SkillAgentSearch skills...

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-reservations

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

95/100

Supported Platforms

Universal

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.

Substance
30/30
Structure
20/20
Description
12/15
Adoption
18/20
Freshness
15/15

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 found

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.

  • 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.

SkillScoreStarsUpdatedFormat
compute-future-reservations (this skill)by google9520.3k54d agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
ai-job-searchby ai-job-search-dev10072.1ktodayCLAUDE.md
claude-howtoby luongnv8910047.3k2d agoCLAUDE.md
lobehubby lobehub10085.6ktodayMCP 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.

name: 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 as a3*, a4*, h4d*, and Cloud TPUs; for newly released machine series, verify Calendar Mode support dynamically via gcloud compute advice calendar-mode or the official Calendar Mode documentation). Do not apply Calendar-Mode flags (--reservation-mode=CALENDAR, --deployment-type=DENSE) to Standard Future Reservations (--reservation-mode=DEFAULT for general-purpose CPU families, a2*/g2* GPUs, DRAFT planning 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:

  1. 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}
    
  2. 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}
    
  3. Cloud SDK & Authentication: Ensure the Google Cloud CLI is installed (never execute unprompted host installation commands such as apt-get or curl | bash without explicit user approval; direct the user to the installation guide instead), then authenticate via gcloud auth login (for interactive CLI), gcloud auth application-default login (for SDKs), or GOOGLE_APPLICATION_CREDENTIALS (for service accounts).
  4. IAM Permissions:
    • Feasibility, Creation & Inspection (advice calendar-mode, create, list, describe, delete): Grant roles/compute.futureReservationUser (includes compute.advice.calendarMode, compute.futureReservations.create, compute.futureReservations.delete, compute.futureReservations.get, compute.futureReservations.list, and compute.reservations.create, excluding compute.futureReservations.cancel).
    • Cancelling Requests (cancel): Grant roles/compute.futureReservationAdmin (or roles/compute.admin), which is required for compute.futureReservations.cancel.
  5. 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-time to consume the auto-created reservation. Sharing across projects requires allowlisting the host project in organization policy constraints/compute.sharedReservationsOwnerProjects.
  6. Billing & Pricing Warning: Approved Calendar-Mode Future Reservations automatically provision capacity at start-time and 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.txt suffixes 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 executing gcloud 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): An APPROVED Calendar-Mode request can only be self-service cancelled when start-time is at least 30 days (720 hours) away, or within 24 hours of submission provided start-time is at least 4 days (96 hours) away.
  • Deletion Preconditions (delete): delete only succeeds once the request is CANCELLED or past end-time, and prompts interactively unless --quiet is 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-address with 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 create or 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=14d or min=14d,max=14d). Both min and max must be provided.
    • --location-policy={zone}={policy}: Optional per-zone inclusion/exclusion policy (ALLOW or DENY, e.g., us-central1-a=ALLOW,us-central1-b=DENY).
    • --tpu-version={V6E|V5P|V5E}: Supported TPU versions in advice calendar-mode (TPU7X is supported only in future-reservations create, not in advice calendar-mode).
    • --workload-type={BATCH|SERVING}: Required when --tpu-version=V5E and optional for V6E and V5P. BATCH optimizes for high-throughput batch ML training; SERVING optimizes 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 reject DRAFT status).
    • --require-specific-reservation & --reservation-name={reservation_name}: Required to name and target the reservation that Compute Engine automatically creates at start-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

View on GitHub
GitHub Stars20.3k
CategoryDevelopment
Updated1mo ago
Forks1.7k

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions