Superserve

io.github.superserve-aiPublished by GitHub account superserve-aiv0.3.4Updated Nov 5, 2026

MCP server for Superserve sandboxes: create, exec, and manage Firecracker microVMs

VerifiedStreamable HTTPWeb executableCloud & InfrastructureBrowser AutomationDeveloper Tools

Overview

Superserve's hosted MCP server (mcp.superserve.ai); API key required; Streamable HTTP; 20 tools.

No AI overview yet: these facts come from the registry entry and the server itself.

Endpoint
mcp.superserve.ai
Last checked

Installation

In SourceWeft

  1. Open Superserve in the dashboard and add it to a workspace.
  2. Connect Authorization token credentials. They are stored privately and never shown on public pages.
  3. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.superserve-ai%2Fmcp/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "superserve": {
      "type": "http",
      "url": "https://mcp.superserve.ai/",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      }
    }
  }
}

README

@superserve/mcp

Model Context Protocol server for Superserve sandboxes. Create, run commands in, and manage isolated Firecracker microVMs from any MCP client — Claude, Cursor, VS Code, Windsurf, Codex.

Runs locally over stdio via npx. Authenticates with your Superserve API key. Targets a sandbox per call by id.

Install

Add to your MCP client and set SUPERSERVE_API_KEY in its env (clients do not inherit it from your shell). Create a key at console.superserve.ai.

Claude Code:

bash
claude mcp add superserve \  --env SUPERSERVE_API_KEY=ss_live_xxxxxxxxxxxxxxxx \  -- npx -y -p @superserve/mcp superserve-mcp

Claude Desktop / Cursor / Windsurf (claude_desktop_config.json, .cursor/mcp.json, mcp_config.json):

json
{  "mcpServers": {    "superserve": {      "command": "npx",      "args": ["-y", "-p", "@superserve/mcp", "superserve-mcp"],      "env": { "SUPERSERVE_API_KEY": "ss_live_xxxxxxxxxxxxxxxx" }    }  }}

VS Code (.vscode/mcp.json, prompts for the key):

json
{  "inputs": [    {      "id": "superserve-key",      "type": "promptString",      "description": "Superserve API key",      "password": true    }  ],  "servers": {    "superserve": {      "type": "stdio",      "command": "npx",      "args": ["-y", "-p", "@superserve/mcp", "superserve-mcp"],      "env": { "SUPERSERVE_API_KEY": "${input:superserve-key}" }    }  }}

Codex (~/.codex/config.toml) — env_vars forwards the key from your environment instead of storing it in the file:

toml
[mcp_servers.superserve]command = "npx"args = ["-y", "-p", "@superserve/mcp", "superserve-mcp"]env_vars = ["SUPERSERVE_API_KEY"]

Hosted (remote)

A hosted instance runs at https://mcp.superserve.ai (Streamable HTTP) — no local install. Send your Superserve API key as a bearer token; the server is stateless and account-scoped (the key already maps to your team).

Bearer auth works in Claude Code, Cursor, VS Code, and the Anthropic Messages API connector. Claude.ai, Claude Desktop's Custom Connector UI, and ChatGPT developer mode expect OAuth (no static-bearer field), which the hosted endpoint does not support yet.

The hosted endpoint limits each request body to about 4.5 MB, so keep sandbox_files_write inline content under about 4 MiB of text or 3 MiB of binary data sent as base64; larger requests fail with HTTP 413 Request Entity Too Large. The local server accepts up to 8 MiB.

Claude Code:

bash
claude mcp add --transport http superserve https://mcp.superserve.ai \  --header "Authorization: Bearer ss_live_xxxxxxxxxxxxxxxx"

Cursor / VS Code (.cursor/mcp.json, .vscode/mcp.json):

json
{  "servers": {    "superserve": {      "type": "http",      "url": "https://mcp.superserve.ai",      "headers": { "Authorization": "Bearer ss_live_xxxxxxxxxxxxxxxx" }    }  }}

Running the hosted server

The same package ships the hosted server. Run it standalone (self-host / staging):

bash
PORT=8080 SUPERSERVE_BASE_URL=https://api.superserve.ai \  npx -y -p @superserve/mcp superserve-mcp-http

Or mount the Web-standard handler in any fetch runtime (e.g. a Next.js route handler):

ts
import { handleMcpRequest } from "@superserve/mcp/http"
export const POST = (req: Request) => handleMcpRequest(req)

It serves the MCP endpoint at / (POST) and a GET /health liveness probe. Config: PORT (default 8080), SUPERSERVE_BASE_URL (optional). The API key is read per request from the bearer header and never logged.

Tools

