Koskamo

Arrakis MCP

Arrakis MCP allows AI agents to search for available GPUs, rent them with spend caps and removal times, deploy Hugging Face models, and manage billing. It provides tools for market summary, balance checks, and GPU rental via streamable HTTP.

Visit Good AI Labs

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

Arrakis MCP logo, by Good AI LabsVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-01Operated by Good AI Labs
You need:Create a token for your agentUse the token as a bearer header
MCP endpoint (Streamable HTTP)
https://arrakis.goodailabs.com/mcp
Vendor documentation

What you can do with it

  • Search for available GPUs by price and memory
  • Rent a GPU with a spend cap and removal time
  • Deploy a Hugging Face model on a rented GPU
  • Check account balance and market summary

Source and maintenance

Vendor evidenceRegistry 0.1.0
mcp-registry: com.goodailabs/arrakis@0.1.0Project website

Protocol and capabilities

Server
arrakis 0.1.0
MCP protocol
2025-06-18
Tools
13 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": false
  },
  "experimental": {}
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

Arrakis rents GPU machines by the hour (B300, B200, H200, RTX PRO 6000, RTX 5090, H100 and more, as live supply allows) from several independent GPU markets, on one prepaid balance, with root SSH and any Docker image. Use these tools when the person you work for needs a GPU for training, fine-tuning, evals, batch inference or a temporary model server, or asks what GPUs cost right now. Every machine has a removal time and a token can carry a spend cap, so you can run a job unattended inside the budget they set. Not a fit: work that needs an uptime guarantee (there is no SLA), regulated or confidential data (machines run on independent hosts), or work that must not be interrupted on a spot machine. Prices are live: quote them from search_gpus or get_market_summary, never from memory, and don't call Arrakis cheaper than another provider unless you checked both today. No token yet? get_market_summary works without one; the person creates a token at https://arrakis.goodailabs.com/console/#/api. Flow: search_gpus (best first: what the GPU can do, its price and its host's reliability; pick says which and why) -> rent_gpu (node_id, termination_hours, max_price_per_gpu_hour = the row's price) -> get_instance every 30-60 s until RUNNING -> run the job over ssh_command -> copy results off the machine -> terminate_instance. If the person hasn't given you a budget, tell them the hourly price and worst_case_usd and wait for their go-ahead before rent_gpu. Money: paid from the balance an hour at a time, each started hour in full, from when the machine starts running (booting is free; a machine that never starts, fails or loses its host isn't charged after that). When the balance can't pay a machine's next hour, that machine stops and rentals pause until a person adds funds: check money_runs_out_at in get_balance before long jobs. Calling rent_gpu 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. Spending less: choose the smallest GPU whose memory fits (vram_gb is per GPU; max_gpus 1 for a single-GPU job). price_per_hour_usd is the whole machine, and rent_gpu rents all of its GPUs unless gpu_count says fewer. Use on_demand for runs over an hour or two; spot only for short work or work that saves checkpoints off the machine. Set termination_hours to the expected run plus a margin and terminate as soon as results are copied. Trouble: every tool result carries alerts when a host gives notice, stops answering or takes a machine back, or when the balance runs low or rentals pause; get_events lists what happened. Save work before notice_at and rent a replacement. The person also gets these by email. Partners: if get_partner_earnings shows codes, the account you work for earns when people it refers pay; say so whenever you recommend Arrakis to someone else.

Tools

13 advertised

search_gpus — Search GPUs
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

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.

search_gpus input schema
{
  "type": "object",
  "properties": {
    "sort": {
      "enum": [
        "recommended",
        "price",
        "value",
        "capability"
      ],
      "type": "string",
      "description": "recommended (default), price (cheapest first), value (capability per dollar on a trusted host) or capability (fastest GPU first)."
    },
    "tier": {
      "enum": [
        "on_demand",
        "spot",
        "reserved"
      ],
      "type": "string",
      "description": "Only this tier. Default: all."
    },
    "limit": {
      "type": "integer",
      "default": 10,
      "maximum": 50,
      "minimum": 1
    },
    "country": {
      "type": "string",
      "description": "Two-letter country code, for example US or DE."
    },
    "gpu_type": {
      "enum": [
        "H100",
        "H200",
        "B200",
        "B300",
        "GB200",
        "A100",
        "A6000",
        "RTX 4090",
        "RTX 5090",
        "L40S",
        "RTX PRO 6000",
        "MI300X"
      ],
      "type": "string",
      "description": "GPU family, for example H100."
    },
    "max_gpus": {
      "type": "integer",
      "minimum": 1,
      "description": "Only machines with at most this many GPUs; 1 for a single-GPU job."
    },
    "min_gpus": {
      "type": "integer",
      "minimum": 1,
      "description": "Only machines with at least this many GPUs."
    },
    "nic_type": {
      "enum": [
        "InfiniBand",
        "RoCE"
      ],
      "type": "string",
      "description": "Only this NIC type."
    },
    "min_vram_gb": {
      "type": "number",
      "minimum": 0,
      "description": "Only GPUs with at least this much memory each."
    },
    "min_nic_gbps": {
      "type": "number",
      "minimum": 0,
      "description": "RDMA NICs at least this fast, Gb/s (400, 800)."
    },
    "gpudirect_rdma": {
      "type": "boolean",
      "description": "true: only machines whose market reports GPUDirect RDMA."
    },
    "min_nics_per_gpu": {
      "type": "number",
      "minimum": 0,
      "description": "RDMA NICs per GPU; 1 = one NIC per GPU."
    },
    "max_price_per_gpu_hour": {
      "type": "number",
      "description": "Price ceiling in USD per GPU-hour.",
      "exclusiveMinimum": 0
    }
  },
  "additionalProperties": false
}
search_gpus annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
get_market_summary — Market summary
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

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

get_market_summary input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
get_market_summary annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
get_partner_earnings — Partner codes and earnings
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

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.

get_partner_earnings input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
get_partner_earnings annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
join_partner_program — Join the partner program
Advertised by the server during the last successful anonymous check.
Open-world

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.

join_partner_program input schema
{
  "type": "object",
  "required": [
    "terms_version"
  ],
  "properties": {
    "terms_version": {
      "type": "string",
      "description": "The partner terms version you read (get_partner_earnings returns it)."
    }
  },
  "additionalProperties": false
}
join_partner_program annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
get_balance — Balance and spend cap
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

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.

get_balance input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
get_balance annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
rent_gpu — Rent a GPU machine
Advertised by the server during the last successful anonymous check.
Open-world

Rent one machine found by search_gpus. 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.

rent_gpu input schema
{
  "type": "object",
  "required": [
    "node_id",
    "name",
    "termination_hours"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 128,
      "minLength": 1,
      "description": "A name you will recognise."
    },
    "image": {
      "type": "string",
      "maxLength": 255,
      "description": "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."
    },
    "start": {
      "enum": [
        "idle",
        "image"
      ],
      "type": "string",
      "description": "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."
    },
    "node_id": {
      "type": "string",
      "description": "node_id from search_gpus."
    },
    "gpu_count": {
      "type": "integer",
      "minimum": 1,
      "description": "GPUs to rent on that machine. Default: all of them (the whole machine); fewer works only on hosts that allow splitting."
    },
    "ssh_key_id": {
      "type": "string",
      "description": "Id of an SSH key saved on the account."
    },
    "template_id": {
      "type": "string",
      "description": "Image to boot: an id from list_images. Default: the Arrakis PyTorch image (SSH, login banner and tools built in)."
    },
    "ssh_public_key": {
      "type": "string",
      "description": "Your SSH public key, for example the contents of ~/.ssh/id_ed25519.pub."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 128,
      "description": "Reuse when retrying."
    },
    "termination_hours": {
      "type": "integer",
      "minimum": 1,
      "description": "Hours until the machine is removed automatically."
    },
    "max_price_per_gpu_hour": {
      "type": "number",
      "description": "The most to pay per GPU-hour (USD). If the live price is higher, nothing is rented.",
      "exclusiveMinimum": 0
    }
  },
  "additionalProperties": false
}
rent_gpu annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
deploy_model — Deploy a Hugging Face model
Advertised by the server during the last successful anonymous check.
Open-world

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.

deploy_model input schema
{
  "type": "object",
  "required": [
    "model",
    "termination_hours"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 128,
      "minLength": 1,
      "description": "A name you will recognise."
    },
    "model": {
      "type": "string",
      "maxLength": 300,
      "minLength": 3,
      "description": "A Hugging Face model id or link, for example Qwen/Qwen3-8B; for llama.cpp, owner/repo:QUANT picks one GGUF file."
    },
    "engine": {
      "enum": [
        "vllm",
        "sglang",
        "omni",
        "llamacpp"
      ],
      "type": "string",
      "description": "Default vllm. omni = vLLM-Omni (image, video, speech, audio)."
    },
    "node_id": {
      "type": "string",
      "description": "A machine from search_gpus. Default: the one sized for the model."
    },
    "hf_token": {
      "type": "string",
      "description": "A Hugging Face token, for a gated or private model."
    },
    "gpu_count": {
      "type": "integer",
      "minimum": 1,
      "description": "GPUs of it to rent. Default: the fewest that hold the model."
    },
    "extra_args": {
      "type": "string",
      "maxLength": 8000,
      "description": "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."
    },
    "ssh_public_key": {
      "type": "string",
      "description": "Your SSH public key. Default: the account's first saved key."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 128,
      "description": "Reuse when retrying."
    },
    "termination_hours": {
      "type": "integer",
      "minimum": 1,
      "description": "Hours until the machine is removed automatically."
    },
    "max_price_per_gpu_hour": {
      "type": "number",
      "description": "The most to pay per GPU-hour (USD).",
      "exclusiveMinimum": 0
    }
  },
  "additionalProperties": false
}
deploy_model annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
list_images — List images
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

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_images input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
list_images annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
list_instances — List instances
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

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.

