Mcphost

mcphost

where agents host their own tools · mcphost.dev · status · llms.txt · llms-install.md

Find it in the registry: dev.mcphost/mcphost — connect with the one-URL quickstart at mcphost.dev.

What it is

mcphost is a remote MCP server where your agent publishes its own tools. Your agent writes a tool mid-task, publishes it with one call, and keeps working: the tool is live with no restart and no deploy, and it outlives the conversation that built it. A schedule can fire it while you sleep, another agent can share it, and every run lands in a log you can read.

Under the hood, mcphost serve is one Rust binary that speaks streamable-HTTP MCP at a single endpoint. Everything is a tool call: publish, run, schedule, log, meter, store secrets, share with another agent, act as one of your end users over OAuth. There is no dashboard; /status is the one page, and the operator works through admin.* tools on the same endpoint.

Measured, not promised: p95 34.2 ms across 200 concurrent calls with zero errors, committed next to the test that produces it. The public site is mcphost.dev; the machine-readable summary at /llms.txt is generated from the same source as the quickstart below (docs/agent-quickstart.md, scripts/gen-agent-docs.sh).

Connect

Paste one line into your client and it has mcphost. Your agent's first call creates its account on that connection: no signup form, no key to paste.

Claude Code

claude mcp add --transport http mcphost https://mcphost.dev/mcp

Docs: https://code.claude.com/docs/en/mcp (checked 2026-10-09)

Cursor

Add to Cursor, or add https://mcphost.dev/mcp to your MCP config directly.

Docs: https://docs.cursor.com/en/tools/mcp (checked 2026-10-09)

VS Code

Add to VS Code, or add https://mcphost.dev/mcp to your MCP config directly.

Docs: https://code.visualstudio.com/api/extension-guides/ai/mcp (checked 2026-10-09)

GitHub Copilot in VS Code

{

"servers": { "mcphost": { "type": "http", "url": "https://mcphost.dev/mcp" } } }

Docs: https://code.visualstudio.com/docs/agent-customization/mcp-servers (checked 2026-10-21)

Claude.ai

1. Open Settings, then Connectors, then Add custom connector.
2. Name: mcphost
3. Remote MCP server URL: https://mcphost.dev/login/mcp
4. Save, then enable the connector in a chat to connect.

Docs: https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp (checked 2026-10-09)

ChatGPT

1. Open ChatGPT, then Plugins, then Add.
2. Choose Create custom MCP server.
3. Name: mcphost
4. MCP server URL: https://mcphost.dev/login/mcp
5. Choose OAuth, then Create. On the consent page press Create a new workspace.

Docs: https://platform.openai.com/docs/mcp (checked 2026-10-09)

Codex CLI

codex mcp add mcphost --url https://mcphost.dev/mcp

Docs: https://developers.openai.com/codex/mcp (checked 2026-10-09)

Gemini CLI

gemini mcp add --transport http mcphost https://mcphost.dev/mcp

Docs: https://geminicli.com/docs/tools/mcp-server/ (checked 2026-10-09)

OpenCode

opencode mcp add mcphost --url https://mcphost.dev/mcp

Docs: https://opencode.ai/docs/mcp-servers/ (checked 2026-10-09)

Amp

amp mcp add mcphost https://mcphost.dev/mcp

Docs: https://ampcode.com/manual#mcp (checked 2026-10-09)

Goose

1. In a Goose session, type /extension.
2. Choose Add Remote Extension (Streamable HTTP).
3. Name: mcphost
4. Endpoint URL: https://mcphost.dev/mcp

Docs: https://goose-docs.ai/docs/getting-started/using-extensions/ (checked 2026-10-09)

Warp

1. In a Warp agent session, type /agent-add-mcp.
2. Paste this server config: {"mcphost":{"url":"https://mcphost.dev/mcp"}}
3. Save; Warp starts the server and lists its tools.

Docs: https://docs.warp.dev/agents/capabilities/mcp/ (checked 2026-10-09)

Windsurf

{

"mcpServers": { "mcphost": { "url": "https://mcphost.dev/mcp" } } }

Docs: https://docs.windsurf.com/windsurf/cascade/mcp (checked 2026-10-09)

Cline / Roo

{

"mcpServers": { "mcphost": { "type": "streamableHttp", "url": "https://mcphost.dev/mcp" } } }

Docs: https://docs.cline.bot/mcp/configuring-mcp-servers (checked 2026-10-09)

SDKs

{

"name": "mcphost", "type": "url", "url": "https://mcphost.dev/mcp" }

Docs: https://platform.claude.com/docs/en/agents-and-tools/mcp-connector (checked 2026-10-21)

See the live status page and the Acceptable Use Policy before you point production traffic at it. Plans and limits: plans / /plans.json (same numbers billing.plans returns, and docs/plans.md). Every error payload carries a help_url pointing at a generated /help/ page explaining it.

Support: support channel not configured (MCPHOST_SUPPORT_URL is unset).

Changes

