How to rent a GPU over remote MCP

An MCP client should look for a compatible running rental first. If reuse is not valid, discover a current GPU string from the live catalog, request a fresh quote, wait for the owner to approve that quote, then start the instance and poll until get_status is running or failed. A lost response or an ambiguous create result does not authorize another allocation: keep the original quote id and any instance id, and do not invent an idempotency key for create_instance. Reconcile those ids. Do not start a second machine blindly.

The copyable reuse check is How to reuse a running GPU over remote MCP. Cap fields, key limits, and quote clocks are in How to set GPU budget caps over remote MCP. The pricing page is the billing source.

Preconditions

The owner authorizes the MCP connection first. Remote Streamable HTTP is https://cloudgpu.app/mcp. Local stdio is the published cloudgpu-mcp 0.16.3 package. Setup is in the MCP guide. After authorization, read the tool list that session returns. Local and remote tool sets differ.

https://cloudgpu.app/.well-known/mcp.json lists the stdio inventory and says the remote tool set excludes local filesystem and SSH. The published server card sets the remote tool count at 23. Those 23 names are not published. An unauthenticated POST https://cloudgpu.app/mcp returns 401 invalid_token, so the session list is the list to use. If a name below is missing from the current session list, skip it and use the documented REST path, or another tool that session actually lists. Do not invent a remote-only command or SSH tool.

connect_account and finish_connect, when listed, are the local stdio key flow. That wording is in the budget-caps guide and the MCP guide. Connecting an account is not approval of a quote.

Check for a reusable rental first

Call get_account and list_instances before a new quote. Both take no parameters in cloudgpu-mcp 0.16.3. Then call get_status on a candidate:

{
  "instance_id": "<id from list_instances>"
}

Reuse only a running rental that already has the needed software or files and still has room inside the original caps. The copyable reuse walkthrough is How to reuse a running GPU over remote MCP. If reuse is not valid, continue below.

Discover a GPU string

list_gpus in cloudgpu-mcp 0.16.3 takes optional min_vram_gb and optional gpu_model. It returns gpu_model, vram_gb, usd_per_gpu_hour, available, and min_gpu_count. The tool description names available as ok, low, or none. That matches OpenAPI GET /v1/gpu/offers, which list_gpus reads. Pass the exact gpu_model string that row returns. Do not shorten it.

{
  "min_vram_gb": "<minimum VRAM the task needs>"
}

usd_per_gpu_hour and available are live price and availability fields. This page does not copy them. The pricing page is the billing source. Read the catalog again before you quote.

GET /v1/public/gpu-catalog needs no key. The agent guide documents gpus[] as model, vram_gb, price_per_gpu_hour_usd, min_gpu_count, availability (available, limited, or unavailable), and tier. price_per_gpu_hour_usd and availability are live fields. This page does not copy them. get_compute_catalog, when listed, reads that catalog and does not rent anything. Use the list_gpus gpu_model string in estimate_cost. The catalog model field is a different name for the same lookup. Reconfirm the string on the day you run.

compare_compute_costs, when listed, compares billed GPU cost for explicit candidates. It does not approve a quote or start a GPU.

Get a quote and wait for approval

Show the owner the quote before any create. A quote is not permission to start. Billing terms come from that quote. The pricing page is the billing source. This page does not restate amounts.

estimate_cost is the quote create_instance accepts. In cloudgpu-mcp 0.16.3 the parameters are gpu_model (the exact list_gpus string), gpu_count (an integer from 1 through 8, default 1), hours, and optional template (a template id from list_templates; omit it for a plain GPU). The client requests POST /v1/gpu/billing-quote, which the MCP guide also names, and returns a local quote_id. Pass that id only to create_instance.

{
  "gpu_model": "<full model string from list_gpus>",
  "gpu_count": "<min_gpu_count from that list_gpus row>",
  "hours": "<expected hours, including preparation and the task>"
}

Read billing_increment_seconds, minimum_charge_usd, preauthorized_usd, and billing_description on the result. suggested_max_spend_usd, when present, is not the owner’s approval and is not a GPU sale price. Set user_confirmed to true only after the owner approves that quote.

quote_compute is a separate server quote. In 0.16.3 it takes estimated_duration_seconds and max_budget_usd, plus optional min_vram_gb, gpu_model, gpu_count, and template. Its description says to pass that quote_id to run_job. The REST call is POST /v1/quotes. Do not pass a quote_compute id to create_instance.

Cap fields (max_spend_usd, max_hours, idle_minutes), key limits, and the quote clocks are in the budget-caps guide. An expired quote does not start a GPU. Get a new quote rather than retrying the old id.

