Why Compound Rebuilt Microsoft Office From Scratch for AI Agents

Yijia Liang introduces himself as a former analyst. He says he was a vice president at Coatue for about three years, specializing in late-stage private software investments.

He says he spent far too much time in Excel, PowerPoint and late nights on that kind of work, so he decided to split off and start building tools to replace his old job.

Liang asks why personal agents took off within the last three months and says his team came up with three main answers. The first is reliable background agents: a user can delegate a task such as booking a restaurant or a flight and it will be done reliably now. He attributes this to computer-use agents having become sophisticated and the models themselves having improved.

The second is proactivity, meaning the agent acts without being asked. He describes waking up to a message that it is your wife's anniversary and you should buy flowers, or better, that the flowers have already been bought. The third is integrations: the agent connects to the systems of context that matter most, such as email, drive and calendar.

Liang argues that the factors making personal agents work so well do not really translate to institutional finance today. The finance analog of booking a restaurant would be taking a data room to a fully prepared set of investment committee models, slides and memos. He says that process normally takes four weeks with multiple rounds of iteration and review, and could be compressed to a few days.

On proactivity, he says a managing director does not want a rogue agent running around doing many things and burning tokens without providing and soliciting input. On context, the relevant material may not be just email or a calendar. It could be a data room with 15,000 files, or SharePoint and Box holding petabytes of unstructured data a firm has collected over its 40-year history.

Liang says the talk will discuss how Compound has approached long-running agents in finance. The first problem is creating a real teammate that collaborates with the user and the deal team, which means multiplayer functionality embedded in the app. The second is running long tasks in parallel in the background and executing them reliably; for this, he says, the company rebuilt Office from scratch. The third is managing the context across everything discussed, including petabytes of data in SharePoint and Box.

Liang says the first question is why multiplayer matters for finance. Looking at the anatomy of a deal team, he says long-running workflows, such as going from a data room into the materials that reach an investment committee, do not work in single-player siloed setups.

He says institutions that have deployed Claude or ChatGPT are all single-player today: people work in a plugin or the web app and produce outputs, but then have to collaborate with their team. In practice that means downloading the file, uploading it to email and to Teams, and asking for feedback. The approach Compound took is to get every person who matters on a deal onto the same thread so that one agent can share the context of everyone involved in a given work stream.

Liang says every agent created at Compound comes with a built-in inbox. He gives the reason as most institutional-finance workflows running through Outlook, with chains of 20 or more emails, and he wants the agent to be part of every one of those conversations.

He says designing email for agents is non-trivial. It requires authentication and making sure everyone on the thread has read and write access to the agent. Because financial firms are always under NDA, privacy is critical and everyone on the thread must be able to talk to the agent. Beyond authentication, he says the team had to design a human-like experience, since the goal is a real teammate.

Liang says that if multiple people email in the same thread in quick succession, the agent should not reply with multiple acknowledgements that spam the group. For that reason, the team wants to bake in more latency so the agent feels more human. He says there are other design decisions involved in creating real email agents for enterprise finance.

Liang says that beyond multiplayer, even after soliciting input from everyone who matters, scaling up the number of tasks and running them in parallel exposed limits in existing solutions. He says the team evaluated a lot: the desktop plugins for Excel, PowerPoint and Word; computer use on virtual machines to scale agents working natively in those applications; and many off-the-shelf engines, including open-source packages such as OpenPyXL and commercial engines available for purchase.

He says none of them really worked for what the team needed. With coding agents dramatically improving and lowering the cost of software, the team decided to build its own Office from scratch. He says agents were run in many loops, consuming 1.5 trillion input-output tokens and writing over 8 million lines of code to rewrite Office.

Liang says the method is simple in concept: point agents at an objective function, which is to recreate Office in full fidelity, and let them run. For Excel, the team started with an open-source solution called IronCalc and asked how it could be recreated perfectly for Excel, using Office as an oracle and running loops.

The team benchmarked against real files from a real-world corpus collected online and files it created internally. After 800,000 lines of Rust, he says, the team had a more performant, one-for-one replica of the product. He says the same approach was applied to PowerPoint and Word, with loops run across each product, and that the recreations can be tried at compound.ai.

