FounderReply

Developers

Drive FounderReply from Claude, Cursor, or your own code.

FounderReply is an MCP server first. Point an agent at one endpoint, enumerate the tool registry, and call it — persona, content, engagement, SEO, and a real browser. Every call is scoped to a single workspace, and every write passes the same controller the dashboard does: the dial you set per action, and the queue behind it.

  • One endpoint for agents: POST /api/mcp, JSON-RPC 2.0
  • 80 documented /api/v1 routes, live in the browser against your own session
  • A key opens 3 surfaces; the other 78 v1 routes never read the Authorization header
  • The API cannot route around the gate — it passes the same controller the dashboard does

58 tools · 80 routes · read from lib/ at render time

YOUR CODE, YOUR AGENTPOST /api/mcpJSON-RPC · Bearer key/api/v1/*your signed-in sessionGET /api/public/blogread · no keyApprovalqueuesame gate as the appyour networksafter you approveyour own sitepublished posts onlyNo surface here can post without the approval it is configured to need.
58
MCP tools returned by tools/list
80
documented /api/v1 routes
3
surfaces an fr_live_ key opens
78
v1 routes that authenticate on your session and nothing else

Every figure here is read at render time from lib/mcp.ts and lib/v1-routes.ts — the same files the endpoints and the OpenAPI document are generated from.

Quickstart

3 steps, and the last one is a real call.

No SDK to install and no sandbox to request. A key, one HTTP request to enumerate the registry, one more to call something.

  1. 1

    Mint a key

    Keys are created in the dashboard and bound to one workspace at creation. Nothing in the tool arguments carries a workspace id, so a key can only ever operate its own. The key authenticates POST /api/mcp; the 78 session-only /api/v1 routes never read the Authorization header, so send it here and nowhere else.

    founderreply — shell
    export FR_KEY="fr_live_…"
  2. 2

    Enumerate the registry

    tools/list returns every tool the server ships — 58 of them — with its JSON Schema. Nothing in that response is a roadmap item.

    founderreply — mcpPOST /api/mcp
    curl -s https://founderreply.com/api/mcp \
      -H "Authorization: Bearer fr_live_…" \
      -H "Content-Type: application/json" \
      -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
  3. 3

    Call one

    tools/call takes the tool name and its arguments. Reads come straight back; writes — a reply, a post — are enqueued for approval and the response says so rather than pretending to have published.

    Requesttools/call
    {
      "jsonrpc": "2.0",
      "id": 2,
      "method": "tools/call",
      "params": {
        "name": "set_autonomy",
        "arguments": { "action": "reply", "mode": "approve" }
      }
    }
    Protocol errors come back at HTTP 200 inside a JSON-RPC error envelope; a missing or revoked key is a transport-level 401.

Guardrails

One key, and exactly 3 surfaces.

An fr_live_ key authenticates POST /api/mcp, plus the 2 routes that try a bearer first — /api/v1/brain and /api/v1/brain/proposals. The other 78 v1 routes read your Supabase session cookie and never inspect the header at all — a key sent there is not rejected on its merits, it is simply not read.

An fr_live_ key, in full

Everything below is enforced server-side at POST /api/mcp — not by a client library you could swap out.

Always
Authenticate POST /api/mcp, plus /api/v1/brain and /api/v1/brain/proposals
Resolve to exactly one workspace — the tools take no workspace id
Put writes through the same controller the dashboard uses, and the same queue behind it
Honour the autonomy mode set for that action on that network, as written
Return a JSON-RPC error envelope at HTTP 200 when the protocol fails
Never
Authenticate the other 78 /api/v1 routes — those read your session cookie and ignore the header, so a key there is a 401
Skip approval because the call came from an agent instead of a person
Move a dial for you — no plan, upgrade or default raises DMs or third-party comments off gated
Read or write another workspace’s rows
Keep working after you revoke it — the next request is a 401

FAQ

What developers ask before the first call.

It depends which surface you are on, and this is the thing to get right before you write anything. The MCP endpoint — POST /api/mcp — takes an fr_live_ bearer key, which you mint in the dashboard; that is what a key is for. The /api/v1 routes authenticate with your signed-in session instead, because they are the routes the app itself calls, and the 2 /api/v1/brain routes are the only ones that try a bearer key first and fall back to the session. Send a key to any of the other 78 v1 routes and you get a 401 — not because the key is invalid, but because those handlers never read the Authorization header. The public blog read API needs no credential at all; it only ever returns posts you have already marked published.
Not on a setting we chose for you. Writes arriving over the API land in the same approval queue the dashboard uses — send_reply and publish_content enqueue and do not dispatch. Two things change that, and both are yours: raising the autonomy dial for that action on that network, and, for press pitches only, the trust ladder — after fifteen consecutive approvals you made without editing the draft, send_press_pitch starts sending directly, while roughly one in twenty still routes through the queue as a spot-check, and any edit or rejection resets the streak and turns it back off. DMs and comments on third-party threads ship gated on every network and are never raised for you — not by a plan, an upgrade or a default. Raising one is a deliberate change you make yourself, the app names the platform rule you are crossing before it saves, and the decision is written to the audit log.
Any client that speaks JSON-RPC 2.0 over a single HTTP request and response, which covers Claude Desktop, Cursor, Windsurf and your own code. SSE and streamable-HTTP transport are not shipped, so a client that requires server push, notifications or sessions will not connect.
Your own. Every action goes out from an account you connected yourself, under a credential you can withdraw from that network’s own settings — and a key resolves to exactly one workspace, because the tools take no workspace id, so a key can only ever operate the workspace it belongs to.
The next request carrying it gets HTTP 401 from /api/mcp, the same as a request with no Authorization header at all. Revoking is immediate and there is nothing to clean up on your side.

Build on it

One endpoint. Your workspace. Your own code.

Mint a key, enumerate the 58 tools, and drive the whole agent from wherever you already work.

Free to start · Approval on by default · No card required