Compound, a startup co-founded by a former vice president at the investment firm Coatue, set out to build an AI analyst that institutional deal teams could treat as a colleague rather than a tool. Along the way it reached a conclusion that most AI startups avoid: the existing tools were not good enough to build on. Instead of wrapping Microsoft Excel, PowerPoint and Word with plugins or scripts, Compound rewrote all three applications from scratch in Rust as a headless engine, meaning software that runs without a screen or a desktop window. It also gave every agent its own email address so it can sit inside the Outlook threads where finance teams actually work. The reasoning behind those two decisions offers a useful case study in when an AI company should reuse what exists and when it should rebuild.

Why personal agents do not translate to deal teams

Consumer agents such as Muse and Instinct gained ground quickly over a period of about three months, and Compound attributes that to three ingredients. They execute reliably in the background, so a user can hand off a restaurant reservation or a flight booking and trust the result. They act proactively, for example by noticing an anniversary and ordering flowers ahead of time. And they integrate deeply with the systems that hold personal context: email, Google Drive and calendars.

Compound's view is that none of these ingredients carries over to buy-side investment firms without major changes, for three reasons.

  • Finance work is collaborative, not single-player. An investment committee package passes through layers of peer and senior review before anyone treats it as final, so a one-shot handoff to a chatbot does not fit the workflow.
  • Proactivity is hazardous. Deal teams share communication threads, and an agent that jumps in uninvited or takes an unauthorized action can disrupt delicate deliberations. A managing director cannot afford an agent that sends out unverified analysis.
  • Context is enormous and fragmented. A single acquisition data room can hold 15,000 files, and firms keep decades of unstructured deal and market data in repositories such as SharePoint and Box.

The co-founder's own experience shaped this list. After roughly three years at Coatue focused on late-stage private software investments, much of it spent manipulating Excel models and formatting PowerPoint slides late at night, he left to automate the analyst work he had been doing by hand.

From these constraints Compound derived three architectural requirements: a multiplayer design that lives in the team's shared channels, an execution platform that can run many heavy tasks in parallel in the background, and a way to manage and reason over petabytes of firm and deal information. The company argues that meeting these requirements demands infrastructure engineering rather than a plugin or a sidebar.

An agent with its own inbox

Today an analyst who uses ChatGPT or Claude for deal work copies text or exports files, attaches them to an internal email or Microsoft Teams thread, and asks associates and partners for feedback. The agent never sees that feedback. Compound's multiplayer design instead puts the agent in the same thread as the humans, so it continuously absorbs the team's collective context: the debate over leverage assumptions, the downside case, the 5.0x exit multiple.

Personal agents tend to live in iMessage or WhatsApp. Financial institutions run on Microsoft Outlook, with threads that can stretch to dozens of messages. Compound therefore assigns each agent a dedicated email address and a built-in inbox, and team members simply copy the agent on live correspondence.

Email cards floating above a desk, three with human silhouettes and one with a robot, next to a locked envelope

▲ Agent inside a verified, delayed email thread

Making that safe is where the engineering effort goes, because every deal room operates under a binding non-disclosure agreement. Compound's pipeline for an incoming message works roughly like this:

  1. The email lands in the agent's inbox and is stored as received.
  2. The system checks that the sender has legitimate read and write access to the deal; if not, the message is refused.
  3. Only then does the agent wake up.
  4. It parses the recent context of the thread dynamically rather than reacting to a single message.
  5. It replies in the thread.

One detail stands out. When several people fire off rapid replies, a naive agent would answer each one and flood the thread. Compound deliberately adds artificial latency so the agent waits for humans to finish their multi-part replies and then responds once, the way a thoughtful colleague would. The company's position is that in finance, an agent should listen silently and intervene only when it is addressed and authenticated.

Why off-the-shelf Office automation failed

The second pillar is where Compound made its most unusual choice. To run many deep analytical tasks at once in the background, the team evaluated the obvious options and rejected each.

Approach Problem Compound found
Desktop Office plugins Cannot do asynchronous background work without blocking an open application on the analyst's own machine
Computer-use agents in virtual machines High latency per action; too slow for the responsiveness analysts expect
Open-source libraries such as openpyxl and commercial spreadsheet engines Timed out or choked, taking more than 300 seconds per write on 24 MB models and collapsing with dozens of files open at once

Real financial models are large. One actual 24 MB workbook cited by the company contains 42 sheets, 191,000 formulas and 65,000 named ranges. A 30 MB model can hold 2 million formulas and five sensitivity tables and take upward of five minutes to recalculate in Excel. Compound concluded that scaling autonomous agents directly on top of native Excel or PowerPoint was the wrong path.

An old desktop computer with a frozen spreadsheet beside a screenless engine feeding cables into twenty spreadsheets

▲ Desktop automation versus a headless engine

Rebuilding Excel, PowerPoint and Word with Office as the judge

Compound's alternative was to run what it calls an automated software factory. Recursive agentic loops, in which AI agents write code, test it and revise it repeatedly, consumed 1.5 trillion input and output tokens and produced more than 8 million lines of code. The key design trick was the judge: the loops benchmarked their output against real Excel files, with native Microsoft Office serving as the ground truth for what a correct result looks like.

