Everpod

Managed hosting for open-source AI agents: see your pods and start a new one from your own agent.

Voir sur everpod.aiEssayer ce MCPSponsorisé

Serveur MCP hébergé

npx add-mcp 'https://everpod.ai/mcp'

S’installe dans Claude Code, Codex, Cursor et plus

Documentation

The Everpod API

In short

Everpod is an easy way to get your own always-on, persistent cloud computer for AI agents, working in minutes: with a managed OpenClaw agent on it, or as a developer pod with Claude Code and Codex installed. The Everpod API is how an agent you already use, such as Claude Code or Codex, works with your Everpod account for you. A key lets an agent or an app you trust see your pods and start a new one for you, which you then pay for on everpod.ai. It can’t pay, change or cancel a plan, delete anything, open your agent’s control panel, or reach a developer pod’s machine.

It is an MCP server at https://everpod.ai/mcp and three REST routes under https://everpod.ai/api/v1, both used with a key you make in your account.

Make a key

  1. Open everpod.ai/account/keys and sign in with your email address and the code we send you. If you have no account yet, signing in makes one.
  2. Name the key after what will use it, and make it.
  3. Copy the key. It starts with everpod_.

We show a key once, when you make it, and keep no copy of it. You can revoke a key in your account at any time, and anything using it stops working at once. A key is not a way to sign in. Whoever holds a key can use it, so keep it secret. Give each agent or app a key of its own, so that revoking one leaves the others working.

What a key can do

Three operations. An agent you connect has each as a tool, with the description shown here, and a script calls each as a route.

  • List pods (list_pods, GET /api/v1/pods): List the pods on the owner's Everpod account, oldest first. Each has its kind, its status and the link its owner needs: pay_url while it is awaiting payment, url (the pod's page on everpod.ai) once it is paid.
  • Get a pod (get_pod, GET /api/v1/pods/{id}): Read one pod by its id: its status and the link its owner needs. This is how to check whether a started pod has been paid for, whether it is ready, and for a developer pod, which of its owner's steps to connect it are done.
  • Start a pod (start_pod, POST /api/v1/pods): Start a new pod for the owner: an OpenClaw pod, or with kind 'developer' a developer pod. This call charges nothing: the pod stays unpaid until its owner opens pay_url in their browser and pays there. While the account has an unpaid pod, calling again returns that same pod, changed to the name and kind now asked for.

A pod is one of two kinds: an OpenClaw pod, a managed OpenClaw agent on a computer of its own, or a developer pod, a cloud computer you run yourself, with Claude Code and Codex installed. An agent starts either. What a pod costs is on the page where you pay for it, on everpod.ai for an OpenClaw pod, and on the developer pod’s page.

Connect an agent

An MCP client connects to https://everpod.ai/mcp over HTTP and sends the key as the header Authorization: Bearer YOUR_KEY. Each tool tells the agent what it does and which link to give you, so it can tell you where to pay and where to open your pod.

Claude Code

claude mcp add --transport http --scope user everpod https://everpod.ai/mcp \
  --header "Authorization: Bearer YOUR_KEY"

Codex

export EVERPOD_API_KEY=YOUR_KEY
codex mcp add everpod --url https://everpod.ai/mcp \
  --bearer-token-env-var EVERPOD_API_KEY

Codex reads the key from that environment variable each time it starts, so set it in the shell Codex runs in.

OpenClaw

openclaw mcp set everpod '{"url": "https://everpod.ai/mcp",
  "transport": "streamable-http",
  "headers": {"Authorization": "Bearer YOUR_KEY"}}'

An OpenClaw agent can run this itself, and has the tools from its next message. Or install the Everpod skill from ClawHub, and the agent connects itself, starts a new agent or a developer pod for you, and can move itself onto a pod: openclaw skills install @everpod/everpod.

Another MCP client

Give it the address and the header. As a JSON entry, in the form Claude Code’s .mcp.json takes, with the key read from an environment variable so that it is never written into a file you share:

