For AI agents
Give your AI agent a real diff for .xlsx
SheetDelta has an MCP server and a token-lean CLI in development, so Claude, Cursor, and your own agents will be able to compare and read Excel workbooks, and you can see exactly what an agent changed, down to the formula.
Reads .xlsx/.xlsm/.xlsb/.xls directly, with no Excel, and runs locally. Not yet publicly released; the free browser tool works today.
The same change, to an agent, before and after
# 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 cannot tell what 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 reading before anyone relies on the number.
An MCP server for Excel
Run sheetdelta mcp and your assistant gets
seven read-only tools that read workbooks directly, with no Excel and 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. |
| audit | Risk-check a single workbook with no second file: concealed cells, numbers stored as text, region-omitting formulas, risky approximate lookups, a rescaled chart axis, weak protection. |
| inspect | List the workbook’s distinct formulas with a complexity band and how many cells reuse each one. This is where the heavy logic in a model lives. |
| anatomy | How the file is built: sheets including hidden and very-hidden ones, named ranges, VBA modules, links out, data connections, charts, pivots, calculation mode. Small and cheap, so call it first. |
| reach | Whether a change to one cell can reach a figure, through the precedent graph. Structural only: it never says by how much, and it reports what it could not follow. |
| merge_plan | What a three-way combine of two divergent versions would do against their ancestor: which changes merge cleanly and which conflict. Read-only; it writes no file. |
The hosted platform speaks MCP too
The tools above read files on your machine. The platform’s MCP server is a URL your client signs into instead, with nothing installed. Because it sits inside the review layer, it answers questions the local tools cannot: which workbooks a team watches, what changed between two versions of one of them, which controls that change broke. Four of its tools write: an agent can comment on a cell, reply in a thread, acknowledge a finding, or submit a change for review. All of it under the signed-in person’s own permissions, and all of it in the audit trail. Sign up to connect yours.
Token-lean output, built for agents
-f agent streams one small JSON object
per change: A1 references, rendered values (formulas as =…) and 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
hosted platform,
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 schemaFrom "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 and the same diff, with a review around it. Combine, the platform’s three-way merge, still writes nothing until a person has approved each group.
Local and private. The agent CLI and MCP server read your workbooks on your machine and send no file data anywhere. There is no licence key, no activation and no phone-home. They make no network calls at all.
What it looks like when an agent makes the change
A version submitted through the platform API carries the assistant that sent it and what it says it did, and the platform checks that description against the cells that moved.
-
And when an agent made the change. A version submitted through the API says which assistant sent it and what it claims to have done. SheetDelta checks that claim against the diff: ten cells changed, seven inside what it described and three outside. It names the three.
Screenshots of the hosted platform. The workbook is our demo model, and no customer data appears anywhere on this site.
Frequently asked questions
What is an MCP server for Excel?
sheetdelta mcp and exposes seven read-only tools: diff (compare two workbooks), dump (read one to JSON), audit (risk-check one), inspect (its formulas), anatomy (how it is built), reach (which figures a cell can move) and merge_plan (what a three-way combine would do). An agent in Claude Desktop, Cursor, or any MCP client can read .xlsx files directly, with no Excel installed and nothing uploaded. It is built and tested but not yet publicly released. Which AI tools can use SheetDelta?
sheetdelta CLI directly. How do I let Claude or Cursor read and diff Excel files?
mcpServers.sheetdelta entry above to your client’s config, then ask your assistant to compare two workbooks and it will call the diff tool. That needs the CLI on your machine, which is not yet publicly released. The hosted platform’s MCP server needs nothing installed, because it is a URL your client signs into once your team is on the platform. Why not hand the agent the raw .xlsx or a full JSON dump?
-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 will not blow the context window. Does the agent upload my workbook anywhere?
Does it need Excel installed?
Put your agent on a workbook today
Wire up the MCP server, or pipe the CLI into your own tooling, and see exactly what changes.
