PlannedThe MCP server isn't live yet; this is what it will be

Your financial model.In your coding agent.

The plan is a Replafin MCP server that gives your coding agent a typed handle on the same driver-based model your team edits: read every statement, change an assumption, run a scenario, and the balance sheet still ties out to the penny. One server, three first-class clients. None of it is connectable today; the page below is the design, marked as such.

See the planned surfaceUse the model today

No server · no package · no keys to issue yet

Where this stands

The model & its engineLive

Every statement is computed by one pure engine, and the balance test runs on every recalculation. That is the part an agent would talk to.

The in-app assistantLive

The built-in assistant reads the computed model, answers questions and proposes changes to your assumptions. You review edits before applying them; the linked statements then update together.

MCP serverPlanned

Not built. There is no endpoint to point a client at and no npm package to run.

API keys & agent accessPlanned

No keys are issued today. Agent, API and MCP access are listed as Planned on the pricing page too.

We publish the plan early because the shape matters: the tool names, the write rules and the guardrails below are what we are building to. When the server ships, this page becomes the setup guide and every Planned tag on it goes away.

Why MCP

One model, reachable by your agent

MCP is the open standard for connecting tools to LLM clients. The plan is for Replafin to speak it, so any compliant agent works on the exact same model, with the same guarantees the app already gives.

01

Read the truth

Agents will pull the live, computed statements, never a re-derived number. The same engine that powers the UI answers the agent.

02

Edit assumptions

Set a driver (churn, ARPU, headcount, a price) and every statement recomputes. Changes land in the workspace your team sees.

03

Run scenarios

Fork the model, apply a what-if, and compare runway, ARR and margin against the base case without touching the live plan.

04

Stay balanced

Every write goes through the same hard balance gate the app already enforces. If assets don't equal liabilities plus equity, the change is rejected.

The planned surface

A small, typed set of tools

Just enough to read, edit and stress-test the model: no raw spreadsheet access, no way to break the books. This is the design we are building to; names and arguments can still move.

Six toolsNot callable yet
get_model

Return the full set of assumptions and the computed model summary.

read
get_statement

Read any statement: revenue build, P&L, cash flow, or balance sheet.

read
get_metrics

Pull headline metrics: ending cash, net new ARR, gross margin, runway.

read
set_assumption

Change one driver and recompute every dependent statement.

write
run_scenario

Apply a batch of what-ifs to a fork and return the comparison.

write
check_balance

Verify assets − (liabilities + equity) stays within 1e-6 every month.

read

The same rules already govern Replafin's own assistant: it may set drivers and run scenarios, and the engine recomputes every statement. The MCP server hands that contract to an outside agent.

Setup, when it ships

One entry per client, and nothing else

MCP config is the same everywhere: a command, its arguments and a key. Each client just keeps it in a different file. Here is where yours will go.

Planned

These blocks are shapes, not commands. The package name and the key format are placeholders because neither exists yet; running them today would only fail. When the server ships, this section becomes three copyable snippets.

Codex

~/.codex/config.toml

Not live
# ~/.codex/config.toml (shape only)
[mcp_servers.replafin]
command = "npx"
args = ["-y", "<package, at launch>"]
env = { REPLAFIN_API_KEY = "<key, at launch>" }

One [mcp_servers] entry, then restart Codex.

Cursor

~/.cursor/mcp.json

Not live
// ~/.cursor/mcp.json (shape only)
{
  "mcpServers": {
    "replafin": {
      "command": "npx",
      "args": ["-y", "<package, at launch>"],
      "env": { "REPLAFIN_API_KEY": "<key, at launch>" }
    }
  }
}

One entry in your global or project mcp.json, then reload.

Claude Code

claude mcp add

Not live
# shape only
claude mcp add replafin \
  -e REPLAFIN_API_KEY=<key, at launch> \
  -- npx -y <package, at launch>

Registered from the terminal; persists to .mcp.json.

Enterprise deployments already run on your own infrastructure, so when the server lands you will be able to point it at your own instance rather than ours.

Humans stay in control

Agents will write. The books still can't break.

Two of these guardrails already hold. Every number in Replafin comes out of one pure calculation engine that re-runs the balance test on each recalculation, and the assistant may only set drivers; it can never hand-key a statement. The two the server adds, scoped keys and per-change attribution, are being built alongside it.

See pricing
Write guardrailsTwo live · two planned
  • Balance test on every recalculation1e-6
  • Driver writes only, no raw cells✓
  • Scoped, revocable API keysPlanned
  • Attributed & reversible changesPlanned

The model is ready.

The wire is coming.

Build the balanced, auditable model your team trusts today, in the workspace, with the assistant that already edits it by driver. When the MCP server lands, Codex, Cursor and Claude Code plug into that same model, and this page turns into the setup guide.

Open the modelBack to the surface