{
  "mcpServers": {
    "everpod": {
      "type": "http",
      "url": "https://everpod.ai/mcp",
      "headers": { "Authorization": "Bearer ${EVERPOD_API_KEY}" }
    }
  }
}

Then ask the agent, for example:

Start an Everpod pod called Otto and tell me where to pay.

Start an Everpod developer pod called atlas, with alex as my username, and tell me where to pay.

Get a developer pod with your agent

A coding agent on your own computer, such as Claude Code or Codex, can take you from nothing to a developer pod you are logged in to. It needs a key, and it does not need the MCP server: the REST routes below do the same from a shell. The steps that open the machine are yours.

  1. You make a key in your Everpod account and give it to your agent.
  2. Your agent starts the pod with the name you want for the machine and your username on it, and gives you the link where you pay.
  3. About 10 minutes after you pay, the machine is built, and we email you.
  4. On the pod’s page, you join the machine to your Tailscale network. You open the sign-in link there yourself: whoever signs in adds the machine to their network, so the link is shown only on that page, to you, and a key never carries it.
  5. You switch off the machine’s key expiry in Tailscale’s admin console. Tailscale otherwise drops a machine from your network after 180 days, and after the hand-over that network is the only way in.
  6. You log in once over SSH from a device on your Tailscale network (ssh you@your-machine, with no key or password: Tailscale checks it is you, which can mean confirming in your browser); an agent on that device can run it for you.
  7. Once the machine has joined your network, its key expiry is off and you have logged in, we remove our own setup access.
  8. On the machine, you run claude or codex and sign in with your own subscription or API key.

Between those steps the agent reads the pod: its status says whether it is paid, built and connected, and machine says which of your steps are done and gives the username and the machine’s name on your network, so it can tell you what is left or log in for you.

For an agent that takes skills, the same steps are a skill, everpod-developer-pod, from github.com/everpod-ai/skills. Claude Code and Codex each install it with two commands; for another agent, copy its folder into the agent’s skills folder.

# Claude Code
claude plugin marketplace add everpod-ai/skills
claude plugin install everpod-developer-pod@everpod

# Codex
codex plugin marketplace add everpod-ai/skills
codex plugin add everpod-developer-pod@everpod

Call it from code

The same three operations over HTTPS. Every request carries the key as Authorization: Bearer YOUR_KEY, and requests and answers are JSON. The list answers { "pods": [...] }; reading or starting a pod answers { "pod": {...} }. Starting one takes { "name": "..." }, the name you want for the pod’s agent, up to 40 characters. A developer pod also takes "kind": "developer" and "login", your username on the machine, and its name is the machine’s, which is also its name on your network.

export EVERPOD_API_KEY=YOUR_KEY

curl https://everpod.ai/api/v1/pods \
  -H "Authorization: Bearer $EVERPOD_API_KEY"

curl -X POST https://everpod.ai/api/v1/pods \
  -H "Authorization: Bearer $EVERPOD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Otto"}'

curl -X POST https://everpod.ai/api/v1/pods \
  -H "Authorization: Bearer $EVERPOD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "atlas", "kind": "developer", "login": "alex"}'

Client libraries

For JavaScript and Python, a client library makes the same three calls, with no dependencies. A refused request becomes an error carrying the API’s code, status and sentence.

npm install @everpod-ai/sdk
pip install everpod-ai

Each one’s page shows how to use it: @everpod-ai/sdk on npm and everpod-ai on PyPI.

A pod