Every release is a git tag, and every change is in CHANGELOG.md.

Ship an MCP tool, not a deployment project.

mcphost lets an agent create the tool it needs, mid-task, without a human in the loop: sign up with one unauthenticated tool call, publish with the next, and the new tool is live immediately — no restart, no deploy, no review queue.

Measured (panel run 0.26.3-20260908T085001Z, 21 sessions): median time from signup to a tenant's first successful host.tool.publish is 30.7s; median time from signup to a successful call on that tenant's own tool is 42.4s.

Quickstart for agents

1. Connect to https://mcphost.dev/mcp -- paste that URL into your MCP client's config. No signup call, no credentials, nothing to paste into a header.
2. Make your first call. host.quickstart() is read-only and hands back a worked example before you commit to anything; any other host.*/ billing.* call creates your tenant right then, on this connection, with no signup call at all -- host.whoami() is the simplest:

   host.whoami()

1. Read onboarding.url once, in that same response, and save it -- it's this tenant's own address and its credential in one; reconnecting through it later is how you come back as this same tenant. onboarding.memory_hint names where agents conventionally keep it. Reconnect rule: a later call on this SAME connection without a key is refused, naming the tenant you already are (data.tenant on the tenant_key_missing response) -- it never creates a second tenant. Use onboarding.url for every call from here on.
2. Publish a tool, reconnected through onboarding.url. host.quickstart()'s own starter_tool is a ready-to-publish python spec; its publish_call is exactly:

   host.tool_publish(name="table_note", kind="python", spec={"source": "import mcphost\n\ndef main(args):\n    mcphost.table.create(name='quickstart_notes', columns={'note': 'text'})\n    mcphost.table.append(table='quickstart_notes', rows=[{'note': args.get('note', '')}])\n    return {'appended': 1}\n"})

Three real kinds: submit code (python -- source required, args_schema/requirements inferred if omitted; js -- JavaScript source defining main(args), args_schema inferred if omitted) or wrap an API you already use (http -- url and method required, args_schema inferred if omitted). echo is a stub for testing the pipes, not a real tool. Before publishing anything, dry-run with host.tool_publish({..., dry_run: true}) -- every gate (secrets, env, network, deps, name, kind, spec size) reported at once, no tool row written -- or host.spec_test(kind, spec, invocations) for up to 5 example calls through the same sandbox a real call uses.

1. Call it -- host.tool_test(name, args) dry-runs an already-published tool by name, or call it directly as . (its own entry in your tools/list):

   host.tool_test(name="table_note", args={"note": "hello"})

try_before_call: args may be omitted on host.tool_test -- the host then runs one example generated from the tool's own schema and returns it as example_args.

1. Share it with a teammate: host.invite.create() returns an /i/ /mcp URL -- whoever connects there and makes their own first call gets a fresh tenant already in contact with you, with any tool names passed as share already shared (see "Share a tool, not a key" in www/llms.txt for sharing one tool while keeping its own key hidden):

   host.invite.create()

1. Relay the claim link to your human: hand them onboarding.url and the sentence "Claim this backend so it belongs to you: ." Never print the personal URL or the key anywhere but that one handoff.

Also useful once you're past the first call: billing.plans()/ billing.status() for plan and quota; host.tool.list()/ host.tool.logs(name)/host.tool.remove(name)/host.usage(window) to inspect and manage; host.secret.set/host.secret.list() for credentials a published tool needs (secrets stored AES-256-GCM encrypted, with a separate plain env map alongside for everything that isn't one). Pass expose_spec: true on host.tool.share (or share names on host.invite.create) to also let a sharee read a tool's source, not just call it -- they read it with host.tool.spec_shared(tool=" . "); shared without expose_spec, the same call fails spec_not_exposed (see "Share a tool, not a key" in www/llms.txt for the full worked example). host.tool.share also takes scopes (what the grantee may do: call, read_source, fork; default ["call"]; url shares allow only call) and rate_per_hour_per_caller; a grantee with fork copies the tool with host.tool.fork(owner, tool, as), and after host.tool.unshare a past caller's next call fails share_revoked.

Explicit signup (clients that cannot keep a session)

A client that can't hold a persistent connection across calls -- so there is no session for mcphost to implicitly bind a tenant to -- signs up directly instead of relying on its first call to create one:

1. Connect to the endpoint and call tools/list with no credentials. The only tool offered is signup.
2. Call signup(name). The response contains tenant, key (a bearer token, shown once), namespace, endpoint, and claim_url. Signup is rate-limited to 5 per IP per hour. Pass source (e.g. signup(name, source: "hn")) to tag which channel this signup came from -- recommended values are hn, reddit, discord, registry, plugin, docs; it's echoed back in the response and broken out in admin healthz, but never required. If signups are paused (an operator's kill switch for an abuse spike), the call fails with signup_paused and a retry_after_secs; try again later. An operator pauses and resumes signups without a shell with the admin tool admin.signup_pause (message to pause, optional until; resume: true to