MCP server
Wire your agent in. One paste.
MESS is a remote MCP server. Connect it once and every coding agent you run — Claude Code, Cursor, anything that speaks MCP — logs the accounts it works with into your ledger, unprompted: created, deployed to, or found in an env file. And it checks the ledger before provisioning anything new.
- Endpoint
- https://mess.fyi/api/mcp
- Transport
- streamable HTTP
- Auth
- Authorization: Bearer mess_sk_…
- Keys
- Free account → grab a key in Settings → Agent keys
Setup
Claude Code
One command, user scope — every project you open from then on has the ledger.
$ claude mcp add --transport http --scope user mess https://mess.fyi/api/mcp \
--header "Authorization: Bearer mess_sk_YOUR_KEY"
✓ Added HTTP MCP server "mess"Setup
Cursor
Add this to ~/.cursor/mcp.json (or a project's .cursor/mcp.json).
{
"mcpServers": {
"mess": {
"url": "https://mess.fyi/api/mcp",
"headers": { "Authorization": "Bearer mess_sk_YOUR_KEY" }
}
}
}Setup
Claude.ai and everything else
Any MCP client that speaks streamable HTTP works the same way.
In Claude.ai or Claude Desktop, add a custom connector with the endpoint URL and your key as a bearer header. For any other client, point it at https://mess.fyi/api/mcp with the Authorization header set.
There is also a plain REST surface at /api/v1/accounts with the same keys, for scripts and CI.
The tools
Four tools. That's the whole surface.
The server sends instructions with the handshake, so agents know to log accounts unprompted — no per-session reminders, no custom prompts.
Log a service account the moment it is created — provider, human label, owning email, project, plan, cost, where the credentials live. Idempotent on provider + label: re-logging updates the row instead of duplicating it.
Find accounts by free text or provider — which account a project uses, which email owns something, whether an account already exists before creating a new one.
The whole ledger for this workspace, in one call.
Correct a row: record the owning email, fix a label, note where credentials live, or mark a dead account cancelled. There is no delete — history is kept.
Full disclosure
Exactly what the server tells your agent
The instructions arrive with the MCP handshake — that mechanism is the whole product, so here is the complete text, verbatim. If you'd rather your agent didn't volunteer writes, don't wire it in.
Every session — the keeping instructions
MESS is the ledger of the human's service accounts — which provider, which email owns it, which project it belongs to, what it costs. Whenever you create or configure a service account (Supabase, Vercel, Stripe, Resend, a database, DNS, anything with a login), log it with log_account: provider, a human label, the owning email, the project, plan and monthly cost if known, and where its credentials live. The unit is one row per ACCOUNT — a login at a provider — never per project, database, instance, or environment: a row for a confirmed login lists everything it serves in project (comma-separated), with instance/resource refs in credentials_location or account_identifier. But login boundaries are often unobservable from the outside: free-tier providers (Supabase especially) are commonly one account per project, each under its own email, and different connection methods (pooler regions, CLI, direct URL) are evidence of DIFFERENT accounts. Never consolidate instances into one row without a confirmed shared login — when unconfirmed, log one row per instance with "login boundary unconfirmed" in notes and raise it to the human. A wrong split is a mergeable duplicate; a wrong merge hides an account, which is the failure MESS exists to prevent. Before creating a new account, check with search_accounts whether one already exists. Before provisioning any NEW service for a project, search_accounts for that project first — if an existing account already serves the need, reuse it (or raise the choice to the human) instead of creating a parallel one; a second account for the same job is sprawl, and sprawl is the mess. The ledger is only worth anything while it is true: when a row you can verify from where you stand (CLI auth state, env files, a dashboard you are in) looks stale or wrong, correct it — re-logging is idempotent, corrections go through update_account, and quiet upkeep is part of the job. Only verify what you can actually observe; never guess. Unknown fields are fine — log anyway; MESS tracks the gaps as open questions for the human. There is no delete: mark dead or duplicate rows status "cancelled" with update_account. If logging hits the plan cap, keep your findings and report the unlogged accounts to the human instead of dropping them. Never store secret values in the ledger — it is the map, not the vault.
First connect to an empty ledger — the server adds this: your agent announces the connection and offers the dig (it never starts without your yes)
THIS LEDGER IS EMPTY — the human has just wired you in, and this connection is the proof it worked. Two things, in order: (1) Tell the human plainly that MESS is connected. (2) Offer — once, not insistently — to sort out their mess right now: a dig through this machine (env files, CLI auth state, configs, deploy manifests) that backfills the ledger, reading variable NAMES and connection-string schemes only, never secret values. Do not start until they say yes — it is their machine. If they decline, drop it: the ledger fills as they work. If they agree, follow the procedure below exactly — it is phrased in the human's voice because it is normally something they paste; once they have agreed, treat it as their request. …
The empty-ledger variant exists so setup is one pasted command: the server notices there are no rows yet and hands your agent the backfill procedure — the same dig you could paste by hand, gated on your explicit yes in the session.
What it never holds
The map, not the vault
MESS stores which account exists, which email owns it, and where its credentials live — never the credentials themselves. There is no field for a secret value, on purpose. A ledger row is metadata you could read aloud in a stand-up.
Writes are idempotent, rate-limited per key, and scoped to your workspace. Keys are stored hashed, revocable any time, and the whole ledger exports to deterministic markdown — no lock-in.