compute-future-reservations
Evaluates future GPU and TPU reservation feasibility and calendar-mode booking options in Google Compute Engine (GCE)
Install / Use
npx skills add google/skills --skill compute-future-reservationsInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Development & EngineeringSupported Platforms
Tags
Our assessment of compute-future-reservations
compute-future-reservations scores 95/100 on our quality scale, 335th of 4,698 Development & Engineering skills we index (top 8%).
Its SKILL.md is 18 KB long, well organised into 21 sections with 5 code examples: a thorough specification that gives an agent plenty to work with.
With 20,340 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so compute-future-reservations is actively maintained.
- Our last check on 2026-11-15 found the source still online.
- It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands (1 minor note below). An AI review of the same text found nothing harmful.
- noteInstalls by piping a downloaded script into a shellline 42
… host installation commands such as `apt-get` or `curl | bash` without explicit user approval; direct the user to the installation guide ins…
AI review by kimi-k2.7-code on 2026-11-15. Automated pattern scan on 2026-11-15. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
compute-future-reservations compared with similar skills
All 4 of these similar skills score higher than compute-future-reservations; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| compute-future-reservations (this skill)by google | 95 | 20.3k | 54d ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| ai-job-searchby ai-job-search-dev | 100 | 72.1k | today | CLAUDE.md |
| claude-howtoby luongnv89 | 100 | 47.3k | 2d ago | CLAUDE.md |
| lobehubby lobehub | 100 | 85.6k | today | MCP Server |
Frequently asked questions
- How do I install compute-future-reservations?
- Run
npx skills add google/skills --skill compute-future-reservations. The install tabs above show the steps for each supported agent. - Which AI agents does compute-future-reservations work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is compute-future-reservations safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands (1 minor note below). An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is compute-future-reservations still maintained?
- The repository was last updated about 2 months ago, so compute-future-reservations is actively maintained.
Skill content
View source on GitHubname: compute-future-reservations metadata: version: "1.0.0" category: Compute description: >- Evaluates future GPU and TPU reservation feasibility and calendar-mode booking options in Google Compute Engine (GCE). Use when planning future AI/ML training runs, checking reservation availability windows, verifying accelerator cluster topologies, or assessing future capacity lead times. Don't use for active on-demand reservations (use compute-on-demand-reservations), immediate Spot capacity queries (use compute-spot-capacity-advice), or Standard Future Reservations (--reservation-mode=DEFAULT).
Compute Engine Future Reservations & Calendar-Mode Feasibility
The compute-future-reservations skill assesses future capacity availability and feasibility for high-demand AI/ML hardware (NVIDIA GPUs, H4D VMs, and Google Cloud TPUs). It enables infrastructure engineers to evaluate future reservation windows, match cluster topologies, and manage calendar-mode bookings.
[!NOTE] Scope Boundary (Calendar Mode vs. Standard Future Reservations): This skill covers Calendar-Mode Future Reservations (
--reservation-mode=CALENDAR, backed by Dynamic Workload Scheduler for up to 90 days on supported families such asa3*,a4*,h4d*, and Cloud TPUs; for newly released machine series, verify Calendar Mode support dynamically viagcloud compute advice calendar-modeor the official Calendar Mode documentation). Do not apply Calendar-Mode flags (--reservation-mode=CALENDAR,--deployment-type=DENSE) to Standard Future Reservations (--reservation-mode=DEFAULTfor general-purpose CPU families,a2*/g2*GPUs,DRAFTplanning workflows, or multi-month/CUD commitments).
Usage Attribution
MUST READ: Before executing any gcloud, REST API, or MCP command, you MUST read and follow the instructions in Usage Attribution.
Prerequisites, IAM & Billing
Before querying calendar-mode advice or submitting future reservation requests, ensure the environment meets these requirements:
- Project & Region Configuration: Prefer passing
--project={project_id}and--region={region}(or--zone={zone}) directly on each command to avoid overwriting global workstation state, or obtain explicit user confirmation before setting defaults (e.g.,us-central1):gcloud config set project {project_id} gcloud config set compute/region {region} - Billing & API Enablement: Ensure the project has an active billing account attached and the Compute Engine API is enabled:
gcloud services enable compute.googleapis.com --project={project_id} - Cloud SDK & Authentication: Ensure the Google Cloud CLI is installed (never execute unprompted host installation commands such as
apt-getorcurl | bashwithout explicit user approval; direct the user to the installation guide instead), then authenticate viagcloud auth login(for interactive CLI),gcloud auth application-default login(for SDKs), orGOOGLE_APPLICATION_CREDENTIALS(for service accounts). - IAM Permissions:
- Feasibility, Creation & Inspection (
advice calendar-mode,create,list,describe,delete): Grantroles/compute.futureReservationUser(includescompute.advice.calendarMode,compute.futureReservations.create,compute.futureReservations.delete,compute.futureReservations.get,compute.futureReservations.list, andcompute.reservations.create, excludingcompute.futureReservations.cancel). - Cancelling Requests (
cancel): Grantroles/compute.futureReservationAdmin(orroles/compute.admin), which is required forcompute.futureReservations.cancel.
- Feasibility, Creation & Inspection (
- Quota & Organization Policy: Submitting a Calendar-Mode request requires 0 reservation quota for GPUs and TPUs, but H4D VMs require sufficient regional CPU quota at submission, and all workloads require sufficient VM/TPU, boot disk, and IP quota at
start-timeto consume the auto-created reservation. Sharing across projects requires allowlisting the host project in organization policyconstraints/compute.sharedReservationsOwnerProjects. - Billing & Pricing Warning: Approved Calendar-Mode Future Reservations automatically provision capacity at
start-timeand bill for the entire committed window whether or not VMs or TPUs are actively running. Review Compute Engine Pricing, Available Regions and Zones, and Google Cloud Locations (strip.md.txtsuffixes when presenting documentation URLs to human users) before submitting requests.
Command Syntax & Reference
1. Evaluate Calendar-Mode Feasibility Advice
Query the optimal time window and zone for a planned block of GPU or TPU capacity:
# For GPU / H4D VMs:
gcloud compute advice calendar-mode \
--project={project_id} \
--region={region} \
--machine-type={machine_type} \
--vm-count={total_instances} \
--start-time-range=from={start_date},to={end_date} \
--duration-range=min={min_duration},max={max_duration} \
[--location-policy={zone}={policy}]
# For Cloud TPUs (supported --tpu-version values: V6E, V5P, V5E; --workload-type is required for V5E):
gcloud compute advice calendar-mode \
--project={project_id} \
--region={region} \
--tpu-version={V6E|V5P|V5E} \
--chip-count={chip_count} \
--start-time-range=from={start_date},to={end_date} \
--duration-range=min={min_duration},max={max_duration} \
[--workload-type={BATCH|SERVING}] \
[--location-policy={zone}={policy}]
2. Inspect Existing Future Reservations
# List planned future reservations
gcloud compute future-reservations list \
--project={project_id} \
[--zones={zone}]
# Inspect a specific future reservation plan
gcloud compute future-reservations describe {future_reservation_name} \
--zone={zone} \
--project={project_id}
3. Create a Calendar-Mode Future Reservation Request
[!IMPORTANT] Submitting a future reservation request (
--planning-status=SUBMITTED) commits to capacity billing once approved. Always obtain explicit human approval before executinggcloud compute future-reservations create.
Once a feasible reservation window and zone are confirmed via calendar-mode, create and submit the request:
# For GPU / H4D VMs (requires --deployment-type=DENSE):
gcloud compute future-reservations create {future_reservation_name} \
--project={project_id} \
--zone={zone} \
--total-count={total_instances} \
--machine-type={machine_type} \
--deployment-type=DENSE \
--reservation-mode=CALENDAR \
--planning-status=SUBMITTED \
--require-specific-reservation \
--reservation-name={reservation_name} \
--start-time={start_rfc3339} \
--end-time={end_rfc3339} \
--auto-delete-auto-created-reservations \
[--share-setting=projects --share-with={consumer_project_ids}]
# For Cloud TPUs:
gcloud compute future-reservations create {future_reservation_name} \
--project={project_id} \
--zone={zone} \
--tpu-version={tpu_version} \
--chip-count={chip_count} \
--reservation-mode=CALENDAR \
--planning-status=SUBMITTED \
--require-specific-reservation \
--reservation-name={reservation_name} \
--start-time={start_rfc3339} \
--end-time={end_rfc3339} \
--auto-delete-auto-created-reservations \
[--workload-type={BATCH|SERVING}] \
[--share-setting=projects --share-with={consumer_project_ids}]
4. Cancel or Delete a Future Reservation (Resource Teardown)
To cancel a pending/submitted request or clean up a cancelled/completed future reservation (requires explicit human approval; cancel requires roles/compute.futureReservationAdmin):
- Cancellation Cutoff (
cancel): AnAPPROVEDCalendar-Mode request can only be self-service cancelled whenstart-timeis at least 30 days (720hours) away, or within 24 hours of submission providedstart-timeis at least 4 days (96hours) away. - Deletion Preconditions (
delete):deleteonly succeeds once the request isCANCELLEDor pastend-time, and prompts interactively unless--quietis passed.
# Cancel a pending or approved future reservation request (within the allowed window)
gcloud compute future-reservations cancel {future_reservation_name} \
--zone={zone} \
--project={project_id}
# Delete a cancelled or completed future reservation record
gcloud compute future-reservations delete {future_reservation_name} \
--zone={zone} \
--project={project_id}
5. Consume the Auto-Created Reservation at start-time
When start-time arrives, Compute Engine automatically provisions the targeted reservation {reservation_name}:
- For GPU / H4D VMs: Launch instances with
--provisioning-model=RESERVATION_BOUND,--maintenance-policy=TERMINATE,--instance-termination-action={STOP|DELETE}, private networking (--no-addresswith IAP TCP forwarding), and a custom least-privilege--service-account:gcloud compute instances create {vm_name} \ --project={project_id} \ --zone={zone} \ --machine-type={machine_type} \ --reservation-affinity=specific \ --reservation={reservation_name} \ --provisioning-model=RESERVATION_BOUND \ --maintenance-policy=TERMINATE \ --instance-termination-action=DELETE \ [--no-address] \ [--service-account={service_account_email}] - For Cloud TPUs: Consume the auto-created reservation via the Compute Engine API using
gcloud compute instances createor a Compute Engine Managed Instance Group (gcloud compute instance-templates create+gcloud compute instance-groups managed create) with the TPU machine type (e.g.,ct6e-standard-8t),--reservation-affinity=specific,--reservation=projects/{project_id}/reservations/{reservation_name},--provisioning-model=RESERVATION_BOUND, and--maintenance-policy=TERMINATE(see Consume a TPU reservation).
Key Parameters & Planning Dimensions
- Calendar-Mode Query Flags:
--start-time-range=from={start_date},to={end_date}: Required acceptable start window in date or RFC 3339 format (e.g.,from=2026-11-01T00:00:00Z,to=2026-11-30T00:00:00Z).--duration-range=min={min_duration},max={max_duration}: Required minimum and maximum operational duration needed (e.g.,min=7d,max=14dormin=14d,max=14d). Bothminandmaxmust be provided.--location-policy={zone}={policy}: Optional per-zone inclusion/exclusion policy (ALLOWorDENY, e.g.,us-central1-a=ALLOW,us-central1-b=DENY).--tpu-version={V6E|V5P|V5E}: Supported TPU versions inadvice calendar-mode(TPU7Xis supported only infuture-reservations create, not inadvice calendar-mode).--workload-type={BATCH|SERVING}: Required when--tpu-version=V5Eand optional forV6EandV5P.BATCHoptimizes for high-throughput batch ML training;SERVINGoptimizes for low-latency concurrent ML inference requests. Do not specify for GPU or H4D VMs.
- Calendar-Mode Reservation Creation Flags:
--reservation-mode=CALENDAR: Required to create a Calendar-Mode future reservation.--planning-status=SUBMITTED: Required to submit the Calendar-Mode request for GCP review immediately (self-service Calendar-Mode requests rejectDRAFTstatus).--require-specific-reservation&--reservation-name={reservation_name}: Required to name and target the reservation that Compute Engine automatically creates atstart-time({reservation_name}must be at most 38 characters, e.g.,{future_reservation_name}-res).- `--deployme
Truncated for display — read the full file on GitHub.
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
ai-job-search
72.1kThe job search that runs on your machine. AI job application framework built on Claude Code: evaluate postings, tailor CVs, write cover letters, prep interviews. Fork it and own it.
claude-howto
47.3kA visual, example-driven guide to Claude Code — from basic concepts to advanced agents, with copy-paste templates that bring immediate value.
lobehub
85.6k🤯 LobeHub - Super-Agents on Your Team. Add super-agents to the chats your team already uses.They take on work by themselves and get better every week.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
