Building Agentic Spreadsheet Automation from Process Mining to Production

ramp · Finance · 2026 · source Agentic: yes · promotional bias: low · source-backed · extracted with prompt 0.5.4 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Finance operations spreadsheet automation

Ramp needed to automate high-stakes finance workflows that were explained through Loom videos and executed in spreadsheets, without turning those workflows into opaque code that finance professionals could not inspect.

Constraints:

Finance users communicated workflows through video and voiceover rather than formal SOPs.
Mistakes in month-end close and reconciliation workflows were disproportionately costly.
The automation had to preserve spreadsheet-native visibility instead of hiding logic inside Python.
The agent needed sandboxed execution for occasional code-generation escape hatches.

Architecture

Ramp Sheets pairs a spreadsheet UI with an external agent loop, Claude-family models, about ten Excel-shaped tools, and a Modal sandbox running SpreadJS. The agent reads and writes ranges as spreadsheet operations first, uses Python only as an escape hatch, and a separate Inspect loop generates and matures Datadog monitors for production coverage.

Diagram confidence: reconstructed (reconstructed from prose).

flowchart LR
  finance-user[Finance User] --> ramp-sheets-ui[Ramp Sheets UI]
  ramp-sheets-ui --> agent-sdk[Agent SDK]
  ramp-sheets-ui --> spreadjs-workbook-runtime[SpreadJS Workbook Runtime]
  agent-sdk --> claude-models[Claude Models]
  agent-sdk --> excel-tool-set[Excel Tool Set]
  agent-sdk --> modal-sandbox[Modal Sandbox]
  excel-tool-set --> spreadjs-workbook-runtime
  modal-sandbox --> spreadjs-workbook-runtime
  modal-sandbox --> python-escape-hatch[Python Escape Hatch]
  inspect-coding-agent[Inspect Coding Agent] --> datadog-monitors[Datadog Monitors]

Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component	Role	Interacts with
`Finance User`	Subject-matter expert who records workflows, selects spreadsheet ranges, and reviews spreadsheet-native outputs.	`Ramp Sheets UI`
`Ramp Sheets UI`	Spreadsheet editor plus chat interface where users provide context and receive generated workbook changes.	`Finance User`, `Agent SDK`, `SpreadJS Workbook Runtime`
`Agent SDK`	Runs the agent loop outside the sandbox and coordinates LLM calls and tool invocations.	`Ramp Sheets UI`, `Claude Models`, `Excel Tool Set`, `Modal Sandbox`
`Claude Models`	LLM family used for decomposition and spreadsheet actions.	`Agent SDK`
`Excel Tool Set`	About ten tools such as read range, set range, and format range that expose spreadsheet operations directly.	`Agent SDK`, `SpreadJS Workbook Runtime`
`Modal Sandbox`	Isolated execution environment for workbook manipulation and code-generation escape hatches.	`Agent SDK`, `SpreadJS Workbook Runtime`, `Python Escape Hatch`
`SpreadJS Workbook Runtime`	Spreadsheet manipulation runtime loaded inside the sandbox.	`Ramp Sheets UI`, `Excel Tool Set`, `Modal Sandbox`
`Python Escape Hatch`	Last-resort code execution path for tasks not naturally expressible as spreadsheet operations.	`Modal Sandbox`
`Inspect Coding Agent`	Internal coding agent that proposes Datadog monitoring changes for Ramp Sheets.	`Datadog Monitors`
`Datadog Monitors`	Production monitoring layer instrumented and matured by Inspect-generated monitor changes.	`Inspect Coding Agent`

Data flow

Finance users describe or execute workflows in spreadsheet form; Ramp Sheets sends selected ranges and chat instructions to the agent SDK, which calls Claude and spreadsheet tools against a sandboxed workbook, writes formulas or sheets back to the UI, and uses Inspect/Datadog to add monitoring around the product.

“We decided to make it like agentic spreadsheet modifications in the sense of like read this column, read this row, write this row”transcript, stated

“we spin up kind of like a modal sandbox in which we have um spread JS, which is like this Excel manipulation uh library that loads it up”transcript, stated

Why this architecture

Ramp chose spreadsheet-native tool calls because finance professionals could understand formulas and sheets, while Python or generic automation felt too opaque for high-stakes finance work.

“all of these are kind of too black box for the finance professional. Like obviously this is like very high stakes”transcript, stated

“they right away get a lot more visibility into what's happening because they are professionals at parsing Excel spreadsheets.”transcript, stated

Models used: Claude · Anthropic Claude family · OpenAI agent SDK · OpenAI models

Scale

Average conversations were roughly ten minutes, with about seven minutes spent on the agent producing output.
“One one conversation tends to be around like 10 minutes. Um but it's dominated kind of by like the the question answering piece”transcript, stated
“out of the 10 minutes on average I think it would be like 7 minutes of like just the agent grinding on producing an output for you.”transcript, stated
Complex FP&A tasks could run for 30 to 50 minutes, while simpler tasks could finish in 20 to 30 seconds.
“some very complex task in FP&A of like get data from the web around like SEC filings or something, aggregate it together and produce a model for me. It can run for like 30, 40, 50 minutes.”transcript, stated
“if it doesn't need to like go and get out and get like information from anywhere, can be very quick. Like it can be 20 30 seconds.”transcript, stated
The tool set was deliberately small, around ten Excel-specific tools.
“give it in Excel? Uh Excel-wise I think it was around like 10-ish tools maybe. So, not super super large tool set. But different than maybe like bash which is one universal tool or something like >> Yeah. We found that like the especially Anthropic like family of models is like”transcript, stated

Alternatives considered (roads not taken)