Liang says the team used Rust renders to make sure the rendering of these products was pixel perfect. What you see in Compound is what you see when you download to Office. He says one-for-one parity was needed because, at the end of the day, these firms only trust what they can download and send.

Liang says desktop Excel, PowerPoint and Word are bound to the CPU, while headless engines allow tasks to run in parallel much faster. A complex model can be built in a much shorter time, and he says a 20 MB Excel file can be recalculated four times faster. He says every piece of work an analyst would expect an agent to do comes with an expectation of human-level quality at much lower speed and cost, and that a headless engine is needed to achieve this. He says trying to scale this with Excel and PowerPoint would be going down the wrong path.

Liang says performance is not the only benefit. Owning the editor allows a richer product experience in which people can work and collaborate with agents asynchronously. He says the slide deck being shown was built in Compound by dropping in comments: he had the agent create a first draft, then added comments for each formatting point, imparting learnings from his consulting and Coatue days about what makes a great slide.

He says the same works for multiplayer, with several people on a team dropping comments into the same infrastructure. For a team of five, he says, a 100-page deck can be worked through in an afternoon rather than revised in a room over multiple weeks.

Liang says owning the engine also allows iterative checking loops. Writing a complex model might take a few hours, so the question is how to make that faster and more accurate. With a library such as OpenPyXL there is no render to check formatting, so the model is effectively guessing and hoping it writes the right thing, perhaps parsing to see whether a cell has a particular color or font. Using Microsoft's own interface limits the user to what Microsoft provides, which he admits is very little. With an owned engine, the team controls the write, render, check and fix loop and can rapidly iterate on output for the user.

Liang says buy-side firms deal with both breadth and depth of data. A data room may hold over 15,000 files, and some files in it may be well over 20 MB. He notes that people in finance often complain about an Excel model of 30 MB that takes five minutes to recalculate because it has 2 million formulas and five sensitivity tables that must recalculate every time.

For breadth, Liang says the team again takes a page from the coding playbook and applies agent swarms to large numbers of files. He says it is no longer necessary to index everything in a vector database unless for a very specific use case. It is preferable to have coding agents read files through grep or another method, with a lead agent slicing the contents of the file directory and swarms of agents returning insights, then iterating in a loop until the required output is reached.

He says every finding can be grounded with citations to the source document, so the viewer knows exactly which number on the screen links to a source the analyst can trust.

Liang says the goal of all this context is to stop people spending time finding files and reminding the model how to do things. Instead, people should focus on importing their judgment into the deal process, tailoring and training agents and deploying them across the deal flow. He describes the stack as running from connected sources, such as off-the-shelf connectors to SharePoint or Outlook, to cited findings grounded in the sources that matter, and finally to embedded preferences and company knowledge about how a model should look, which differs at every firm. Humans then spend most of their time on whether a deal is good, rather than whether the numbers tie or the model looks right.

Liang compares tasks that are already on autopilot with those still on copilot. He says several finance tasks can be done pretty well with off-the-shelf tools. Spreading comps is one, and he notes that the head of finance at ChatGPT mentioned earlier that they now have their own products for this. He says many longer-running tasks are not yet handled by existing solutions, such as drafting a 50-page investment committee presentation off the cuff, or getting agents to build a model exactly the way a private equity or hedge fund professional wants. Those, he says, remain within the copilot realm, where people want to be deeply embedded in the process without letting go.

He says the tools the team has built let autopilot take over more in finance firms. Rather than using tools embedded in Excel as plugins with hand-holding along the way, users can start delegating and becoming more ambitious about what AI can do.

Liang says finance today reminds him of when Opus 4.5 launched last December, when people stopped using code tools simply as a copilot to generate the next file or line and started delegating far more ambitious tasks. He says developers began to feel they could truly vibe code if they had sufficient checks and tests, and could trust all the code it wrote.

He says the tooling built today, along with what is planned, aims to solve the problems required before finance reaches that point: how analysts and the whole deal team can become more ambitious with AI, drop in a data room, trust each output, and then do this tenfold so they can see more deals and expand what matters.