// transactional guard proxy for MCP agents

Your agent failed at
step 3 of 5. Now what?

When an AI performs real actions in your business — creating users, sending emails, charging cards — and one of them fails halfway, ChronoMCP shows the impact in plain language, waits for a human's approval, undoes what's reversible and tells the truth about what isn't.

A transparent guard for MCP agents: impact preview, human approval, automatic rollback, tamper-evident audit.

49 automated tests · validated against 7 different MCP servers · 0 runtime dependencies · MIT

$ chronomcp guard --mode gate --saga -- npx your-mcp-server

┌─ the problem

MCP standardized how agents call tools.
It says nothing about how to undo one.

Agents run multistep jobs against real systems: create the user, grant access, send the email, charge the card. When step 4 fails, steps 1–3 are already committed in three different systems — and nothing at the protocol level knows what is safe to reverse, or how.

Workflow engines solved this decades ago with the saga pattern — inside your own code. MCP tools are other people's code. There was no declarative, portable way for a server to say: "the inverse of this tool is that one, with these parameters." Now there is.

┌─ how it works

One proxy between the agent and the world

  1. InterceptEvery tools/call, over stdio or Streamable HTTP. stdout stays pure JSON-RPC; the human UI lives on stderr.
  2. ClassifyExplicit mcp-compensate metadata → native MCP annotations → conservative name heuristics. Explicit always wins.
  3. Show the impactA human-readable diff: what will run, with which arguments, and whether it can be undone — before any effect.
  4. Gate on approvalTerminal prompt, policy mode, or a remote control plane with Slack buttons and multi-approver quorum.
  5. Compensate on failureLIFO saga rollback driven by static parameter mappings. No LLM anywhere in the rollback path — by design, against prompt injection.
  6. Audit everythingAppend-only JSONL with a sha256 hash chain. Tamper with one line and the chain breaks from there on — verifiable by third parties.

┌─ the saga, scrubbed by your scroll

Watch a failure get unwound

1create_recordcompensable✓ done
2send_emailirreversible✓ done
3grant_accesscompensable✓ done
4charge_paymentirreversible× FAILED
! rollback: 3 step(s), LIFO…
✓ grant_access → compensated via revoke_access
≠ send_email → IRREVERSIBLE (delivered to third parties)
✓ create_record → compensated via delete_record
! 1 action has NO possible reversal — review manually.

The agent only sees the error after the environment is compensated. The report never pretends the email came back.

┌─ the open standard

mcp-compensate — reversibility, declared

A tiny MCP extension (dev.chronomcp/compensate): each tool declares its class in tools/list. Gateways get semantics; clients that ignore it lose nothing.

readonly

No side effects. Flows through, zero friction.

compensable

A declared inverse exists — tool + static parameter mapping, with its limitations in writing.

irreversible

No way back — declared before execution, surfaced in the diff, the report and the audit trail.

"_meta": {
  "dev.chronomcp/compensate": {
    "reversibility": "compensable",
    "compensation": {
      "toolName": "delete_record",
      "parameterMapping": { "id": "$.output.structuredContent.id" }
    },
    "sideEffectScope": ["storage"]
  }
}

No metadata? Reversibility is unknown — never inferred as safe. Full spec, JSON Schema, reference proxy and a complete demo server in the repo.

┌─ what we will not promise

Honesty is the feature

We won't "unsend" your email.

Delivered to third parties means delivered. The server declares it irreversible and the gate demands stronger approval.

A refund is not a reversal.

It's a new transaction with its own fees and latency. Pretending otherwise teaches operators to approve what they shouldn't.

No AI in the rollback.

Compensation is boring, static and deterministic — exactly where a prompt-injected agent would love to "improvise".

┌─ open-core

The standard is free. The operation is paid.

Open · MIT

  • The mcp-compensate spec + JSON Schema
  • The chronomcp CLI — zero runtime dependencies
  • Reference demo server + full test suite

┌─ for teams · early access

Approvals your auditor will love

Running AI agents against real systems at work? We're onboarding a small group of pilot teams: Slack approvals, multi-approver quorum, and a compliance trail your auditor can verify independently. Free during the pilot — you shape the product.

No spam, no newsletter — one email when your pilot slot opens. Or write us: hello@chronomcp.dev

┌─ faq

Questions we actually get

Is compensation the same as undo?

No — and that honesty is the core feature. Servers declare each tool readonly, compensable or irreversible; irreversible actions are flagged before you approve, not after they fail.

Does it use an LLM to roll back?

Never. The compensating tool and its parameter mapping are static declarations. Deterministic rollback is the defense against prompt injection.

Does it break my existing MCP setup?

No. It's a transparent proxy: point your client at chronomcp guard -- <server> and everything passes through unchanged. stdio and Streamable HTTP supported.

What does it cost?

The mcp-compensate spec and the chronomcp CLI are MIT — free forever. The managed Control Plane (Slack approvals, multi-approver quorum, centralized compliance trail) is paid per approver seat, with a free pilot for the first teams and tailored pricing on request. Start a pilot or book a demo →

Is this an official MCP extension?

Not yet — it's a community draft headed for the SEP (Extensions Track) process. The namespace migrates if accepted. Adversarial feedback is welcome.

What is ChronoMCP, in one line?

A transactional guard proxy for AI agents over MCP: it previews the impact of each tool call, gates risky mutations on human approval, rolls back multi-step failures deterministically, and is honest about what cannot be undone — all in a hash-chained audit log.

What is mcp-compensate?

An open extension (identifier dev.chronomcp/compensate) that lets an MCP server declare, per tool, its reversibility (readonly/compensable/irreversible) and, when compensable, the inverse tool plus a static parameter mapping. Declarative metadata only — no transport, no engine, no LLM. Verified against the final MCP spec 2026-07-28.

How is it different from an orchestrator like Temporal, Restate or LangGraph?

Orchestrators implement compensation inside your own workflow code. ChronoMCP is a transparent guard at the protocol level (MCP): it works with any server without rewriting your agent, adds a human approval gate and an impact diff, and is honest about irreversibility. It complements an orchestrator rather than replacing it — see the full comparison.

Who should use ChronoMCP?

Any team letting AI agents touch systems where a mistake hurts — fintech, DevOps/infra, healthcare, e-commerce, SaaS. If an agent can delete data, send email or move money, ChronoMCP is the seatbelt.

Can the audit log be tampered with?

No — it's hash-chained with SHA-256: each entry's hash includes the previous one, so editing any single entry visibly breaks the chain. Anyone can verify it with chronomcp verify or in the browser.

Guard your first agent
in 30 seconds.

npm install -g chronomcp GitHub ↗