Generate Python scripts from process videos.

Rejected because: Python was expressive but unreadable to the finance users who needed to trust and verify the result.

“just Python code gen, we tried N8N, um, we tried like Retool automations. And kind of the feedback that we got was all of these are kind of too black box”transcript, stated

“Python is like a great medium that's very expressive, but to them, it's a black box because They're not going to understand Python.”transcript, stated

Put the agent itself inside the sandbox.

Rejected because: Ramp kept the agent state outside and spun up fresh sandboxes so code-generation steps would not pollute later runs.

“in any way you want but the one that we landed on is like the agent just keeps track of the state outside of the sandbox and then if we need to like the code gen does not get polluted by previous runs because it gets spun up and the sandbox like applies the the coding steps”transcript, stated

“constrain like if there is a code gen step, we don't want it to be polluted any in any way from the previous one and having the agent outside of the sandbox I mean you can it's kind of like this gradient of like you can probably do it in any way you want but the one that we”transcript, stated

Let Python be the normal path for spreadsheet manipulation.

Rejected because: Ramp biased the system toward Excel formulas and kept Python as a last-resort path.

“just as a last resort escape hatch for things that are not possible just through pure Excel formulas. Like we really tried to bias it towards Excel formulas.”transcript, stated

Patterns

`tool-use-orchestration` (agent-architecture)

The spreadsheet agent exposes spreadsheet operations as first-class tools instead of asking the model to write arbitrary code.

“specific tools like read range, set range, format range. And And those are given as actual tools, not as like functions in a repple”transcript, stated

`latency-optimization` (runtime)

Ramp splits fast and expert modes and treats runtime as task-dependent, with short runs for simple tasks and longer agentic execution for complex finance work.

“We have like a a fast and expert mode. Um and the user toggles that?

Yeah, the the user decides and yeah, it depends on the complexity of the task.”transcript, stated

`observability-tracing` (operations)

Ramp uses an internal coding agent to propose and mature Datadog monitors for Ramp Sheets.

“set up Inspect to run an action whenever there's a new PR that gets created. Uh also like as a cron job at night to just instrument uh Ramp sheets with extra DataDog monitors”transcript, stated

`canary-rollout` (operations)

Automated monitors start in shadow mode and are promoted only after signal/noise review.

“then it goes into kind of like this this shadow mode where the monitor alerts won't like bug anyone yet”transcript, stated

“if they run for a while and they're not noisy and the agent deems them to be like good enough, then they get like kind of promoted”transcript, stated

Tradeoffs

Primary automation representation

Chose Spreadsheet-native read/write/formula tools over Python code generation, N8N, or Retool automations.

Rationale: The spreadsheet representation kept finance users in a medium they could inspect and trust.

“we decided to replicate the exact same way as as they performed the work, which is opening an Excel spreadsheet and making the modifications directly in it.”transcript, stated

LLM/tooling fit

Chose Claude-family models for spreadsheet decomposition over The initial OpenAI-leaning implementation.

Rationale: The team observed Claude handled their tool shape and spreadsheet decomposition better.

“the initial version was kind of like more OpenAI leaning and then we discovered like the Claude family just tends to perform much better on the way that we had developed the tools”transcript, stated

Sandbox boundary

Chose Agent outside sandbox with fresh sandboxes per action over Agent state living inside a persistent sandbox.

Rationale: The boundary let the agent keep state while preventing code-generation pollution across runs.

“the agent just keeps track of the state outside of the sandbox and then if we need to like the code gen does not get polluted”transcript, stated

Monitor rollout

Chose Shadow-mode generated monitors with later promotion over Immediate alerting from agent-created monitors.

Rationale: The team wanted extra coverage without noisy automated alerts interrupting engineers.

“the monitor alerts won't like bug anyone yet, but then there's like another agent that will review them”transcript, stated

Gotchas (what bit them)

Code generation was too opaque for the users who owned the finance process.

Root cause: Finance users could inspect spreadsheets but could not meaningfully inspect Python, Pandas, or generic automation code.

Resolution: Move the automation into spreadsheet-native operations and formulas.

“Python is like a great medium that's very expressive, but to them, it's a black box because They're not going to understand Python.”transcript, stated

Reading entire spreadsheets into context would pollute the model context.

Root cause: Large spreadsheets contain more cells than the task needs, so the agent must inspect selectively.

Resolution: Have the agent read ranges in human-like passes instead of loading the full sheet.

“read in diagonals with like these kind of like blocks of it's not going to read the entire thing so that we don't pollute the entire context.”transcript, stated

A generic agent SDK did not remain sufficient as the spreadsheet product matured.

Root cause: The harness became overfit to the spreadsheet workflow and required customized behavior.

Resolution: Keep replacing SDK pieces until the harness matched the product's task shape.

“we had to like rip out pieces one piece at a time and just like customize it. Like it was very very overfit to the task”transcript, stated

Agent-created monitors can become noisy if promoted immediately.

Root cause: Automated monitor creation lacks the same human judgment as hand-authored monitors.

Resolution: Run generated monitors in shadow mode and prune noisy ones before they page engineers.

“if there's a they're like too noisy, then they get pruned because there's not enough signal.”transcript, stated

Evaluation

Ramp evaluated the architecture through user feedback on black-box versus spreadsheet-native automation, observed model/tool performance, runtime behavior, and a monitoring shadow-mode loop for Inspect-generated Datadog monitors.

Metrics: Average session/runtime duration · Monitor noise before promotion · Model/tool fit for spreadsheet decomposition · User acceptance of transparent spreadsheet output

“kind of the feedback that we got was all of these are kind of too black box for the finance professional.”transcript, stated