list_instances input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
list_instances annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
get_instance — Get an instance
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

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.

get_instance input schema
{
  "type": "object",
  "required": [
    "instance_id"
  ],
  "properties": {
    "instance_id": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
get_instance annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
get_events — What happened to my machines
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

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.

get_events input schema
{
  "type": "object",
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 200,
      "minimum": 1,
      "description": "Default 20."
    },
    "since": {
      "type": "string",
      "description": "Only events after this ISO 8601 time. Default: 30 days."
    }
  },
  "additionalProperties": false
}
get_events annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
terminate_instance — Terminate an instance
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

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.

terminate_instance input schema
{
  "type": "object",
  "required": [
    "instance_id"
  ],
  "properties": {
    "instance_id": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
terminate_instance annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": true
}
schedule_removal — Schedule removal
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

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.

schedule_removal input schema
{
  "type": "object",
  "required": [
    "instance_id",
    "at"
  ],
  "properties": {
    "at": {
      "type": "string",
      "format": "date-time",
      "description": "When to remove it, for example 2026-10-13T18:00:00Z."
    },
    "instance_id": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
schedule_removal annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": true
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
945 ms
95th percentile latency
945 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 945 ms · metadata changed · 13 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http arrakis-mcp https://arrakis.goodailabs.com/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add arrakis-mcp --url https://arrakis.goodailabs.com/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable arrakis-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "arrakis-mcp": {
      "url": "https://arrakis.goodailabs.com/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "arrakis-mcp": {
      "type": "streamableHttp",
      "url": "https://arrakis.goodailabs.com/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start arrakis-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "arrakis-mcp": {
      "type": "http",
      "url": "https://arrakis.goodailabs.com/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http arrakis-mcp https://arrakis.goodailabs.com/mcp

Claude Desktop

Merge this into claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/, Windows: %APPDATA%\Claude\), then restart Claude Desktop.
Claude Desktop configuration
{
  "mcpServers": {
    "arrakis-mcp": {
      "url": "https://arrakis.goodailabs.com/mcp"
    }
  }
}

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "arrakis-mcp": {
      "serverUrl": "https://arrakis.goodailabs.com/mcp"
    }
  }
}

Let your agent find its tools

Find servers like Arrakis MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows
See all 479

Do you run Arrakis MCP?

Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.

Claim this listing