# Arrakis (remote · arrakis.goodailabs.com)

Rent GPUs at live prices and serve any Hugging Face model, with spend caps for AI agents.

- Trust score: 66/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- remote · `arrakis.goodailabs.com`: 66/100 (this document), [markdown](https://verifymcp.io/servers/com-goodailabs-arrakis/arrakis.md), [page](https://verifymcp.io/servers/com-goodailabs-arrakis/arrakis)

## Channel facts

- Endpoint: `https://arrakis.goodailabs.com/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.1.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, 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-05.

- **Endpoint Security**: 63/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (terminate_instance).
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 60/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4149 tokens (~276/item across 15 items; 15 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 17/100
  - Stability observed for 5 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 97/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 90% of tool parameters carry a description.
- **Tool Safety**: 92/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 2 of 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "plan_deploy" implies "deploy" and declares readOnlyHint instead, contradicting what its own name says it does.
  - An AI judge read all 16 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 Arrakis MCP server?

Arrakis is a hosted endpoint at https://arrakis.goodailabs.com/mcp, so there is nothing to install locally. 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 --transport http com-goodailabs-arrakis 'https://arrakis.goodailabs.com/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "com-goodailabs-arrakis": {
      "url": "https://arrakis.goodailabs.com/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-goodailabs-arrakis": {
      "type": "http",
      "url": "https://arrakis.goodailabs.com/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.com-goodailabs-arrakis]
url = "https://arrakis.goodailabs.com/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-goodailabs-arrakis": {
      "type": "remote",
      "url": "https://arrakis.goodailabs.com/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-goodailabs-arrakis --url 'https://arrakis.goodailabs.com/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-goodailabs-arrakis:
    url: "https://arrakis.goodailabs.com/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "com-goodailabs-arrakis": {
      "Transport": "http",
      "Url": "https://arrakis.goodailabs.com/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-goodailabs-arrakis -t streamable-http -u 'https://arrakis.goodailabs.com/mcp'
```

### Other

```json
{
  "mcpServers": {
    "com-goodailabs-arrakis": {
      "type": "http",
      "url": "https://arrakis.goodailabs.com/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## 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-05 (score 66, 0)

- [security] The server rewrote its instructions, which are the text every model session reads
- [security] New tool “instance_ssh_keys”, which the server declares destructive
- [security] Tool “rent_gpu” rewrote its description, which is the text the model reads
- [functional regression] Schema quality: 3381 → 4149
- [functional] Destructive annotations: 2 of 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "plan_deploy" implies "deploy" and declares readOnlyHint instead, contradicting what its own name says it does.
- [functional] New tool “plan_deploy”
- [cosmetic] “rent_gpu” added an optional parameter “ssh_key_ids”

### 2026-11-04 (score 66, +1)

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

### 2026-11-02 (score 65, +1)

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

### 2026-11-01 (score 64, 0)

- [security] The server rewrote its instructions, which are the text every model session reads
- [security] Tool “search_gpus” rewrote its description, which is the text the model reads
- [functional improvement] Stability: unverified → 0.03

### 2026-10-31 (score 64)

First indexed and scored.

## MCP tools (15)

### `search_gpus` (~596 tokens)

Search GPUs

Search GPU machines you can rent now at live prices: B300, B200, H200, RTX PRO 6000, RTX 5090, H100 and more. Free; changes nothing. Use it before rent_gpu and to answer what a GPU costs right now. Rows come best first: what the GPU can do (capability, H100 = 1.0), its price and how reliable its host is, with badges saying why (Reliable host, NVLink, or a warning such as a host taking it back soon); sort=price lists the cheapest first. pick is the first row with the reason, cheapest the lowest whole-machine price. Each row has node_id (for rent_gpu), gpu, gpu_count (rent_gpu rents all of them unless gpu_count says fewer; max_gpus 1 finds single-GPU machines), vram_gb per GPU, price_per_gpu_hour_usd, price_per_hour_usd for the whole machine, CPUs (and cpu, the model), RAM, disk, location, tier and network. Badges also say when renters rate a host low, it often fails to start or its GPUs are slow next to the same GPU elsewhere. Tiers: on_demand runs until its removal time; spot costs less but its host can take it back at any time, so use it only for work that saves checkpoints off the machine. Prices can move within a minute: pass the row's price to rent_gpu as max_price_per_gpu_hour. For multi-machine training add min_nic_gbps 400 and min_nics_per_gpu 1; null network fields were not reported.

Input parameters:

- `country` (string): Two-letter country code, for example US or DE.
- `gpu_type` (string): GPU family, for example H100.
- `gpudirect_rdma` (boolean): true: only machines whose market reports GPUDirect RDMA.
- `limit` (integer)
- `max_gpus` (integer): Only machines with at most this many GPUs; 1 for a single-GPU job.
- `max_price_per_gpu_hour` (number): Price ceiling in USD per GPU-hour.
- `min_gpus` (integer): Only machines with at least this many GPUs.
- `min_nic_gbps` (number): RDMA NICs at least this fast, Gb/s (400, 800).
- `min_nics_per_gpu` (number): RDMA NICs per GPU; 1 = one NIC per GPU.
- `min_vram_gb` (number): Only GPUs with at least this much memory each.
- `nic_type` (string): Only this NIC type.
- `sort` (string): recommended (default), price (cheapest first), value (capability per dollar on a trusted host) or capability (fastest GPU first).
- `tier` (string): Only this tier. Default: all.

### `get_market_summary` (~36 tokens)

Market summary

Live market summary by GPU family: cheapest price per GPU-hour, GPUs available and machines. Free; needs no token; changes nothing.

### `get_partner_earnings` (~155 tokens)

Partner codes and earnings

For partners (agents and people who bring customers to Arrakis): your partner codes with the link and a message to share, what each earns you (a share of what the customers you bring pay), the customers your codes brought (each with what they paid and earned you, and your link tag; never who they are), what you have earned, what is pending until those payments reach Arrakis or held before a cash-out, what you can cash out or move to your balance, any sales target with its progress, and whether the partner program is open to join. Free; changes nothing. Wherever you recommend Arrakis, say that you earn from referrals (the partner terms). Needs a token with the billing scope.

### `join_partner_program` (~168 tokens)

Join the partner program

Join the Arrakis partner program and get your own partner code, link and a message to share. The account earns a share of what the customers it brings pay, as cash (paid through Stripe to the person or company you act for, once they set up payouts in the console) or Arrakis credit you can spend on GPUs. Only join if the person or company you act for agrees: joining accepts the partner terms (terms_url from get_partner_earnings) for them. Pass the terms_version you read. Free; joining again returns the same code. Add ?tag=<label> to your link to tell your own channels apart. Needs a token with the billing scope.

Input parameters:

- `terms_version` (string, required): The partner terms version you read (get_partner_earnings returns it).

### `get_balance` (~95 tokens)

Balance and spend cap

The account balance (what it can pay now, what the running machines cost per hour, when the money runs out, whether rentals are paused and whether auto-recharge tops it up from a saved card) and this token's spend cap: the limit, what is committed, what is left, the longest rental allowed and when the token expires. Call it before long jobs and whenever an alert mentions the balance. Free; changes nothing.

### `rent_gpu` (~649 tokens)

Rent a GPU machine

Rent one machine found by search_gpus, for work you run yourself over SSH (training, fine-tuning, batch jobs). To serve a model, use plan_deploy then deploy_model instead: one call sets up the machine, the engine and an OpenAI-compatible endpoint. COSTS MONEY: price per GPU-hour x GPUs, paid an hour at a time from when it starts running (booting is free) until terminate_instance or termination_hours, whichever comes first; worst_case_usd in the result is the most it can cost, and balance_covers_hours says how many hours the balance pays. It rents every GPU on the machine unless gpu_count says fewer (only some hosts allow that). Pass max_price_per_gpu_hour, normally the price search_gpus showed: if the live price is higher nothing is rented and the error gives the new price. Spot machines can be taken back by their host at any time. Boots the Arrakis PyTorch image unless template_id (list_images) or a public image is given; uses ssh_public_key, else ssh_key_id, else the account's first SSH key. Returns instance_id, state, the locked price, worst_case_usd and what to do next. Calling again with the same idempotency_key, or the same node_id and name within 10 minutes, returns the same machine instead of renting a second; use a new name for a second machine.

Input parameters:

- `gpu_count` (integer): GPUs to rent on that machine. Default: all of them (the whole machine); fewer works only on hosts that allow splitting.
- `idempotency_key` (string): Reuse when retrying.
- `image` (string): Or any public image as docker pull takes it, e.g. vllm/vllm-openai:v0.11.0 or nvcr.io/nvidia/pytorch:25.01-py3 (x86-64). Checked with its registry before anything is charged. Not with template_id.
- `max_price_per_gpu_hour` (number): The most to pay per GPU-hour (USD). If the live price is higher, nothing is rented.
- `name` (string, required): A name you will recognise.
- `node_id` (string, required): node_id from search_gpus.
- `ssh_key_id` (string): Id of an SSH key saved on the account.
- `ssh_key_ids` (array): Several saved keys by id (list_ssh_keys): every one of them can log in, for example the person's and a teammate's.
- `ssh_public_key` (string): Your SSH public key, for example the contents of ~/.ssh/id_ed25519.pub.
- `start` (string): With image: idle (default) keeps the machine waiting for SSH; image runs the image's own command (server images such as vLLM). Reach a server with ssh -L 8000:localhost:8000.
- `template_id` (string): Image to boot: an id from list_images. Default: the Arrakis PyTorch image (SSH, login banner and tools built in).
- `termination_hours` (integer, required): Hours until the machine is removed automatically.

### `plan_deploy` (~212 tokens)

Plan a model deploy (free)

What serving a Hugging Face model takes, before anything is rented: the GPU memory it needs and the machines it fits on right now, best value first, each with its hourly price and a rough speed. Free; rents and changes nothing. Call it first whenever the person wants a model running (to chat with, call from code, generate images, video or speech, or run evals against), tell them the price, then deploy_model with the option's node_id and gpu_count.

Input parameters:

- `engine` (string): Default vllm. omni = vLLM-Omni (image, video, speech, audio).
- `extra_args` (string): The person's own engine options, to check them before renting.
- `hf_token` (string): A Hugging Face token, for a gated or private model.
- `model` (string, required): A Hugging Face model id or link, for example Qwen/Qwen3-8B; for llama.cpp, owner/repo:QUANT.

### `deploy_model` (~552 tokens)

Deploy a Hugging Face model

Serve any model from Hugging Face on a machine of the person's, like a hosted inference API but on their own GPU: vLLM or SGLang for text models, vLLM-Omni or SGLang for image and video models (FLUX, Qwen-Image, Wan), vLLM-Omni for speech and music, llama.cpp for a GGUF file (owner/repo:Q4_K_M). extra_args takes the person's own engine options as they'd paste them. COSTS MONEY like rent_gpu: the machine's hourly price, paid an hour at a time from when it runs until terminate_instance or termination_hours; worst_case_usd is the most it can cost. The model's size is read from Hugging Face and, without node_id, the best-ranked clean machine that holds it is rented on as few GPUs as it allows. A gated or private model needs hf_token (read access is enough; it goes to the machine only and Arrakis keeps none). Returns the instance, the endpoint (an OpenAI-compatible base URL once RUNNING, and its api_key) and ssh_command: the person also gets root SSH. The engine downloads the model first, so it answers a few minutes after RUNNING: get_instance shows endpoint_ready. Same idempotency_key returns the same machine.

Input parameters:

- `engine` (string): Default vllm. omni = vLLM-Omni (image, video, speech, audio).
- `extra_args` (string): The person's own engine options, as they'd paste them: flags, the whole command, or a docker run line (--max-model-len 32768). Read without a shell; the address, key and model stay Arrakis's.
- `gpu_count` (integer): GPUs of it to rent. Default: the fewest that hold the model.
- `hf_token` (string): A Hugging Face token, for a gated or private model.
- `idempotency_key` (string): Reuse when retrying.
- `max_price_per_gpu_hour` (number): The most to pay per GPU-hour (USD).
- `model` (string, required): A Hugging Face model id or link, for example Qwen/Qwen3-8B; for llama.cpp, owner/repo:QUANT picks one GGUF file.
- `name` (string): A name you will recognise.
- `node_id` (string): A machine from search_gpus. Default: the one sized for the model.
- `ssh_public_key` (string): Your SSH public key. Default: the account's first saved key.
- `termination_hours` (integer, required): Hours until the machine is removed automatically.

### `list_images` (~70 tokens)

List images

Images a machine can boot, for rent_gpu's template_id: the Arrakis images (PyTorch, CUDA toolkit, Ubuntu; SSH, login banner and tools built in) and the account's saved ones, with download size. Any other public image works through rent_gpu's image. Free; changes nothing.

### `list_instances` (~58 tokens)

List instances

Every machine on the account with its state, price per hour, SSH command, removal time and any notice from its host. Check it at the start of a session: a machine left running keeps billing until its removal time. Free; changes nothing.

### `get_instance` (~115 tokens)

Get an instance

One machine now: state (PENDING or PROVISIONING while it boots, which is free; RUNNING when ssh_command works; then TERMINATED or FAILED), price per hour, ssh_command, removed_by, any notice from its host (host_notice and host_notice_at, host_down_since) and, once it ended, ended_reason (evicted when its host took it back). After rent_gpu, call it every 30-60 seconds until RUNNING. Free; changes nothing.

Input parameters:

- `instance_id` (string, required)

### `get_events` (~137 tokens)

What happened to my machines

Events on your machines, newest first: machine.ready (with its SSH command), machine.ended (reason says why: evicted when its host took it back or stopped working, otherwise stopped, removal_time, out_of_funds, paused or failed) and machine.notice (its host will take it back or restart it at notice_at, stopped answering, or it failed). Check it when a machine stops answering, and after any alert on a tool result. Free; changes nothing.

Input parameters:

- `limit` (integer): Default 20.
- `since` (string): Only events after this ISO 8601 time. Default: 30 days.

### `terminate_instance` (~70 tokens)

Terminate an instance

Stop a machine now and delete it with everything on its disk; billing stops (the hour already started is paid). Copy results off first, for example with scp or rsync over its ssh_command. Cannot be undone; terminating a machine that already ended changes nothing.

Input parameters:

- `instance_id` (string, required)

### `instance_ssh_keys` (~220 tokens)

SSH keys on a machine

List, add or take off the SSH keys that can log in to a running machine. With only instance_id: the keys on it (fingerprint, comment, the saved key's name). add_ssh_key_ids / add_public_keys: more keys can log in (a teammate's, a new laptop's), at once. remove_fingerprints: those keys can't log in any more (rotate a key: add the new one and remove the old one in one call); taking keys off takes up to half a minute, and at least one key must stay. Free: it changes no billing. Keys are never returned, only fingerprints.

Input parameters:

- `add_public_keys` (array): Public keys that can log in too (the .pub file's line).
- `add_ssh_key_ids` (array): Saved keys (list_ssh_keys) that can log in too.
- `instance_id` (string, required)
- `remove_fingerprints` (array): Fingerprints (SHA256:...) of keys on the machine to take off.

### `schedule_removal` (~117 tokens)

Schedule removal

Change when a machine is removed automatically (ISO 8601, UTC). It bills until then, and removal deletes the machine and its disk. Use it to end a rental early when the job will finish sooner, or, with a token that has no spend cap, to extend a long run. A token with a spend cap can only move removal earlier.

Input parameters:

- `at` (string, required): When to remove it, for example 2026-10-13T18:00:00Z.
- `instance_id` (string, required)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/com-goodailabs-arrakis/arrakis#diagnostics

## Score history

- 2026-11-05: 66
- 2026-11-04: 66
- 2026-11-03: 65
- 2026-11-02: 65
- 2026-11-01: 64
- 2026-10-31: 64

## Common questions

### What is the Arrakis MCP server?

Arrakis is an MCP server listed in the public MCP registry as com.goodailabs/arrakis. Rent GPUs at live prices and serve any Hugging Face model, with spend caps for AI agents. This page covers its hosted endpoint (https://arrakis.goodailabs.com/mcp).

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

Arrakis scores 66 out of 100 on VerifyMCP. 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 Arrakis MCP server expose?

Arrakis exposes 15 tools: search_gpus, get_market_summary, get_partner_earnings, join_partner_program, get_balance, and 10 more. Their descriptions and schemas cost roughly 3,250 tokens of context every time the server is loaded.

### Does the Arrakis MCP server require authentication?

No. We connected to Arrakis without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the Arrakis MCP server still maintained?

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

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

VerifyMCP ran 13 checks on Arrakis, covering TLS certificate, Authorization, HTTPS, HSTS header and 9 more. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- Remote endpoint: https://arrakis.goodailabs.com/mcp
- Website: https://arrakis.goodailabs.com/agents
- Changelog RSS feed: https://verifymcp.io/servers/com-goodailabs-arrakis/arrakis.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-goodailabs-arrakis/arrakis/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/com-goodailabs-arrakis/arrakis.json
- HTML version of this page: https://verifymcp.io/servers/com-goodailabs-arrakis/arrakis