If the current session schema lists billing_quote_id and billing_accepted, pass billing_quote_id only when the response you just received contains it, and set billing_accepted to true only after the owner accepts that quote. On local stdio, create_instance does not take those two fields. After user_confirmed is true, the client attaches the billing quote that estimate_cost stored.

Start the instance

When create_instance is on the current tool list, cloudgpu-mcp 0.16.3 takes quote_id, user_confirmed, max_spend_usd, max_hours, idle_minutes, and optional setup_script. The tool is marked idempotentHint: false. It does not take an idempotency key.

{
  "quote_id": "<quote_id from that estimate_cost>",
  "user_confirmed": true,
  "max_spend_usd": "<example budget cap the owner approved>",
  "max_hours": "<example hour cap the owner approved>",
  "idle_minutes": 60
}

idle_minutes 60 in that example is the schema default, not a value the owner must copy. What the caps mean is in the budget-caps guide.

The documented REST create is POST /v1/gpu/instances. OpenAPI and the agent guide describe gpu_model or template, optional quote_id from POST /v1/quotes, max_minutes, max_spend_usd, and idle_minutes. That call has no idempotency key. The agent guide says the same request sent twice can start two machines.

Do not retry an uncertain allocation. The local client deletes the quote_id when create_instance takes it, so the same id cannot be sent again. If the response is lost, keep that quote id and call list_instances. Look for an instance already created before calling create_instance again. Do not invent a key, and do not request another quote to force a second start while that lookup is unresolved.

Poll get_status with the returned instance_id, and list_instances, until status is running or failed. Documented instance statuses are creating, running, stopped, and failed.

{
  "instance_id": "<id from create_instance or list_instances>"
}

Use the fields the response contains. Do not fill in api_url or a cost. A failed start is not a running rental. Inspect release evidence and do not assume the cost is zero. That check is in How to stop a GPU and verify release over remote MCP.

Jobs and a standing rental

If the next work is a one-shot command, run_job provisions separately, runs one command, and releases that GPU when the command ends. That is not create_instance. run_job takes an idempotency_key. If you omit it, 0.16.3 generates one and returns it. Keep that returned value. A retry uses the same key and the same body. A new key is a new Job. Copyable steps are in How to run a GPU Job over remote MCP. Quotes and Jobs are in GPU Jobs for AI agents.

prepare_job_rerun does not start a GPU and does not reuse the old quote. Saving files is How to save GPU results over remote MCP. Stopping and checking release is How to stop a GPU and verify release over remote MCP.

After it is running

Continue on that instance_id only while the next work stays inside the original caps. Lookup steps are in the reuse guide. Caps stay in the budget-caps guide. Persist results with the save-results guide before release, then follow the stop-and-verify guide. Do not keep an idle GPU running only to consume time that was already authorized.

Exceptions

Local stdio and remote MCP do not expose the same tools. A quote is not a start. An expired quote does not start a GPU; get a new quote rather than retrying the old id. Quote clocks are in the budget-caps guide. create_instance is not idempotent. A lost response does not authorize another allocation. cloudgpu-mcp 0.16.3 has no tool that changes max_spend_usd, max_hours, or idle_minutes on a running rental. Catalog prices and availability are read live. This page does not copy them.

Rent, reuse, and release boundaries are in the rent-and-reuse guide. Tool rules are in AGENTS.md. Connection wording is in the MCP guide and the agent guide. A template-specific ComfyUI start is How to run ComfyUI over remote MCP.

Questions and answers

Should the MCP client quote before looking for a running rental?

No. Call get_account and list_instances, and get_status on a candidate, before requesting a new quote. Reuse only a running rental that already has the needed software or files and still has room inside the original caps. If reuse is not valid, then discover a current GPU string and request a fresh quote.

Is a quote enough to start the GPU?

No. A quote is not permission to start. Wait for the owner to approve that quote, and set user_confirmed to true only after that approval. An expired quote does not start a GPU. Get a new quote rather than retrying the old id. Pass the estimate_cost quote_id to create_instance. Pass the quote_compute quote_id to run_job. Do not swap those ids.

What if the create response is lost?

Keep the original quote id and any instance id. create_instance does not take an idempotency key. Do not invent one, and do not send the request again to start a second machine. Call list_instances and look for an instance already created before calling create_instance again. The local client deletes the quote_id when create_instance takes it. Poll that instance id until get_status is running or failed.

Does run_job replace create_instance?

No. run_job provisions a GPU, runs one command, and releases that GPU when the command ends. create_instance starts a rental you poll until status is running or failed. prepare_job_rerun does not start a GPU and does not reuse the old quote. A one-shot command uses run_job. Further approved work on a rental that is still running uses that instance_id, not a second create_instance.