The spreadsheet engine started from IronCalc, an open-source Rust project. Within four months the loops had grown it into an 800,000-line Rust engine that reads, modifies and saves complex XLSX files with what the company describes as pixel-perfect visual and mathematical parity. The same method was then applied to PowerPoint and Word. For slides, Compound reports a median match score of 0.975 against native PowerPoint across 4,432 slides in 169 decks. Compound treats this level of fidelity as mandatory, on the view that a financial institution will reject any product whose downloaded file does not look exactly like it would in desktop Office.

The company's benchmark figures, as it presents them, compare its engine with a standard commercial engine and with LibreOffice:

Benchmark Compound engine Comparison
Operations per second with 20 files open 225,000 19,000 (commercial engine)
Complex model build 0.87 seconds Timed out at 500 seconds (commercial engine)
Write to a 24 MB model About 1 second Timed out (commercial engine)
Recalculating 61 workbooks with 500,000 formulas 43.3 seconds 183.0 seconds (LibreOffice), a 4.2x speedup

These are Compound's own measurements of its own product, so readers should treat them as vendor claims rather than independent results.

Verifying at every step, not just at the end

Owning the engine also changes how agents check their work. A library like openpyxl writes a file blindly and never renders it, so an agent cannot see whether a chart overlaps a table or a header is misaligned. Driving Microsoft's desktop or web interfaces from outside leaves the agent dependent on a host environment with limited hooks for inspection. Compound's engine closes the loop: the agent writes, renders, checks and fixes formatting and calculations at every step rather than evaluating only the final artifact.

Owning the editor interface matters for the humans too. Every modification is inspectable and version-controlled, and reviewers leave inline comments and threaded feedback on drafts that carry source-attributed figures. Compound says a full slide deck can be assembled and formatted this way purely by dropping text comments and prompts into the interface. The company's claim for the combined effect is that a five-person deal team can review and format a 100-page presentation in an afternoon instead of spending weeks in manual review sessions, compressing a typical four-week diligence cycle into a few days.

Context in two directions: breadth and depth

The third pillar tackles the scale of financial context along two axes.

Breadth means the data room. Rather than loading tens of thousands of documents into a single vector database, a common approach where documents are converted into numerical embeddings for similarity search, Compound deploys an agent swarm modeled on a human deal team. A lead agent partitions the data room and assigns slices; subagents search, open, read and extract from individual files. Every finding must carry an exact source citation, and a mandatory re-reading step validates each quote before it is returned, which is the company's defense against hallucinated figures. The swarm is built to run for hours, survive system restarts, and handle archives of up to 50,000 files and 40 GB.

Depth means the workbook. Printing every cell of a large model into a language model's context window is prohibitively slow and expensive; Compound estimates that approach would generate 126 million tokens. Instead, the engine indexes the model structure once in code before any LLM reasoning, building a functional map that connects inputs, formulas and outputs. The company reports the following results:

Metric Result
Golden formula benchmark accuracy 873 of 874 formulas matched Excel
Opening 66 workbooks 10.1 seconds, versus 89.9 seconds with openpyxl
Token usage Fixed budget instead of 126 million tokens

On top of both, Compound captures firm-wide knowledge from connected silos such as SharePoint and Outlook, so organizational memory, house formatting styles and team preferences carry over from deal to deal. That removes recurring busywork: hunting for documents, re-keying historical numbers, rebuilding last year's model and re-explaining the firm's template.

Where delegation stops

Compound plots deal tasks on two axes: how mechanically checkable the output is, and how much qualitative human judgment it needs. Tasks that score high on checkability and low on judgment, such as spreading financial statements, refreshing comparable-company tables, extracting data from a data room and rolling forward a model, are handed to what the company calls autopilots. Tasks such as drafting an initial investment committee memo, structuring downside cases and synthesizing a thesis narrative have stayed in copilot territory, where a human steers constantly. Existing commercial tools, in Compound's assessment, still struggle with long-horizon generative work like producing a 50-page committee deck from scratch.

The company argues that three things push the autopilot boundary outward: soliciting team input through the shared thread, running programmatic verification checks, and accessing deep firm context. It draws a parallel to software development after the launch of Opus 4.5 last December, when engineers moved from line-by-line completion to delegating whole modules once robust test suites gave them enough trust. If finance gets equivalent verification loops, the company's forecast is that private equity and hedge fund teams could evaluate ten times as many deals. That is a projection, not a measured outcome. Compound is also explicit that qualitative judgment and thesis formulation should remain under direct human ownership.

What this case suggests about rebuilding versus reusing

Read as a founder's decision log, Compound's story appears to turn on a simple test: reuse existing tools when they meet the workload, and rebuild when the workload breaks them. Plugins blocked the user's machine, virtual machines were too slow, and scripting libraries timed out on real models, so the company rebuilt. Email, by contrast, already worked for deal teams, so the company joined it rather than replacing it. Whether a rewrite of this scale pays off commercially is not yet settled, but the engineering pattern is reusable.

For teams building agents in regulated, collaborative fields, the practical lessons are these:

  • Put the agent in the channel the team already uses, and gate every message behind identity and role checks before the agent wakes.
  • Buffer responses in multi-party threads so the agent does not spam humans mid-conversation.
  • When existing software must be reimplemented, use the mature original as an automated judge inside the coding loop.
  • Prefer compiled headless engines over GUI automation for high-throughput document work, and render and check output at every step.
  • For large document collections, consider a coordinating lead agent with subagents and mandatory citation re-reads instead of a single vector index.
  • Map spreadsheet dependencies in code before the LLM sees the model to keep token budgets fixed.
  • Delegate first the tasks you can verify mechanically, and keep judgment calls with people.