j0yen/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.
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:
3. 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.
4. 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:
Two real kinds: submit code (python -- source required,
args_schema/requirements 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.
5. 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):
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.
6. 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):
7. 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).
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