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_accountwrite

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.

search_accountsread-only

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.

list_accountsread-only

The whole ledger for this workspace, in one call.

update_accountwrite

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.

Free to 20 accounts. Wired in two minutes.