GPU Jobs for AI Agents: MCP, Budgets and Workspace

An AI agent can use CloudGPU through MCP to discover GPUs, obtain a quote, submit a Job with spending and time limits, check its result and request cancellation. You approve spending; the agent handles the tool calls. Saved Workspace versions let another Job reuse project files. This guide covers the published MCP 0.11.0 workflow and its limits, not a promise that every application or model has been tested.

1. Connect the agent, then approve its access

Your assistant needs a client that supports local MCP servers and Node.js 18 or newer. Add this server using your client’s MCP configuration interface:

{
  "mcpServers": {
    "cloudgpu": {
      "command": "npx",
      "args": ["-y", "cloudgpu-mcp@0.11.0"]
    }
  }
}

Configuration formats differ by client; the MCP installation guide has examples. Restart the MCP client after upgrading. An ordinary chat without these tools cannot acquire them just by opening an account link.

Ask the agent to call connect_account. Open the returned CloudGPU link yourself, check the account, spending limit, concurrency and expiry, and approve only the access you intend to grant. The agent then calls finish_connect. Keep passwords, API keys and signed download links out of the conversation. Access can be revoked from your API account page.

The MCP specification describes tools as discoverable, schema-defined operations; client permissions and human oversight still matter. See the official MCP server concepts.

2. Start with a reviewable task, not a running GPU

Use this prompt as a starting point. Replace the placeholders with your own requirements:

Use CloudGPU to prepare this task. First check whether local CPU execution
is sufficient. If a GPU is needed, show me the selected GPU, current quote,
maximum GPU spend and time limit, command, inputs and output files.
Do not submit until I approve. Do not infer permission for storage charges.
Reuse my saved Workspace version <version-id> if appropriate.

list_task_templates and prepare_task_template work locally without creating a GPU. The published catalog includes GPU inspection, CSV summary, an existing Workspace Python entrypoint, and experimental ComfyUI and small causal-language-model LoRA recipes. Small CSV processing normally belongs on a local CPU.

Preparation does not certify that an image has every dependency. Review the image, model licence, script and output paths before approving. The ComfyUI recipe requires a prepared ComfyUI environment; the LoRA recipe requires prepared CUDA and training dependencies. The latter is not an image or SDXL LoRA template. Local protocol tests do not establish real GPU generation or training quality.

3. Quote, approve and submit one Job

The agent can discover capabilities with get_compute_catalog, request a fresh quote_compute, then submit run_job after you approve the concrete request. GPU stock and prices come from live responses; see current GPU availability and billing details.

Review before submission	Why it matters
GPU and current quote	A model name alone does not establish compatibility or availability
Maximum spend and runtime	Bound the GPU request instead of leaving an open-ended rental
Exact Workspace version and command	Make the input reviewable and repeatable
Explicit result files	Identify what must survive after the GPU is released
Storage eligibility and charges	GPU approval does not automatically approve paid storage

Retain the Job ID and idempotency key. If submission loses its response, reconcile the original request; do not invent a new key to try again. get_job reports status, recorded cost and release evidence. If cancellation is needed, use cancel_job and check the resulting state. A client disconnect does not itself prove that a GPU has been released, and stopping or needs_attention is not a successful release.

4. Save project files and results explicitly

A Workspace version preserves selected project files, not the entire GPU environment. Eligible funded accounts can use save_workspace to save an immutable version, then pass its workspace_version_id into another Job. Read get_storage first for current usage, reserved uploads, quota, retention and any charges.

For results, explicitly request persist_results and the files to collect under $CLOUDGPU_OUTPUT_DIR. Confirm that collection succeeded and retrieve the files before relying on them. Failed uploads, files outside the requested paths and unsaved changes are not a backup.

For an existing manual rental, use the Workspace selection in the rental dialog, then confirm Apply to GPU when the instance is ready. You can also use the Workspace page or MCP list_workspace_instances and apply_workspace. Application copies the selected version into a new project directory; it does not install packages, run the project or restore the whole instance. Rental billing continues during transfer. Budgeted agent keys can only target instances created with that same key.

See saving files before destroying a GPU for alternatives and a final checklist.

5. Reuse a task without confusing reuse with retry

Tell your agent:

Prepare another run of this task using the same saved project version.
Show the previous result and cost, obtain a fresh quote, and wait for
my approval before submitting a new paid Job.

A new run is a new paid request. Keeping the same project files does not keep installed packages or the original GPU alive. Public model references can pin a repository revision and file checksums for download onto the rented GPU. This is not a shared model cache or a guarantee that the files will already be present. The Hugging Face download guide explains revision selection; CloudGPU’s supported reference format is in the agent documentation.

What about a batch of Jobs?

MCP 0.11.0 adds prepare_job_batch, run_job_batch and get_job_batch for 1–8 Jobs. Preparation checks the immutable plan and aggregate GPU budget; submission requires explicit approval of that plan. Keep the original batch key, plan and partial receipts. If an acknowledgement is uncertain, reconcile it with the original keys before proceeding.

A batch can be partially accepted. Already accepted Jobs use the existing backend queue, but unsubmitted members are not a durable batch queue that will resume by themselves. Failed executions are not automatically retried, and storage charges remain separate from the GPU budget. For tool parameters and recovery rules, use the MCP reference.

Try the smallest useful task first

Read the Agent Compute overview, connect an MCP-capable client and ask it to prepare a GPU inspection task without submitting. Approve a paid run only after reviewing the live quote and limits. After that, reuse an explicitly saved project version and compare the actual result and cost; there is no need for a separate task configuration console.