# CloudGPU MCP (npm · cloudgpu-mcp)

Agent GPU compute scheduling: compare billing, approve budgets, run tasks and persist results.

- Trust score: 69/100 (medium)
- Change this week: −6
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- remote · `cloudgpu.app`: 38/100, [markdown](https://verifymcp.io/servers/cloudgpu-app-cloudgpu-mcp/cloudgpu.md), [page](https://verifymcp.io/servers/cloudgpu-app-cloudgpu-mcp/cloudgpu)
- npm · `cloudgpu-mcp`: 69/100 (this document), [markdown](https://verifymcp.io/servers/cloudgpu-app-cloudgpu-mcp/cloudgpu-mcp.md), [page](https://verifymcp.io/servers/cloudgpu-app-cloudgpu-mcp/cloudgpu-mcp)

## Channel facts

- Registry: `npm`
- Package: `cloudgpu-mcp`
- Version: `0.16.8`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Supply Chain Security**: 48/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 34 of 99 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to cloudgpu-app/cloudgpu-mcp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 78/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Tool/resource definitions use about 5957 tokens (~97/item across 61 items; 60 tools + 1 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 30/100
  - Stability observed for 9 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 74/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 22% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 62 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the CloudGPU MCP server?

CloudGPU MCP runs locally as an npm package, launched with npx -y cloudgpu-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add cloudgpu-app-cloudgpu-mcp -- npx -y cloudgpu-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "cloudgpu-app-cloudgpu-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "cloudgpu-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "cloudgpu-app-cloudgpu-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "cloudgpu-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add cloudgpu-app-cloudgpu-mcp -- npx -y cloudgpu-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "cloudgpu-app-cloudgpu-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "cloudgpu-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add cloudgpu-app-cloudgpu-mcp --command npx --arg -y --arg cloudgpu-mcp
```

### Hermes

```yaml
mcp_servers:
  cloudgpu-app-cloudgpu-mcp:
    command: "npx"
    args: ["-y", "cloudgpu-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "cloudgpu-app-cloudgpu-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "cloudgpu-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add cloudgpu-app-cloudgpu-mcp -t stdio -c npx -a -y cloudgpu-mcp
```

### Other

```json
{
  "mcpServers": {
    "cloudgpu-app-cloudgpu-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "cloudgpu-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-21 (score 69, +11)

- [security improvement] Malware scan: unverified → pass
- [security improvement] Known CVEs: unverified → pass
- [functional improvement] Dependency health: unverified → 0.84
- [functional improvement] Dependency health: unverified → 0.83
- [functional] Package version: 0.16.7 → 0.16.8

### 2026-11-20 (score 58, −25)

- [security regression] Malware scan: pass → unverified
- [security regression] Known CVEs: pass → unverified
- [functional regression] Dependency health: 0.83 → unverified
- [functional] Package version: 0.16.6 → 0.16.7

### 2026-11-19 (score 83, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-18 (score 82, +26)

- [security improvement] CVE-2023-54404 no longer affects this package
- [security improvement] Malware scan: unverified → pass
- [security improvement] Known CVEs: unverified → pass
- [functional improvement] Dependency health: unverified → 0.84

### 2026-11-17 (score 56, −20)

- [security regression] Known CVEs: fail → unverified
- [security regression] Malware scan: pass → unverified
- [functional regression] Dependency health: 0.84 → unverified
- [functional] Package version: 0.16.3 → 0.16.6
- [functional] Package version: 0.16.3 → 0.16.5

### 2026-11-15 (score 76, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-14 (score 75, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-13 (score 60, −14)

- [security regression] Malware scan: pass → unverified
- [security regression] Known CVEs: fail → unverified
- [security regression] Stability: 0.00 → unverified
- [security regression] Tool safety: pass → unverified
- [functional regression] Schema quality: 4217 → 5394
- [functional regression] Schema quality: 4217 → 5061
- [functional regression] Schema quality: 4217 → 5052
- [functional regression] Dependency health: 0.84 → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional] Package version: 0.13.1 → 0.16.3
- [functional] Package version: 0.13.1 → 0.16.2
- [functional] Package version: 0.13.1 → 0.16.1
- [functional] Package version: 0.13.1 → 0.15.0
- [functional] Package version: 0.13.1 → 0.14.1

## MCP tools (60)

### `request_top_up` (~58 tokens)

Request an owner payment link

Creates a short-lived link only. No checkout, card charge or transfer is made. Show the link to the human owner; never complete payment for them. Payment completion does not approve a GPU quote.

Input parameters:

- `amount_usd` (number, required)

### `wait_for_funds` (~69 tokens)

Wait for credited account funds

Read-only polling of actual account balance and real-top-up signal for up to 60 seconds. No payment, job submission or authorization. If still pending, return to the owner; do not blindly repeat rentals.

Input parameters:

- `min_balance_usd` (number, required)
- `timeout` (integer)

### `get_agent_readiness` (~44 tokens)

Read-only Agent self-check

No login or spending: capabilities, source-specific billing, task prerequisites, limitations, recent aggregate Job evidence and known issues. Unknown data is not a healthy or verified result.

### `assess_task_fit` (~93 tokens)

Assess whether a task fits CloudGPU

Read-only task suitability before quoting a GPU. Returns blockers, unverified requirements and evidence status; does not benchmark, approve spending or guarantee availability.

Input parameters:

- `expected_output_bytes` (integer)
- `needs_persistent_outputs` (boolean)
- `requires_kernel_control` (boolean)
- `requires_nested_virtualization` (boolean)
- `requires_resale` (boolean)
- `task_type` (string, required)

### `list_rental_regions` (~68 tokens)

List rentable GPUs by continent

Read-only qualified continent catalog shared with the rental UI. Use enabled and inventory/capability/count constraints. Request estimate_cost with the same continent before renting. Countries and individual datacenters are not selectable. Empty inventory does not authorize renting in another continent.

Input parameters:

- `continent` (string)

### `list_regional_offers` (~191 tokens)

Inspect regional compute observations

Anonymous, read-only native regional stock observations, independent price evidence ages, billing references and known/unknown limits. Supply the human owner's country explicitly; the Agent server IP is not its owner's location. Counts are not reservations or verified single-host multi-GPU allocations. Published SKU references are not region-bound executable quotes; these observations are not executable quotes. Use list_rental_regions and estimate_cost for enabled continent-constrained rentals; exact countries/datacenters are unsupported. Unsupported, stale or failed observations do not prove global stockout. Follow has_more/next_after_id; pagination is a live view, not a frozen snapshot.

Input parameters:

- `after_id` (string)
- `country_code` (string)
- `gpu_count` (integer)
- `gpu_model` (string)
- `include_unavailable` (boolean)
- `limit` (integer)
- `user_country` (string)

### `list_task_templates` (~41 tokens)

List reusable Job task drafts

Public, local and read-only. Inspect small task recipes and requirements before quoting. Does not call an API, rent a GPU, install dependencies or reserve capacity.

### `prepare_task_template` (~200 tokens)

Prepare a Job task draft

Local preparation only. Returns a command and optional Workspace/output fields; never submits or spends money. Quote, explicit GPU/budget/time approval and existing storage consent are still required by run_job. No guaranteed application compatibility or automatic retry.

Input parameters:

- `accept_storage_charges` (boolean)
- `comfy_port` (integer)
- `dataset_path` (string)
- `entrypoint` (string)
- `image_count` (integer)
- `input_path` (string)
- `learning_rate` (number)
- `model_reference` (object)
- `output_files` (array)
- `persist_results` (boolean)
- `rank` (integer)
- `sequence_length` (integer)
- `steps` (integer)
- `target_modules` (array)
- `template_id` (string, required)
- `timeout_seconds` (integer)
- `workflow_path` (string)
- `workspace_version_id` (string)

### `compare_compute_costs` (~98 tokens)

Compare GPU billing periods and estimated task costs

Read-only live quote comparison for up to eight explicit compatible GPU candidates. Accounts for minimum one-hour versus per-minute billing. No capacity reservation, GPU creation, benchmark, automatic selection or approval. Run estimate_cost for the selected rental afterward.

Input parameters:

- `gpu_count` (integer)
- `gpu_models` (array, required)
- `hours` (number, required)
- `max_spend_usd` (number, required)
- `template` (string)

### `prepare_task_pipeline` (~96 tokens)

Prepare sequential tasks for one GPU allocation

Local read-only preparation of 1–8 reviewed commands for one bounded Job or an approved existing rental. Reuses GPU and disk across steps; stops on the first error. Does not create, retry, install dependencies, approve spending or change an instance lifecycle. Summary persistence is optional and never implies paid-storage consent.

Input parameters:

- `persist_summary` (boolean)
- `steps` (array, required)
- `workspace_version_id` (string)

### `get_job_batch_receipt` (~77 tokens)

Read a private local batch receipt

Read only saved accepted Job IDs and uncertain submission intents for the original batch key, API key and endpoint. No API request or GPU creation. Local state is historical, not live release evidence; a missing entry does not prove non-creation. Commands, tokens and signed URLs are never stored.

Input parameters:

- `batch_key` (string, required)

### `prepare_job_batch` (~77 tokens)

Review a bounded Job batch

Local, read-only preparation for up to eight Jobs with fresh per-Job quotes and one aggregate cap. No API requests, reservations, installations or automatic execution retries. Retain the immutable plan hash and batch key.

Input parameters:

- `batch_key` (string, required)
- `jobs` (array, required)
- `total_budget_usd` (number, required)

### `get_job_batch` (~42 tokens)

Inspect a Job batch

Read-only status and cost summary for explicit Job IDs. Does not retry, cancel, create or claim independent supplier release verification.

Input parameters:

- `job_ids` (array, required)

### `get_server_job_batch` (~40 tokens)

Read a durable server batch

Read persisted child Job states and costs after either client or server restarts. Does not create or retry resources.

Input parameters:

- `batch_id` (string, required)

### `run_server_job_batch` (~113 tokens)

Atomically enqueue an approved server batch

Paid. Use the exact reviewed prepare_job_batch manifest/hash. Enqueue is atomic and persists on the server; each Job reserves its own budget and waits for account/key concurrency. No automatic command retries and no partial client-side fallback. Whole-hour Jobs require a separate accepted current billing quote per allocation.

Input parameters:

- `approved_plan_sha256` (string, required)
- `batch_key` (string, required)
- `jobs` (array, required)
- `total_budget_usd` (number, required)
- `user_confirmed` (boolean, required)

### `cancel_server_job_batch` (~54 tokens)

Cancel a server batch

Cancel queued children without starting a GPU; request safe shutdown of active children. Preserve outputs first. Previously started whole-hour charges remain payable.

Input parameters:

- `batch_id` (string, required)
- `user_confirmed` (boolean, required)

### `run_job_batch` (~120 tokens)

Submit an approved bounded Job batch

Paid: submit an explicitly approved immutable manifest using existing durable Jobs, each with a quote, budget and deadline. Aggregate worst-case budget is capped. Partial success is possible. On lost responses replay the IDENTICAL manifest/key; never create replacement GPUs or retry failed execution automatically. Persist the returned receipt. No transaction rollback or independent batch scheduler.

Input parameters:

- `approved_plan_sha256` (string, required)
- `batch_key` (string, required)
- `jobs` (array, required)
- `total_budget_usd` (number, required)
- `user_confirmed` (boolean, required)

### `get_storage` (~25 tokens)

Persistent storage quota

Storage availability, used bytes, reserved uploads and account quota. No money is spent.

### `list_files` (~25 tokens)

List persistent files

Persistent artifacts, model/data files and Workspace files. Availability depends on storage being enabled.

### `list_workspaces` (~20 tokens)

List Workspaces

Saved project Workspaces; versions are immutable file manifests.

### `list_workspace_versions` (~26 tokens)

List Workspace versions

List saved immutable versions of an owned Workspace.

Input parameters:

- `workspace_id` (string, required)

### `get_workspace_version` (~28 tokens)

Read Workspace version

Read the path-to-file manifest for an owned version.

Input parameters:

- `version_id` (string, required)

### `list_workspace_instances` (~32 tokens)

Running GPUs for Workspace restore

Lists your running GPUs that this key may access. Budgeted Agent keys only see instances created by the same key.

### `get_workspace_application` (~57 tokens)

Workspace application status

Check file restoration on an existing GPU. This does not create, stop or restart a GPU. An uncertain result must be checked, never automatically resubmitted.

Input parameters:

- `instance_id` (string, required)
- `version_id` (string, required)

### `quote_storage_budget` (~75 tokens)

Quote separate storage budget

Quote reserving GPU wallet funds for persistent storage, or returning unused surplus. No transfer yet. Shows USD rate, budget-based capacity and 30-day file expiry. Budget-limited keys cannot move funds; ask owner to use Web or unrestricted key.

Input parameters:

- `action` (string, required)
- `amount_usd` (number, required)

### `confirm_storage_budget` (~64 tokens)

Confirm storage budget transfer

Moves wallet funds only after the user approves the exact quote. Retrying the same quote cannot transfer twice. Reservation is not billed usage; daily actual peak consumes the budget. Never approve automatically.

Input parameters:

- `quote_id` (string, required)
- `user_confirmed` (boolean, required)

### `resume_artifact_upload` (~73 tokens)

Resume interrupted file upload

Resume the same unexpired multipart reservation. Requires the original SHA-256 reported when upload paused. Skips completed parts; renews expiring URLs. Never mixes changed files or creates another reservation.

Input parameters:

- `file_id` (string, required)
- `local_path` (string, required)
- `sha256` (string, required)

### `apply_workspace` (~106 tokens)

Apply Workspace to running GPU

Restore project files to a new private directory on your existing running GPU. Does not install dependencies, execute code, overwrite existing files, rent, restart or stop a GPU. GPU rental billing continues; transfer consumes its network and disk. Ask the user before applying. Repeat requests for the same version and instance return the existing result; failures require inspection, not automatic retries.

Input parameters:

- `instance_id` (string, required)
- `user_confirmed` (boolean, required)
- `version_id` (string, required)

### `delete_workspace_version` (~49 tokens)

Delete Workspace version

Deletes a saved version, releasing its file references. Refuses versions pinned by active Jobs. Ask the user first.

Input parameters:

- `user_confirmed` (boolean, required)
- `version_id` (string, required)

### `upload_artifact` (~85 tokens)

Save a persistent artifact

Uploads a local regular file in resumable-sized parts. Consumes storage quota; retention and pricing depend on the account policy. Credential files are refused.

Input parameters:

- `accept_storage_charges` (boolean): Read get_storage pricing first. Set true only after the user agrees to paid storage above the included allowance.
- `local_path` (string, required)
- `purpose` (string)

### `download_artifact` (~41 tokens)

Download a persistent file

Streams a persistent file to this computer. Never overwrites an existing local file.

Input parameters:

- `file_id` (string, required)
- `local_path` (string, required)

### `save_workspace` (~109 tokens)

Save a project Workspace

Saves 1–100 regular project files as an immutable version. Refuses secrets and symlinks; skips .git, node_modules, __pycache__ and .venv. Save dependency manifests, not the operating system. Pass the returned workspace_version_id to run_job.

Input parameters:

- `accept_storage_charges` (boolean): Read get_storage pricing and obtain user agreement before enabling paid storage.
- `local_dir` (string, required)
- `name` (string, required)
- `workspace_id` (string)

### `delete_file` (~48 tokens)

Delete a persistent file

Permanently deletes a persistent file or cancels an unfinished upload. Files pinned by a Workspace version cannot be deleted.

Input parameters:

- `file_id` (string, required)
- `user_confirmed` (boolean, required)

### `diagnose_job` (~50 tokens)

Inspect Job failure and cost state

Read-only Job diagnosis and observed platform instance state. Never creates, stops or retries a GPU. Does not claim supplier release verification or classify every command failure as user error.

Input parameters:

- `job_id` (string, required)

### `save_job_output` (~127 tokens)

Save ended Job output tail

With approval, persist the ended Job log tail as a small Artifact using existing storage quota and retention. This is not the full log or binary output collection. Refuses recognizable credentials, quoted/aliased fields and bounded escaped representations or queried URLs. This is not a guarantee that arbitrary logs contain no secrets; save only logs you know are sanitized. Never touches GPU resources. Reuses a matching verified snapshot when found; cross-client concurrent calls may create duplicates.

Input parameters:

- `accept_storage_charges` (boolean)
- `job_id` (string, required)
- `user_confirmed` (boolean, required)

### `get_compute_catalog` (~25 tokens)

Public GPU catalog

GPU catalog, templates and billing without an API key. Does not rent anything.

### `quote_compute` (~122 tokens)

Server-side compute quote

Compare minute and whole-hour Job estimates, minimum charges and starting balances. No GPU is started. Use job_billing_options to compare cost for your duration, then call quote_job_billing for the selected period. The legacy quote_id still supports minute-only Jobs.

Input parameters:

- `disk_gb` (integer)
- `estimated_duration_seconds` (integer, required)
- `gpu_count` (integer)
- `gpu_model` (string)
- `max_budget_usd` (number, required)
- `min_vram_gb` (integer)
- `template` (string)

### `quote_job_billing` (~107 tokens)

Quote the selected Job billing period

Read-only. Use the exact Job configuration and selected billing period from quote_compute. Show the returned billing period, minimum charge and hourly total. Obtain explicit approval before sending billingQuoteId as billing_quote_id with billing_accepted=true to run_job.

Input parameters:

- `billing_increment_seconds` (required)
- `disk_gb` (integer)
- `gpu_count` (integer)
- `gpu_model` (string, required)
- `template` (string)
- `workspace_restore_required` (boolean)

### `get_account` (~29 tokens)

CloudGPU account

Balance in USD, how many instances this account may run at once, and how many are running now.

### `list_gpus` (~110 tokens)

List GPUs

GPU catalog with per-card VRAM, live starting price in USD, availability, and native configurations (GPU count, CPU, RAM, disks, region, interconnect and whole-instance price) when provided. Unavailable models remain discoverable. Request an exact quote before renting.

Input parameters:

- `gpu_model` (string): Filter by name, e.g. 4090, A100, H20
- `min_vram_gb` (number): Only GPUs with at least this much VRAM per card

### `list_templates` (~51 tokens)

List templates

Ready-made instance images (e.g. JupyterLab, Ollama, ComfyUI, LLaMA-Factory) with the GPU each recommends. Templates with has_api_endpoint get a public HTTPS api_url.

### `estimate_cost` (~147 tokens)

Quote a rental

Live price and estimated cost for a GPU, plus your balance after it. Returns a quote_id that create_instance needs. Show the quote to the user and get an explicit yes before renting.

Input parameters:

- `continent` (string): Hard continent constraint, from list_rental_regions
- `gpu_count` (integer)
- `gpu_model` (string, required): GPU model exactly as list_gpus returns it
- `hours` (number, required): Expected run time in hours
- `template` (string): Template id from list_templates; omit for a plain GPU with Python and CUDA
- `workspace_restore_required` (boolean): Reserve a rental for restoring a saved Workspace. Excludes suppliers with known impaired restore routes.

### `list_models` (~49 tokens)

List hosted models

Models on CloudGPU's OpenAI-compatible API (same key, same balance). Use them from code with base_url https://cloudgpu.app/v1 instead of renting a GPU when you only need inference.

### `connect_account` (~146 tokens)

Connect this assistant to a CloudGPU account

Use when there is no API key. Starts an approval request and returns a link. The user opens it, signs in to cloudgpu.app and approves this assistant with a spending limit and a maximum number of GPUs at once; CloudGPU's servers enforce both. Then call finish_connect. No money is spent.

Input parameters:

- `agent_name` (string, required): How the user will recognise this assistant, e.g. 'Claude Code on Yang's laptop'
- `expires_in_days` (integer)
- `max_concurrent` (integer): GPUs or jobs this key may run at once
- `spend_limit_usd` (number, required): Total this key may ever spend, in USD; ask the user

### `finish_connect` (~65 tokens)

Finish connecting

After the user approved the link from connect_account: waits up to about a minute for the approval, then stores the new key on this computer (~/.config/cloudgpu/credentials.json, readable only by the user) and uses it from now on. The key itself is never shown.

### `get_job` (~62 tokens)

Job status

Status of a job (queued / provisioning / running / stopping / succeeded / failed / cancelled / needs_attention), exit code, cost so far, the last ~4 KB of the command's output and the job's event history.

Input parameters:

- `job_id` (string, required)

### `list_jobs` (~25 tokens)

List jobs

Recent jobs on this account with status and cost.

Input parameters:

- `limit` (integer)

### `get_status` (~55 tokens)

Instance status

Status (creating / running / stopped / failed), minutes run, cost so far, whether SSH is ready, the public api_url if the template has one, and the auto-shutdown limits.

Input parameters:

- `instance_id` (string, required)

### `list_instances` (~30 tokens)

List instances

Instances on this account: running, starting, and those stopped in the last 7 days, with cost.

### `create_instance` (~252 tokens)

Rent a GPU

Rents the GPU from a quote. Costs money. Requires a quote_id from estimate_cost that the user has approved. max_spend_usd and max_hours are enforced by CloudGPU's servers: the instance is destroyed when either is reached, even if this assistant has disconnected. idle_minutes destroys it after the GPU sits idle that long (installing packages and downloading data count as idle, so allow for setup). setup_script (optional bash) runs once as root after the instance is handed over; its output is in /root/cloudgpu-setup.log.

Input parameters:

- `idle_minutes` (integer): Destroy after the GPU has been idle this long; 0 turns it off; otherwise at least 10
- `max_hours` (number, required): Hard time limit in hours (at most 24)
- `max_spend_usd` (number, required): Budget for this instance in USD (at most 50)
- `quote_id` (string, required)
- `setup_script` (string): Optional bash script run once as root in the background after the instance is handed over; output in /root/cloudgpu-setup.log
- `user_confirmed` (boolean, required): true only if the user explicitly approved this quote in the conversation

### `resolve_model_reference` (~91 tokens)

Pin a public model reference

Read-only. Resolve a public Hugging Face model revision and explicit file list to immutable commit, sizes and available LFS SHA-256 checksums. Does not download weights, rent a GPU or authenticate to Hugging Face. Review model license and application compatibility separately.

Input parameters:

- `files` (array, required)
- `name` (string, required)
- `repo_id` (string, required)
- `revision` (string)

### `prepare_model_deployment` (~129 tokens)

Prepare models and a ComfyUI workflow

Preparation only; no GPU is started. Create a reviewed setup script for the existing ComfyUI template. Downloads go from the public model host directly to the rented GPU, never through CloudGPU storage. Use model names as categories (checkpoints, loras, vae, diffusion_models, text_encoders, clip, controlnet, upscale_models). Does not install custom nodes, execute workflows, accept licenses for the user, or promise compatibility. Pass the setup_script only after explicit approval to the existing deployment flow.

Input parameters:

- `model_references` (array, required)
- `workflow` (object)

### `prepare_job_rerun` (~69 tokens)

Prepare a successful job for rerun

Read-only. Retrieve the original command, pinned model references and Workspace without starting anything. Request a fresh quote, check Workspace expiry and obtain explicit budget approval before calling run_job with a NEW idempotency key. Never reuse the old quote or key.

Input parameters:

- `job_id` (string, required)

### `run_job` (~556 tokens)

Run a job on a GPU

Costs money. CloudGPU starts a GPU, runs one bash command on it, then destroys the GPU, all on its servers, so it finishes even if this assistant disconnects. max_spend_usd and max_hours are enforced by the servers. Retrying with the same idempotency_key never starts a second GPU; this tool generates one if you leave it out and returns it. The disk is erased when the job ends. When automatic_output_collection is available, declare outputs and write only those files under $CLOUDGPU_OUTPUT_DIR for persistent storage before release. Otherwise upload results yourself or print them. Storage retention and fees follow the account policy; collection consumes the same GPU budget and may fail. Requires the user's explicit yes on the GPU, budget and time limit.

Input parameters:

- `billing_accepted` (boolean): true only after the user accepts the quoted minimum and billing period; budget must cover that minimum
- `billing_quote_id` (string): Accepted source-specific billing quote from estimate_cost; expires after five minutes. Required for whole-hour sources.
- `command` (string, required): bash command or script to run on the GPU
- `disk_gb` (integer): Larger system disk: 100, 200 or 500; omit for the standard disk
- `gpu_count` (integer)
- `gpu_model` (string): GPU model exactly as list_gpus returns it
- `idempotency_key` (string): Reuse the same value when retrying the same job
- `max_hours` (number, required): Hard time limit in hours (at most 24)
- `max_spend_usd` (number, required): Budget for this job in USD (at most 50)
- `model_references` (array): Pinned public model references from resolve_model_reference. Downloads into $CLOUDGPU_MODEL_DIR/<name> before the command; download time consumes the same GPU budget. No R2 cache or remote repository…
- `outputs` (object): Explicit relative output files under $CLOUDGPU_OUTPUT_DIR; no globs, symlinks, hidden or credential files. Default total limit 10 MiB, maximum 100 MiB. Only set accept_storage_charges=true after the…
- `quote_id` (string): Server quote from quote_compute, starting quote_; binds configuration and checks price at submission
- `template` (string): Template id from list_templates
- `user_confirmed` (boolean, required): true only if the user explicitly approved the GPU, budget and time limit
- `workspace_version_id` (string): Immutable Workspace version to restore before the command; requires enabled persistent storage

### `cancel_job` (~42 tokens)

Cancel a job

Stops a job: if a GPU was started it is destroyed and billing stops. Output not yet uploaded by the command is lost.

Input parameters:

- `job_id` (string, required)

### `run_command` (~122 tokens)

Run a command on the instance

Runs a bash command on the instance as root, in an interactive-style shell so conda/venv from ~/.bashrc are active. Foreground returns the exit code and the last 20k characters of output. For anything longer than a few minutes (training, big downloads) use background=true, then tail_logs.

Input parameters:

- `background` (boolean)
- `command` (string, required): bash command or script
- `instance_id` (string, required)
- `timeout_sec` (integer): Foreground only
- `workdir` (string): Directory to run in

### `upload` (~108 tokens)

Upload to the instance

Copies a local file or directory (this computer) to the instance over SFTP. node_modules, .git and __pycache__ are skipped. Credentials files (.ssh, .env, keys) are refused unless allow_sensitive is true and the user asked for it.

Input parameters:

- `allow_sensitive` (boolean)
- `instance_id` (string, required)
- `local_path` (string, required)
- `remote_path` (string, required): Destination on the instance, e.g. /root/project or /root/data/

### `download` (~71 tokens)

Download from the instance

Copies a file or directory from the instance to this computer. Do this for every result before stop_instance: destroying an instance erases its disk.

Input parameters:

- `instance_id` (string, required)
- `local_path` (string, required): Local destination file or directory, e.g. ./outputs/
- `remote_path` (string, required)

### `tail_logs` (~75 tokens)

Job logs and GPU use

Last lines of a background job's log (job_id) or any log file (path), whether the job is still running and its exit code, plus current GPU utilisation and memory.

Input parameters:

- `instance_id` (string, required)
- `job_id` (string)
- `lines` (integer)
- `path` (string)

### `stop_instance` (~68 tokens)

Destroy an instance

Destroys the instance and stops billing. Its disk is erased. If commands were run on it in this session and nothing was downloaded, this refuses unless force=true (only after the user confirms the results are not needed).

Input parameters:

- `force` (boolean)
- `instance_id` (string, required)

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/cloudgpu-app-cloudgpu-mcp/cloudgpu-mcp#diagnostics

## Score history

- 2026-11-21: 69
- 2026-11-20: 58
- 2026-11-19: 83
- 2026-11-18: 82
- 2026-11-17: 56
- 2026-11-16: 76
- 2026-11-15: 76
- 2026-11-14: 75
- 2026-11-13: 60
- 2026-11-12: 74

## Common questions

### What is the CloudGPU MCP server?

CloudGPU MCP is listed in the public MCP registry as io.github.cloudgpu-app/cloudgpu-mcp. Agent GPU compute scheduling: compare billing, approve budgets, run tasks and persist results. This page covers its npm package (cloudgpu-mcp).

### Is the CloudGPU MCP server safe to use?

CloudGPU MCP scores 69 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the CloudGPU MCP server expose?

CloudGPU MCP exposes 60 tools: request_top_up, wait_for_funds, get_agent_readiness, assess_task_fit, list_rental_regions, and 55 more. Their descriptions and schemas cost roughly 5,127 tokens of context every time the server is loaded.

### Is the CloudGPU MCP server still maintained?

CloudGPU MCP is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the CloudGPU MCP server under?

CloudGPU MCP declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the CloudGPU MCP server?

VerifyMCP ran 15 checks on CloudGPU MCP, covering Known CVEs, Install scripts, Dependency health, Source repository and 11 more. One item could not be completed, a gap on our side rather than a finding about CloudGPU MCP: Malware scan. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/cloudgpu-mcp
- Socket report: https://socket.dev/npm/package/cloudgpu-mcp
- Repository: https://github.com/cloudgpu-app/cloudgpu-mcp
- Website: https://cloudgpu.app/docs/mcp
- Changelog RSS feed: https://verifymcp.io/servers/cloudgpu-app-cloudgpu-mcp/cloudgpu-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/cloudgpu-app-cloudgpu-mcp/cloudgpu-mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/cloudgpu-app-cloudgpu-mcp/cloudgpu-mcp.json
- HTML version of this page: https://verifymcp.io/servers/cloudgpu-app-cloudgpu-mcp/cloudgpu-mcp