ToolDescription
sandbox_createCreate a sandbox; returns its id. Accepts secrets bindings and egress rules.
sandbox_updateChange a sandbox's metadata or egress (allow_out/deny_out) rules after creation.
sandbox_listList sandboxes (active and paused), filterable by metadata.
sandbox_infoGet a sandbox's status, resources, metadata, network rules, and secret bindings.
sandbox_execRun a shell command; returns stdout, stderr, exit code. Auto-resumes a paused sandbox.
sandbox_computerDrive a GUI desktop sandbox: screenshot, mouse, keyboard, scroll, resize, live viewer URL. Input actions return a fresh screenshot (JPEG).
sandbox_files_readRead a file (UTF-8 text or base64). Rejects files over 1 MiB.
sandbox_files_writeCreate or overwrite a file (inline content capped at 8 MiB locally, about 4 MiB on the hosted endpoint).
sandbox_files_listList a directory.
sandbox_files_download_dirDownload a directory as a base64 ZIP (symlinks skipped). Capped at 10 MiB.
sandbox_pausePause a sandbox (state preserved).
sandbox_resumeResume a paused sandbox (usually unnecessary — exec auto-resumes).
sandbox_killDelete a sandbox.
sandbox_preview_urlPublish a port and return a public or private signed preview URL.
sandbox_network_logAudit a sandbox's outbound connections.
sandbox_template_listList the templates (prebuilt base images) your team can create sandboxes from.
sandbox_template_createBuild a custom template (vCPU/memory/disk shape, preinstalled software). Async.
secret_listList bindable team secrets (metadata only — never values).
sandbox_attach_secretBind a stored secret to a sandbox under an env var.
sandbox_detach_secretRemove a secret binding from a sandbox.

All tools take a sandbox_id except sandbox_create, sandbox_list, sandbox_template_list, sandbox_template_create, and secret_list. Secret creation is intentionally not exposed (the raw value belongs on the SDK/console, not an agent transcript); the server only binds existing secrets.

Configuration

VariableRequiredDefault
SUPERSERVE_API_KEYYes—
SUPERSERVE_BASE_URLNohttps://api.superserve.ai

Development

bash
bun installbunx turbo run build     --filter=@superserve/mcpbunx turbo run typecheck --filter=@superserve/mcpbunx turbo run test      --filter=@superserve/mcp        # unit + in-memory integration (no credentials)SUPERSERVE_API_KEY=ss_live_... bunx turbo run e2e --filter=@superserve/mcp   # live round-trip

The server is a thin adapter over @superserve/sdk; the per-sandbox data-plane access token is managed by the SDK and never exposed to the model.

License

Apache-2.0

Source: packages/mcp/README.md at commit 7eca44e

Tools

20

sandbox_create

Create a sandbox

Create a new Superserve sandbox (a Firecracker microVM). Returns the sandbox id to use in subsequent tool calls. The sandbox is active and ready immediately.

Parametersnamesecretsdeny_outenv_varsmetadataallow_outfrom_snapshotfrom_templatepreview_accesstimeout_secondsauto_delete_secondsidle_timeout_seconds

sandbox_template_list

List templates

List the templates (prebuilt base images) your team can launch sandboxes from. Call this before sandbox_create to choose a from_template instead of guessing a name. Official templates are curated by Superserve, available to every team, and named with the reserved `superserve/` prefix — e.g. `superserve/python-3.11`, `superserve/node-22`, `superserve/openclaw`; names without that prefix are your team's own templates. Returns each template's name, status, and resources; only templates whose status is ready can be used.

Parametersname_prefix

sandbox_template_create

Build a custom template

Build a reusable template (base image) so you can launch sandboxes with a specific vCPU/memory/disk shape or preinstalled software. Sandbox resources are inherited from the template and cannot be set at sandbox_create time, so this is how you get, say, a 4 vCPU sandbox. The build runs asynchronously: this returns immediately with status 'building' (or 'pending'). Poll sandbox_template_list (filter by name) until the template's status is 'ready' before passing it to sandbox_create's from_template. A build can take a few minutes.

Parametersfromrequirednamerequiredvcpudisk_mibready_cmdrun_stepsstart_cmdmemory_mib

sandbox_list

List sandboxes

List your sandboxes (active and paused), optionally filtered by metadata. Returns ids, names, and statuses.

Parametersmetadata

sandbox_info

Get sandbox details

Get current details (status, resources, metadata, timeouts) for one sandbox by id. Read-only — does not resume a paused sandbox.

Parameterssandbox_idrequired

sandbox_pause

Pause a sandbox

Pause a sandbox to save resources. State is preserved; resume it, or just run a command (exec auto-resumes).

Parameterssandbox_idrequired

sandbox_resume

Resume a sandbox

Explicitly resume a paused sandbox. Usually unnecessary — sandbox_exec and the file tools auto-resume a paused sandbox.

Parameterssandbox_idrequired

sandbox_kill

Delete a sandbox

Permanently delete a sandbox and all its state. Irreversible. Idempotent — deleting an already-deleted sandbox succeeds.

