How an analyst and Claude share a .deepcell

Halfway through a build, the question shows up: am I supervising the agent, or driving? The model is taking shape. The dashboard is filling in. Some of the cells you wrote; some Claude wrote. By Friday you'll send this to a partner with your name on it.

Where exactly is the line?

The handoff most demos hide#

Most agent demos cut away from the seam. The prompt goes in, the deliverable comes out, the analyst nods. It looks like collaboration. But "Claude built this" and "I built this" are not the same artifact, and the difference is what determines whether you can sign your name to it. If the line between the two isn't legible, you didn't share the work. You ceded it.

The fix isn't more guardrails on the agent. It's a shared surface where every move is visible — to you, in the moment, and to anyone reviewing later.

The file is the surface#

A .deepcell is that surface. The analyst opens it in the playground or edits it from the CLI. Claude opens it through MCP. Both read and write the same XML, the same item definitions, the same calc graph. No mirror, no proxy, no "the agent's working copy." One file.

Every interaction is captured twice. During the session, you watch the agent's tool calls in the transcript. After the session, every edit is a commit in the file's git history. You don't have to ask what did the agent do? — you can deepcell diff it.

How the wiring actually works#

Connect. Claude.ai, Claude Code, or any MCP client connects to your DeepCell workspace through a single tool: deepcell(command). It wraps the entire CLI. Local clients run over stdio with no auth. Remote clients use OAuth 2.1 with PKCE and an API key — the dck_ prefix is the giveaway — managed at /settings/api-keys in the frontend.

Delegate. The orchestrator is Claude Sonnet 4.5, configured in backend/conf/conf.yaml. It hands bounded jobs to three subagents, each driven by a complete per-task brief:

• general-purpose — executes research, modeling, and report briefs with web search, file search, the format guide, and CLI-style model commands.
• statement-extractor — pulls filings from SEC EDGAR and categorizes line items.
• excel-extractor — converts .xlsx into .deepcell (see bringing your Excel model).

None of them improvises beyond its brief and tool surface. An extraction subagent doesn't rewrite your formulas; a modeling brief doesn't go off to scrape a 10-K it wasn't asked for.

Edit. A short transcript, the kind you'd actually see:

You: Add a sensitivity table for WACC ± 100bps and terminal growth ± 50bps.

Claude: Adding the sensitivity grid as a calc with explicit dependencies.

  deepcell defs add-calc \
    --item-id Sensitivity_WACC \
    --formula "DCF_Value(WACC + wacc_delta, g + g_delta)" \
    ...

  Calc added. 12 new cells materialized. Dependencies tracked.

You: deepcell diff

  + ItemDef:    Sensitivity_WACC (level 0)
  + CalcDef:    DCF_Value parameterized
  + 12 values   under Sensitivity_WACC x scenario grid

You didn't have to inspect the formula bar of twelve cells. The diff is structural — a new ItemDef, a new CalcDef, the values that fall out of them. If anything looks wrong, you restore and ask again.

What the agent cannot do#

This is the part that matters most, and it's the part no MCP-in-Excel story can offer.

Ten CLI commands are blocked from MCP: login, register, verify-email, to-excel, clone, status, pull, push, commit, merge. The pattern is consistent — anything interactive, anything that produces binary output, anything with external or persistent side-effects stays with the analyst.

The agent can read your file. It can query values. It can edit values and definitions. It can run reasoning queries — which claims support this assumption, which evidence contradicts it — over the typed reasoning graph. It cannot push a commit to your remote. It cannot ship an .xlsx to a stakeholder behind your back. It cannot log in as you.

Blocking to-excel in MCP is deliberate. Binary output and external sharing are decisions, not edits — they belong with the analyst. The CLI still runs to-excel locally for you whenever you ask.

Review happens once, at the end#

Because every edit is a git commit, you don't need to babysit each step. Let the agent work. When the session is done, run:

deepcell log --since "1 hour ago"
deepcell diff HEAD~5

Scan the structural changes. Inspect the reasoning graph for the new claims the agent introduced. Accept the run, or deepcell restore to the commit before the agent touched anything. The handoff is legible because the file remembers everything that happened to it. See show your work for how the reasoning side of that audit trail is captured.

Why this is different from "AI in Excel"#

Excel doesn't have an MCP. There's no equivalent tool surface that an external agent can drive while the user watches and a versioned file records the result. "AI in Excel" plateaus at the cell — it can fill values, write a formula, run a macro. It cannot carry the structure of the conversation that produced those changes, and it cannot be reviewed at the level of what did the agent decide? You get a workbook that looks the same as it did yesterday, with new numbers in it, and no durable record of why.

The format is what makes the agent's work legible. The git history is what makes review tractable. The MCP block list is what keeps the analyst's signature attached to anything that leaves the workspace.

Where the line is#

Claude reads, queries, proposes, edits. The analyst commits, exports, ships, signs.

That's the line. It runs through commit and to-excel, and it is deliberately enforced by the protocol, not by trust.

Coexistence, again#

Excel doesn't have an MCP — but it does have you. Use both. The point isn't to replace your tooling; it's that some workflows that used to end in fog now end in a clean handoff. You can see what the agent did. You can undo what the agent did. You can put your name on what's left, and mean it.

Round-tripping a model back to Excel is the next piece of the story — what happens when you export the file the agent and you built together.

See it for yourself — open a sample .deepcell in the playground. Edit a value, watch the dependents recalculate, inspect the reasoning behind any number.