For AI agents

Give your AI agent a real diff for `.xlsx`

SheetDelta ships an MCP server and a token-lean CLI, so Claude, Cursor, and your own agents can compare and read Excel workbooks — and you can see exactly what an agent changed, down to the formula.

Add the MCP server See the agent CLI

Reads .xlsx/.xlsm/.xlsb/.xls directly — no Excel, runs locally. Ships with SheetDelta Desktop.

The same change — to an agent, before and after

A raw workbook unreadable / heavy

# What an agent sees without SheetDelta
$ cat model.xlsx
PK\x03\x04\x14\x00\x06\x00 ...binary zip of XML...

# A full JSON dump is readable — but thousands of
# tokens of styles and shared strings, mostly noise.

-f agent output ~10× leaner

$ sheetdelta diff model.before.xlsx model.xlsx -f agent
{"sheet":"Assumptions","ref":"B12","op":"modified","kind":"formula","old":"=Growth*0.08","new":"=Growth*0.09"}
{"sheet":"Headcount","ref":"A14","op":"added","kind":"text","new":"Q2 backfill"}
{"sheet":"Summary","ref":"D7","op":"removed","kind":"formula","old":"=SUM(D2:D6)"}
{"sheet":"Notes","op":"sheet_added"}

AI agents are editing spreadsheets. Can you see what they changed?

An agent can open a workbook, rewrite a formula, and save it in seconds. To Git and to most tools, the result is an opaque binary blob — you can roll the file back, but you can’t tell what actually moved. SheetDelta gives the agent, and you, a precise cell-level diff of every change: formulas (compared as logic, not text), values, inserted rows, renamed sheets, named ranges, and VBA.

You wouldn’t merge a code pull request without reading the diff. A spreadsheet an agent touched deserves the same — that’s the difference between trusting an automated change and verifying it.

An MCP server for Excel

Run sheetdelta mcp and your assistant gets two tools that read workbooks directly — no Excel, nothing uploaded. Point any MCP client at it with one small config entry:

{
  "mcpServers": {
    "sheetdelta": {
      "command": "sheetdelta",
      "args": ["mcp"]
    }
  }
}

Tool	What it does
diff	Compare two workbooks and return a compact, agent-friendly summary of every changed cell, formula, and sheet. Options for full comparison (styles, VBA, charts, pivots) and a max-changes cap.
dump	Read one workbook and return its full contents as JSON — cells by A1, formulas, VBA, charts, pivots, and named ranges.

One-click setup with the desktop app

SheetDelta Desktop bundles the sheetdelta command and can register the MCP server for you. Turn on AI agent access in settings and it adds the sheetdelta server to every agent client you have installed — Claude Desktop and Cursor today — without touching anything else in their config.

Token-lean output, built for agents

-f agent streams one small JSON object per change — A1 references, rendered values (formulas as =…), no style noise. It’s about 10× leaner than full JSON, so even a big diff stays cheap to read. The example at the top of this page is exactly what it prints.

Around that, a few flags keep an agent in control of its own context budget:

# Did anything change, and roughly what? (~1 line, cheap pre-check)
sheetdelta diff old.xlsx new.xlsx --summary
# {"changed":true,"cells_modified":2,"sheets_added":1}

# Cap a huge diff so it can't flood the context window
sheetdelta diff old.xlsx new.xlsx -f agent --max-changes 200
# …up to 200 lines… then {"truncated":1543}

# Branch on the result from the exit code (1 = changed, 0 = identical)
sheetdelta diff old.xlsx new.xlsx --exit-code

# Scan many pairs at once — one summary per pair
printf '%s\n' '{"old":"a.xlsx","new":"b.xlsx"}' | sheetdelta diff --batch

Full flag list and the JSON schema for every op and kind are in the command-line reference, or run sheetdelta skills get core --full.

Let an agent check its own work

The most useful pattern: snapshot the workbook, let the agent edit, then diff. A blind write turns into an auditable change the agent can summarize back to you — and that you can review.

# Snapshot before the agent edits
cp model.xlsx model.before.xlsx

# …the agent edits model.xlsx…

# Diff after — a blind write becomes an auditable change
sheetdelta diff model.before.xlsx model.xlsx -f agent --all

The same --exit-code check makes a clean CI gate: fail the job if a workbook changed in a way nobody approved. See git diff for Excel for the repo and pull-request side of this.

Instructions that never go stale

The CLI serves its own usage guide, so an agent’s instructions always match the installed version instead of drifting against a copy pasted into a prompt months ago.

# The binary serves its own usage guide — always matches your version
sheetdelta skills get core          # workflows + agent output formats
sheetdelta skills get core --full   # + the full flag list and JSON schema

# Or add it to Claude Code as a plugin
/plugin marketplace add sheetdelta/sheetdelta.com
/plugin install sheetdelta@sheetdelta

From "the agent did something" to "here’s what it did, and who approved it"

Seeing the diff is step one. For a team, the next step is sign-off: pair an agent’s changes with SheetDelta’s hosted review and approval, so a human signs off before an agent-edited model reaches the people who trust the number. The same engine, the same diff — now governed. SheetDelta makes changes reviewable; it never auto-merges workbooks.

Local and private. The agent CLI and MCP server read your workbooks on your machine and send no file data anywhere. The only network call is an optional, one-time license activation that exchanges a key — never your files.

Frequently asked questions

What is an MCP server for Excel?

An MCP (Model Context Protocol) server lets an AI assistant call tools on your machine. SheetDelta’s MCP server runs with sheetdelta mcp and exposes two tools — diff (compare two workbooks) and dump (read one workbook to JSON) — so an agent in Claude Desktop, Cursor, or any MCP client can inspect .xlsx files directly, with no Excel installed and nothing uploaded.

Which AI tools can use SheetDelta?

Anything that speaks MCP or can run a shell command. The desktop app wires the MCP server into Claude Desktop and Cursor in one click; any other MCP client works by adding the same small config. Agents that run shell commands (Claude Code, CI bots, your own scripts) can call the sheetdelta CLI directly.

How do I let Claude or Cursor read and diff Excel files?

Two ways. With SheetDelta Desktop, open settings and turn on "AI agent access" — it registers the bundled MCP server in every agent client you have. Or add the mcpServers.sheetdelta entry above to your client’s config by hand. Either way, ask your assistant to compare two workbooks and it will call the diff tool.

Why not just hand the agent the raw .xlsx or a full JSON dump?

A raw .xlsx is a binary zip — an agent can’t read it. A full JSON dump is readable but heavy: thousands of tokens of styles and shared strings, most of it irrelevant to what changed. The -f agent format streams one small object per change with A1 references and rendered values — about 10× leaner than full JSON, so a large diff won’t blow the context window.

Does the agent upload my workbook anywhere?

No. The CLI and MCP server read your files locally and send no workbook data to our servers, or anywhere. The only network call is an optional, one-time license activation that exchanges a license key — never file contents. Air-gapped setups can activate with an offline signed license and stay fully offline.

Does it need Excel installed?

No. SheetDelta reads .xlsx, .xlsm, .xlsb, .xls, .xltx, .xltm, and .xlam directly, so it runs on a plain Linux CI runner or a locked-down laptop with no Office.

Is the agent tooling free?

The in-browser web tool is free for humans. The CLI and MCP server ship with SheetDelta Desktop (a one-time license), which also entitles use in your agents and CI. Activate with sheetdelta license activate --key <KEY>.