Parameterssandbox_idrequired

sandbox_update

Update a sandbox

Change a sandbox's metadata, egress network rules, auto-delete window, or auto-pause timeouts after creation. Use this to lock down or open up outbound network access (rules apply to new connections), or to schedule cleanup of a sandbox you no longer need running. Only the fields you pass are changed.

Parametersdeny_outmetadataallow_outsandbox_idrequiredpreview_accesstimeout_secondsauto_delete_secondsidle_timeout_seconds

sandbox_preview_url

Publish a port and get its preview URL

Publish a sandbox port and return a browser-ready preview URL. Private ports receive an expiring signed URL; public ports receive a clean URL, and unpublished ports remain closed. This does not verify that a process is listening (start one with sandbox_exec, e.g. `python3 -m http.server 8000`).

Parametersportrequiredsandbox_idrequiredexpires_in_seconds

sandbox_network_log

Audit a sandbox's egress

List the outbound network connections a sandbox made (newest first) — host, verdict (allowed/blocked), bytes, and credential-injected requests. Use it to audit what a sandbox actually reached and to verify allow_out/deny_out rules. When has_more is true, pass next_cursor as before to fetch the next page. Read-only — does not resume a paused sandbox.

Parameterslimitbeforeverdictsandbox_idrequired

sandbox_exec

Run a command in a sandbox

Run a shell command in a Superserve sandbox and return stdout, stderr, and exit code. Paused sandboxes are resumed automatically — you do NOT need to resume first.

Parameterscwdenvcommandrequiredsandbox_idrequiredtimeout_ms

sandbox_computer

Control a desktop sandbox (computer use)

Drive a GUI desktop in a Superserve sandbox (requires a desktop template, e.g. superserve/desktop): capture screenshots and send mouse/keyboard input. One action per call. Input actions return a fresh screenshot of the result by default. Screen coordinates are [x, y] pixels with the origin at the top-left. Paused sandboxes are resumed automatically.

Parameterstextwidthactionrequiredheightcoordinatesandbox_idrequiredduration_msscroll_amountscreenshot_afterscroll_directionstart_coordinate

sandbox_files_read

Read a file from a sandbox

Read a file from a sandbox. Returns UTF-8 text by default, or base64 when encoding is set to base64 (use it for binary files). Files larger than 1 MiB are rejected — read a slice with sandbox_exec instead.

Parameterspathrequiredencodingsandbox_idrequired

sandbox_files_write

Write a file to a sandbox

Write a file to a sandbox, creating or overwriting it. Parent directories are created automatically. Set encoding to base64 to write binary content. Inline content is limited to 8 MiB; on the hosted endpoint, keep it under about 4 MiB of text or 3 MiB of binary (base64), or the request fails with HTTP 413. Upload larger files with the SDK/CLI.

Parameterspathrequiredcontentrequiredencodingsandbox_idrequired

sandbox_files_list

List a directory in a sandbox

List directory contents in a sandbox. Returns name, type (file/directory/symlink), size, and modification time for each entry.

Parameterspathrequiredsandbox_idrequired

sandbox_files_download_dir

Download a directory as a zip

Download a directory from a sandbox as a ZIP archive, returned base64-encoded in the result's structured content (symlinks are skipped). Use this to pull a whole folder — build output, results, a small project — in one call. Directories that zip to more than 10 MiB are rejected: grab a subdirectory, pull individual files with sandbox_files_read, or use the Superserve SDK/CLI for the full archive.

Parameterspathrequiredsandbox_idrequired

secret_list

List team secrets

List the team's stored secrets you can bind to sandboxes — names, auth type, and allowed hosts. Returns metadata only; secret values never leave the platform. Bind one with sandbox_attach_secret or the secrets argument on sandbox_create. Create new secrets via the Superserve SDK or console.

Takes no parameters.

sandbox_attach_secret

Bind a secret to a sandbox

Bind a stored team secret to a sandbox under an environment variable. The sandbox sees a proxy token; the platform swaps in the real credential for outbound requests to the secret's allowed hosts. Takes effect for processes started after this call. Auto-resumes a paused sandbox.

Parametersenv_keyrequiredsandbox_idrequiredsecret_namerequired

sandbox_detach_secret

Unbind a secret from a sandbox

Remove a secret binding from a sandbox by its environment-variable key. The proxy token is revoked, so requests using it are refused. Auto-resumes a paused sandbox. Idempotent.

Parametersenv_keyrequiredsandbox_idrequired

Version history

6
  1. v0.3.4LatestNov 5, 2026
  2. v0.3.3Oct 16, 2026
  3. v0.3.2Oct 16, 2026
  4. v0.3.1Oct 9, 2026
  5. v0.3.0Oct 6, 2026
  6. v0.1.3Sep 16, 2026

Score

100% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listed15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts