What is an MCP server, and how can it give agents GPUs?

An MCP server is a small program that offers an AI agent a list of tools it can call, using the open Model Context Protocol (MCP). The server itself needs no GPU: on Nodus, its tools let an agent like Claude Code price, launch and watch a GPU job, and you approve the cost before the job starts.

The split matters. The agent decides what to call, the server turns each call into a real action, and the hardware lives wherever that action runs.

What does an MCP server actually do?

An MCP server answers requests from an agent in a fixed message format, so any agent that speaks MCP can use it without custom glue code. Anthropic open-sourced the protocol on November 25, 2024, and the specification now defines it in the open.

The spec names three roles. The host is the AI application, such as Claude Code. The client is the connector inside that host, and the server is the service that provides context and capabilities.

The three exchange JSON-RPC 2.0 messages, and the spec says the design takes inspiration from the Language Server Protocol, which did the same job for code editors.

A server can offer three kinds of things:

Source: MCP specification overview. Checked November 6, 2026.

Tools matter most for compute. A GPU platform's MCP server is mostly a set of tools that map to its API: list jobs, read logs, estimate, create.

Does MCP need a GPU?

No. MCP is a protocol, and an MCP server is an ordinary process that sends and receives messages. It can run on your laptop or on someone else's server without a GPU anywhere near it.

The spec defines two standard transports, and neither involves a GPU. With stdio, your agent starts the server as a subprocess and they trade newline-delimited messages. With Streamable HTTP, each message is an HTTP POST to one endpoint on a remote server (transports).

The GPU only enters when a tool call starts work that needs one. That is the useful question to ask about any MCP server: where does the work it starts actually run? For a database server, the answer is your database. For the Nodus server, it is a Nodus Job, Sandbox or training run on the GPU type the manifest asks for.

Can you use MCP servers with Claude Code?

Yes. Claude Code is an MCP host, and you add a server with one command. A remote server uses --transport http, and a local one uses --transport stdio with the command that starts it (Claude Code MCP docs).

These are the two Nodus entries, copied from the connect page:

# Hosted server, browser sign-in
claude mcp add --scope user --transport http nodus https://api-next.nodus-compute.ai/mcp

# Local server, uses your nodus login
claude mcp add --scope user --transport stdio nodus -- nodus mcp

The scope decides who sees the server. Local scope is the default and loads the server only in the project where you added it. Project scope writes a .mcp.json file you can commit for your team. User scope, used above, makes it available in all your projects while staying private to you.

Codex, Cursor, VS Code, Gemini CLI and OpenCode take the same server through their own config files. Our step-by-step setup post has each client's exact entry and compares GPU platforms that offer an MCP server.

How does an agent get from a prompt to a finished GPU job?

It makes a short chain of tool calls, and most of them are waiting. We counted the calls the Nodus MCP guide workflow needs for one job you expect to run for 2 hours, with the agent checking in every 10 minutes.

1. Inspect, 2 calls: whoami confirms the organization, and explain reads the current Job fields.
2. Create, 2 calls: estimate returns the dry run, cost estimate and an etag. After you accept, apply runs with confirmed: true and that same etag.
3. Observe, 12 calls: wait blocks for up to 60 seconds per call, so the agent checks once every 10 minutes for 120 minutes.
4. Retrieve, 1 call: outputs lists results and returns a download link valid for 10 minutes.

Watching the job is 12 of the 17 calls, so the check interval matters more than the setup.

That is 17 tool calls in total, and only one of them spends money. Your approval between estimate and apply is not a tool call. It is you reading the estimate in the chat and saying yes.

The confirmed apply fails if the estimate changed after you saw it. The agent then has to estimate again and show you the new number. Jobs created this way carry the label nodus.dev/launched-by: mcp, so you can find them later.

What does the GPU behind a tool call cost?

The cost is the job's GPU time at that GPU's rate, and the agent's choice of GPU moves it far more than anything about MCP. Take the same 2-hour job on three GPUs listed on the Nodus pricing page:

Prices checked November 6, 2026. The dry-run estimate for your own manifest is the number to trust before you approve.

The same prompt can cost $1.59 or $11.00, which is why the estimate step should show the GPU type, not just a total.

Our rule: put the GPU type and a dollar cap in the prompt, and ask the agent to show both in the estimate. Our post on GPU spending limits for agents covers the caps the platform enforces.

What should you lock down before an agent gets GPU tools?

Treat every write tool as something that can cost money, and keep a person able to say no. The MCP spec says there should always be a human in the loop with the ability to deny tool invocations (tools). It also says clients must treat a tool's self-described behavior as untrusted unless the server is trusted.

On Nodus, four settings do most of the work:

• Grant only the scopes the task needs. The hosted server's consent page asks which org and scopes the client gets, and the tool list follows them.
• Keep your client's approval prompts on. The etag handshake covers apply, but delete, set_state, request, record and exec do not use it.
• Put maxCostUSD on every Job, so a run that hangs is suspended at the cap instead of running all weekend.
• Revoke what you no longer use. Deleting a grant takes effect within 30 seconds, even for a client that already holds a token (connected agents).

Logs and command output come back marked as untrusted. A training script can print anything, and an agent should never treat a log line as a new instruction.

When is MCP the wrong way to give an agent GPUs?

Skip MCP when the agent already has a terminal and the job is a single command you would type yourself. Claude Code can run nodus run through its shell, and a CLI command is easier to read in a transcript than a chain of tool calls.

Use MCP when the client has no shell or you want a revocable grant with chosen scopes. It also wins when you want the platform, not the prompt, to enforce the priced dry run. For jobs that run for hours, the hand-off pattern in our post on coding agents and long-running jobs matters more than which route you pick.

FAQ

Is MCP only for Claude models?

No. MCP is an open protocol, and the Nodus connect page lists setup for Codex, Cursor, VS Code, Gemini CLI and OpenCode alongside Claude Code. Any client that supports a remote HTTP server or a local stdio server can use it.

What happened to the SSE transport?

Claude Code's docs mark the SSE (Server-Sent Events) transport as deprecated and recommend HTTP servers. Claude Code still connects to SSE-only servers by trying HTTP first and falling back.

Can an MCP tool return a whole training log?

Not in one piece. The Nodus logs tool returns at most 2,000 lines per call. Claude Code warns when one tool result exceeds 10,000 tokens and cuts it at 25,000 tokens unless you raise MAX_MCP_OUTPUT_TOKENS.

Will MCP handle long-running jobs natively?

The current spec lists Tasks as an optional extension for long-running operations, with polling and durable handles. Both client and server must opt in, so for now plan on the agent checking job status with repeated calls.

Can the hosted server read files on my laptop?

No. The hosted Nodus server cannot read your local filesystem. Use the local nodus mcp server, which adds upload_source and download_output, or an image that already contains your code.

Originally published on the Nodus blog.