{
  "pod": {
    "id": "5f0c1a52-8f1e-4d0b-9a57-3f6f2f7c1e9a",
    "name": "Otto",
    "kind": "openclaw",
    "status": "awaiting_payment",
    "created_at": "2026-10-03T09:12:44.512345+00:00",
    "url": null,
    "pay_url": "https://everpod.ai/create?pod=5f0c1a52-8f1e-4d0b-9a57-3f6f2f7c1e9a",
    "plan": null,
    "machine": null,
    "subscription": null
  }
}
  • id: the pod’s id, which reading one pod takes.
  • name: the name of the pod’s agent, or of a developer pod’s machine.
  • kind: openclaw for an OpenClaw pod, or developer for a developer pod.
  • status: one of the statuses below.
  • created_at: when the pod was started.
  • pay_url: where the pod is paid for, by its owner in a browser, with its price. Present while the status is awaiting_payment, and null after.
  • url: the pod’s page on everpod.ai, where its signed-in owner opens an OpenClaw pod’s control panel and connects a messaging app, or connects a developer pod, and manages the plan. Null until the pod is paid for.
  • plan: the plan the pod is on, base (dev_s for a developer pod) when it is first paid for. Null until then.
  • machine: null for an OpenClaw pod. For a developer pod, its size (vcpu, ram_gb, disk_gb), your username on it (login), its name on your Tailscale network once it has joined (hostname, null until then), and whether its key expiry is switched off (key_expiry_off) and you have logged in (logged_in): 
    "machine": {
  "vcpu": 4,
  "ram_gb": 8,
  "disk_gb": 80,
  "login": "alex",
  "hostname": "atlas",
  "key_expiry_off": false,
  "logged_in": false
}
  • subscription: its status, when the paid period ends (current_period_end), and whether it is set to end then (cancel_at_period_end). Null until the pod is paid for.

Pod status

  • awaiting_payment: named, and waiting for its owner to pay at pay_url.
  • building: paid, and its computer is being set up. Setup usually takes about 15 minutes for an OpenClaw pod and about 10 for a developer pod; its page (url) shows where this one is, and its owner gets an email when setup is done.
  • setup_delayed: setup stopped partway on Everpod's side. Everpod is alerted and will fix it, and setup then carries on from where it stopped. Nothing is needed from the owner, who gets an email when setup is done.
  • awaiting_connection: a developer pod that is built, and waiting for its owner to connect it. On its page (url), signed in, they join it to their own Tailscale network, switch off its key expiry there, and log in once over SSH; machine says which of these are done. Everpod then removes its own setup access, and the pod is ready.
  • ready: an OpenClaw pod is awake: url is its page on everpod.ai, where its signed-in owner opens the agent's control panel and connects a messaging app. A developer pod is in its owner's hands: they reach it over their Tailscale network with ssh, as the login and hostname in machine, and sign in to Claude Code and Codex on it.
  • needs_attention: was running and has a problem. Its page (url) says what.
  • stopped: its subscription ended. Its page (url) says what happens next.

When a request is refused

A refusal answers with a code and a message. The message says what happened and what to do next, in words an agent can pass on to you; over MCP the same message arrives as the tool’s error.

{
  "error": {
    "code": "not_found",
    "message": "No pod with that id on this account."
  }
}
  • unauthorized (401): the request carried no key, or one that does not work: mistyped, or revoked.
  • rate_limited (429): requests are arriving too quickly. The message says how long to wait.
  • not_found (404): No pod with that id on this account.
  • name_required (400): A pod needs a name: send a 'name', the name the owner wants for their agent, or for a developer pod's machine.
  • kind_unknown (400): A pod's 'kind' is 'openclaw' or 'developer'. Leave it out for an OpenClaw pod.
  • login_invalid (400): A developer pod needs a 'login', the username its owner will have on the machine: lowercase letters and numbers, starting with a letter, 31 characters at most. A few names the system already uses, such as root and admin, are taken.
  • invalid_body (400): The request body must be JSON.
  • server_error (500): Something went wrong on Everpod's side. Try again in a minute; support@everpod.ai if it keeps happening.

Questions

Anything about the API: support@everpod.ai. How your account and your keys are protected is in the Security overview. Everpod as a whole, both kinds of pod and every guide, in one plain-text file: everpod.ai/llms.txt.