Use Aquanode from an AI agent (MCP)

Connect Claude Code, Cursor or any remote MCP client to Aquanode. Let an agent look up GPU prices, check your balance, and launch or stop pods, with spend limits the server enforces.

Aquanode runs a hosted MCP (Model Context Protocol) server, so an AI agent can look up GPU prices, read your pods and jobs, and rent a GPU for you.

https://server.aquanode.io/mcp

It is a remote server over streamable HTTP. There is nothing to install: you point your client at the URL and give it an API key.

Authenticate with an API key

The server accepts an Aquanode API key (it starts with aq_sk_) sent as a Bearer header:

Authorization: Bearer aq_sk_xxxxxxxxxxxxxxxxxxxx

Create a key on the API Keys page of the console. The full steps, scopes and expiry options are in API Keys.

A key belongs to one team, and the agent acts on that team. You do not send a team id.
Keys are the only way in. There is no OAuth sign-in, and a browser session is not accepted.
The key's scope still applies. A Read key can use the read-only tools; launching, running and stopping need a key with the Deploy scope or higher.

Treat the key like a password

Anything that holds the key can spend your balance, up to the limits below. Give an agent its own key, pick the smallest scope that works, set an expiry, and revoke the key from the console if it leaks.

Connect a client

Set the key in an environment variable first, for example AQUANODE_API_KEY.

Claude Code

claude mcp add --transport http aquanode https://server.aquanode.io/mcp --header "Authorization: Bearer $AQUANODE_API_KEY"

Cursor

Add the server to mcp.json (project .cursor/mcp.json or the global one):

{
  "mcpServers": {
    "aquanode": {
      "url": "https://server.aquanode.io/mcp",
      "headers": {
        "Authorization": "Bearer aq_sk_xxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}

Any other remote MCP client

Use these settings in whatever your client calls them:

Setting	Value
URL	`https://server.aquanode.io/mcp`
Transport	Streamable HTTP
Header	`Authorization: Bearer aq_sk_...` (your key)

What the agent can do

Thirteen tools. Ten only read (this includes the two quote tools), two rent a GPU, and one stops a pod.

Read-only tools

Tool	What it does
`list_gpu_offers`	Lists rentable GPU offers with the hourly price for the whole machine. Filter by GPU, VRAM and tier.
`get_balance`	Returns the team's credit balance, plan and the plan tiers on sale.
`list_pods`	Lists the team's pods and their state.
`get_pod`	Returns one pod by id.
`list_environments`	Lists the environments a pod can be created from, with the version id to launch from.
`get_deployment_status`	Returns the live status of the machine behind a pod, by its numeric deployment id.
`list_jobs`	Lists the team's jobs.
`get_job_run`	Returns one run of a job: state, timings and exit result.
`quote_launch`	Prices a machine for a GPU and count against your ceiling and returns a signed quote. Rents nothing.
`quote_job`	Prices a job against your ceiling and returns a signed quote. Rents nothing.

The quote tools are read-only: they never rent anything. They are listed here because they are how an agent gets permission to use the tools below.

Tools that rent a GPU

Tool	What it does
`launch_pod`	Starts an existing pod, or creates a new one from an environment, on the machine that was quoted. Needs a quote from `quote_launch`.
`run_job`	Submits a job and starts a run. Needs a quote from `quote_job`.

Billing starts when the machine is rented. launch_pod and run_job answer once the request is accepted, so the agent checks progress with get_pod, get_deployment_status or get_job_run.

Stopping

Tool	What it does
`stop_pod`	Stops a pod, the same Stop as the console button. The machine is released and billing stops.

Stopping a pod that is not running is harmless.

Billable tools can be switched off

The tools that rent a GPU are not listed at all while Aquanode has them disabled on the server, and refuse if called by name. If your client shows only the read-only tools and stop_pod, that is why.

Spend limits

An agent that can rent GPUs needs limits it cannot talk its way around. These are enforced on the server, not by the client.

A price ceiling the agent must state. Every quote takes a maxPricePerHourUsd. If no matching machine is at or under it, there is no quote. The ceiling travels with the quote, and the server checks it again when the machine is rented.
A signed quote, passed back within 10 minutes, that rents once. quote_launch and quote_job return a quoteToken that is signed by Aquanode and tied to your team and to the exact request quoted. launch_pod and run_job refuse without a valid token. A token expires after 10 minutes. Each token can rent one machine: using it a second time is refused, and the agent has to quote again.
A cap on active machines per team, default 3. A rental is refused when the team already has that many machines running or starting through Aquanode (a job that was just accepted and is still being placed counts too). The refusal names the limit and the deployments that are running. Machines you attach yourself do not count. The cap is checked and the machine is rented under a per-team lock, so two requests arriving at the same moment cannot both slip past it.

Two more rules from the rest of the platform still apply to an agent:

A rental is refused when your balance covers less than ten minutes of the machine.
If the server cannot check the limits, it refuses and rents nothing.

The cap applies to the MCP only. Renting from the console or the aq CLI is not affected by it.

Quote defaults

If quote_job is called without diskGb, it quotes 100 GB of disk, the same default a job gets when you submit one without a size.

What stopping a pod does

When you stop a pod, through stop_pod or the console, its workspace is captured on the way out and can be restored later. Start the same pod again and your files are back. See Stop, start, and move.

If the provider kills the machine instead, the pod restores only to its last scheduled snapshot. Anything written after that snapshot is not recovered.

So an agent that is finished with a pod should call stop_pod rather than leave it running or walk away.

A typical agent flow

get_balance to see what the team can spend.
list_gpu_offers to see what is on sale and at what price.
quote_launch with a GPU, a count and a ceiling. The agent states the ceiling and gets a quoteToken.
launch_pod with that token (and an environment version from list_environments for a new pod).
get_pod until the pod is running.
Work, then stop_pod.

Limits of this server

It only lists, reads, launches, runs jobs and stops pods. It has no tools to delete anything, and none for volumes, snapshots, teams or billing changes.
Prices from list_gpu_offers come from a cached feed, so treat them as a guide. The quote is the price the agent holds you to.
A server card describing the endpoint is served at https://server.aquanode.io/mcp/server-card.

Use Aquanode from an AI agent (MCP)

On this page