October 14, 2026Main stage5 min read

Towards Autonomous Analysts in Finance

An investment team needs more than a chatbot that produces a spreadsheet. Yijia Liang explains why Compound built shared agents, its own Office engines, and tools for navigating large data rooms before asking analysts to delegate longer pieces of work.

Yijia LiangCompound AICo-Founder

From the conference livestream · 1:59:37–2:15:23 on YouTube. The player starts and stops at this session’s boundaries.

1:59:37 ↗

A restaurant reservation is a small delegation

A personal agent can book a restaurant and report back. The analogous delegation on an investment team is much larger: take a data room and produce the models, slides, and memos needed for an investment committee. Work that normally takes weeks includes several people's judgment and repeated review.

Yijia Liang, cofounder of Compound, starts with that gap. Reliable background execution, proactivity, and integrations helped personal agents become useful. Each creates a harder requirement inside institutional finance.

A managing director may not want an agent launching work without asking. The context can span a data room of 15,000 files or decades of unstructured material in SharePoint and Box. And the output belongs to a deal team, not just the person who typed the first prompt.

Compound's approach follows those requirements: put the team and agent in the same conversation, provide execution tools that can run long tasks in parallel, and organize the context those tasks need. Liang's most expensive response to the execution problem was to build new spreadsheet, presentation, and document engines.

2:02:56 ↗

Put the agent on the same email thread

A single-user assistant can produce a useful file and still leave the collaboration problem untouched. The analyst downloads it, uploads it to email or Teams, requests feedback, and then has to carry that feedback back to the assistant. Different people develop different versions of the context.

Compound gives agents an inbox so they can participate in the email threads where the deal team already works. Everyone who matters to a workstream can contribute to the same agent's context. That requires more than forwarding messages to a model.

The email path below checks the sender before the agent wakes and responds. A message arriving on a thread does not automatically establish permission to read or change the work.

Compound's email flow moves from copied email to agent inbox and storage, checks the sender, then wakes the agent and replies on the thread; failed sender checks are refused.

Source frame at 2:04:50. This permission check matters on deal teams working under confidentiality agreements. The agent needs to know who is entitled to participate before acting on the message.

Responsiveness also means knowing when to wait. If several colleagues email the thread in quick succession, an acknowledgment for every message can spam the group. Liang deliberately adds some latency so the agent can collect the conversation and respond in a way that fits the team's work.

2:05:12 ↗

Use Office as the judge for a new engine

Sharing the conversation does not solve parallel execution. Compound evaluated desktop plug-ins, virtual machines running Office, open-source libraries, and commercial engines. Liang says those options did not meet the requirements for running many long tasks at once, so the team built its own engines.

He reports using 1.5 trillion input and output tokens and generating more than eight million lines of code across that effort. For the spreadsheet engine, the starting point was IronCalc. Agents then worked against Office as an oracle, comparing behavior on files gathered from public sources and files created internally.

The slide shows the feedback cycle: test calculated values, exercise real files, and improve speed, with Excel providing the reference behavior.

Compound's spreadsheet-engine slide shows four months and 800,000 lines of Rust alongside a loop comparing calculated values with Excel, exercising real files, and measuring speed.

Source frame at 2:06:28. Liang reports reaching roughly 800,000 lines of Rust for the spreadsheet engine. Those scale figures describe the development effort; the useful test is whether the resulting files calculate and render as expected.

He describes similar work for PowerPoint and Word, with rendering checks intended to make the in-app result match the downloaded Office file. That compatibility claim is central to the product: investment firms still need files they can send and open outside Compound.

A headless engine can run without maintaining a desktop application for each task. Liang argues this makes parallel execution easier and reports recalculating 20 MB spreadsheets four times faster in Compound's comparison. The figure is a reported workload result, rather than a promise for every workbook.

2:08:05 ↗

Owning the editor closes the checking loop

The engine also changes how people review the agent's work. Liang says he made the presentation itself by asking for a draft and leaving comments on its formatting. Multiple teammates can comment on the same file, giving the agent their corrections where the problem appears.

The larger engineering benefit is the ability to inspect an intermediate result. Writing a workbook through a library can set a cell's font or color without showing the agent what the whole sheet looks like. A desktop interface can supply that view, but adds a running host to the process. Compound controls both writing and rendering, so it can check and repair the output as it develops.

Compound compares a write-and-deliver code library, a hosted write-and-look interface, and its own write-render-check-fix cycle.

Source frame at 2:09:30. The circular path on the right lets a formatting or calculation problem feed into another edit before delivery. It gives long-running work a shorter correction cycle.

2:09:39 ↗

Handle many files and large files differently

A data room creates two problems. Breadth means thousands of files; depth means individual workbooks large enough to contain millions of formulas and expensive recalculations.

For breadth, Liang borrows from coding agents. A lead agent divides the directory, other agents inspect the files using search and file-reading tools, and their findings return for further investigation. He prefers this approach to indexing everything into a vector database by default, while leaving room for indexing where a specific use case needs it. Findings link back to their source documents so an analyst can inspect the number behind the answer.

For depth, the custom engine can expose the workbook through tools designed for the agent. Instead of printing enormous amounts of spreadsheet structure into the model's context, the engine processes the file and presents relevant information in a form the model can use. Richer APIs make large models easier to work over without serializing everything into a prompt.

The layers above those files preserve what the firm learns: cited findings, team corrections, preferred formats, and company conventions. An analyst should spend less time finding a document or explaining the house style again, and more time applying judgment to the deal.

Liang ends by asking teams to become more ambitious about delegation. Off-the-shelf assistants already help with bounded tasks such as comparable-company work. A fifty-page investment-committee presentation or a firm-specific financial model asks more of the surrounding system. Shared context, inspectable files, and repeated checks are Compound's proposed route toward letting an agent carry those longer assignments while the team concentrates on the investment decision.

Further reading

  • Compound ↗

    The financial-analysis workspace and Office engines presented in the talk.

  • IronCalc ↗

    The open-source spreadsheet engine Liang identifies as Compound’s starting point.

Full transcript 248 timestamped passages

Machine transcription with reviewed terminology and names. Some recognition errors may remain. Timestamps refer to the original livestream.

1:59:40Hi, my name is Yijia Liang. I'm the co-founder of Compound AI. We sell analysts for buy-side finance, and specifically we specialize in long-running analysts.

1:59:50Think cloud agents that Devon or Factory might do for coding agents, but tailoring that for buy-side institutions.

1:59:57I was previously an analyst in a previous life. I was

2:00:00a vice president at Code2 for about three years, specializing in late-stage private software investments. Spent way too much time in Excel, PowerPoint, and late nights doing that type of work and so decided to split and start building tools to replace my old job.

2:00:14Quick show of hands, how many people in here have used user instinct in the last day?

2:00:20I expected more hands, but maybe people are too shy to raise them.

2:00:25And how many people know an analyst in finance that fully delegates their work to AI, fully

2:00:31hands off, running it autonomously?

2:00:33One, but a lot fewer.

2:00:37I think if you think about the question, why did personal agents take off within the last

2:00:41three months, internally we came up with three main answers.

2:00:45The first, reliable background agents.

2:00:47You can delegate a task, book a restaurant, book a flight, and it'll do it reliably now.

2:00:53Computer use agents have gotten sophisticated.

2:00:55The models themselves have gotten better.

2:00:58The second is proactivity.

2:01:00It'll do things without you asking.

2:01:02It's part of that magical experience when instinct wakes you up saying,

2:01:05it's your wife's anniversary, go buy some flowers.

2:01:07Or better yet, I already bought the flowers for you.

2:01:10And finally, integrations.

2:01:12It's connected to the systems of context that matter most for you.

2:01:14Email, drive, calendar.

2:01:19all the factors that make personal agents work so well doesn't really translate to institutional

2:01:26finance today.

2:01:27If we think about background tasks, something as simple as booking a restaurant reservation,

2:01:33the analog equivalent in by-side finance might be how do you go from a data room to a fully

2:01:38prepared set of IC models, slides and memos.

2:01:41taking a process that would normally take four weeks, multiple rounds of iteration and review,

2:01:46and compressing that to a few days.

2:01:49If we think about proactivity, your managing director doesn't really want an agent rogue

2:01:55running around doing a bunch of things and burning tokens without them providing and soliciting input.

2:02:00And then finally, if you think about the context that matters, it's not just email, it's not just calendar.

2:02:05It could be a data room with 15,000 files.

2:02:08It could be SharePoint box with petabytes of unstructured data the firm has collected in its 40-year history.

2:02:14So how do you deal with these problems?

2:02:17So the purpose of today's talk is to discuss a bit more about how we at Compound have approached the problem of solving long-running agents in finance.

2:02:26On one hand, it's creating a real teammate that collaborates with you in the deal team.

2:02:31So that's multiplayer embedding that into the app.

2:02:34On the other hand, it's solving for how can you run long tasks in parallel in the background, reliably execute them.

2:02:42And so for that, we actually rebuilt Office from scratch.

2:02:45And then finally, it's how do you manage the context of everything.

2:02:48Everything we just discussed, petabytes of data in SharePoint in Box.

2:02:52And we'll talk a little bit about how we've designed a solution for that.

2:02:56So the first question we have to ask, I think, is why does multiplayer actually matter for finance?

2:03:01If you look at the anatomy on a deal team, the type of tasks that matter for long-running

2:03:06type of workflows, for example, going from a data room into all the sorts of materials

2:03:11that make its way in front of an investment committee, it doesn't work for the single-player

2:03:16siloed workflows.

2:03:17Today, for people who have deployed Cloud or ChatGPT in their institutions, it's all single-player.

2:03:24People working in a plug-in, people working in the web app, producing outputs, but invariably,

2:03:30those people need to collaborate with their team.

2:03:32And what does that look like?

2:03:33It means downloading the file, uploading it into email,

2:03:36uploading it to Teams, asking for feedback.

2:03:39I think the right way to approach this,

2:03:41and this is the way we've thought about at Compound,

2:03:43is how do you get every person who matters on a deal

2:03:45onto the same thread?

2:03:46How can they all talk to the same agent

2:03:48so that one agent can share the context of everyone who matters

2:03:51for any particular work stream?

2:03:55When we thought about how do we actually bring multiplayer

2:03:58into a familiar context,

2:04:00We looked again towards personal agents.

2:04:02Why did they work so well?

2:04:03Well, you can easily text one in iMessage,

2:04:05or you can text one in WhatsApp.

2:04:08So for agents at Compound, every single one you create

2:04:10comes with a built-in inbox.

2:04:12Because ultimately, at the end of the day,

2:04:14for institutional finance, most workflows run through Outlook.

2:04:16You'll have chains of emails, 20 or more running.

2:04:19You want an agent to be part of every single one

2:04:22of those conversations.

2:04:25Designing email for agents is actually non-trivial.

2:04:28It's not just as simple as hooking it up with an email inbox.

2:04:31It requires A, authenticating, making sure everyone part of that thread has read and write access to that agent.

2:04:38Ultimately, at these financial firms, privacy is incredibly important.

2:04:42You're always under NDA no matter what deal you look at,

2:04:44and so you want to make sure everyone on that thread can actually talk to the agent.

2:04:48But then beyond authentication, you also have to think about how do you design a real human-like experience,

2:04:53because after all, we're trying to create a real teammate.

2:04:55If multiple people email in the same thread in quick succession, you don't want multiple

2:05:00acknowledgments spamming that group.

2:05:02You actually want to bake in some more latency to make it feel more human.

2:05:06And so there are other design decisions when thinking about how to create real email agents

2:05:09for enterprise finance.

2:05:12But multiplayer aside, we realized even after you solicit the input of everyone who matters,

2:05:18you wanted to scale up the number of tasks and run them all in parallel, existing off

2:05:23the shelf solution simply don't cut it.

2:05:25We evaluated a lot.

2:05:26The desktop plug-ins of Excel, PowerPoint, and Word.

2:05:29We evaluated computer use using virtual machines to scale up the number of agents that could

2:05:34work in Excel, PowerPoint, and Word natively.

2:05:37And we also evaluated a ton of off-the-shelf engines, whether those are open source packages

2:05:41like openpyxl or commercial engines that are available for purchase.

2:05:46None of them really cut it for what we were trying to look at.

2:05:48And with coding agents dramatically improving and bringing the cost of software down, we

2:05:54decided to just build our own office from scratch.

2:05:57And like a great AI engineer would, we ran agents in many loops, spent 1.5 trillion input

2:06:03output tokens and over 8 million lines of code to rewrite office from scratch.

2:06:07And I'll walk through a little bit of how we approached it.

2:06:10it's as simple as pointing agents at an objective function, which is recreate office

2:06:15with full fidelity and then letting it run.

2:06:19take Excel as an example.

2:06:21We started with an open source solution called IronCalc.

2:06:24We decided, okay, how can you recreate this perfectly for Excel, use Office as an Oracle,

2:06:30and just run loops, benchmarking it on real files from both real world corpus that we

2:06:35grabbed online and also ones that internally we created.

2:06:38And 800,000 lines of rust later, we had a much more performant compared to Excel, one

2:06:45one for one replica of the product.

2:06:47With this, we're actually able to do that for not only Excel,

2:06:51but also PowerPoint and Word.

2:06:53So we ran loops across every single one of these products,

2:06:56and we have faithful recreations.

2:06:57You can try it for yourself today at get compound.ai.

2:07:00And it's the same method, loop agents

2:07:03against Office as a judge, using rust renders

2:07:06to make sure that the rendering of these products

2:07:09was pixel perfect.

2:07:10So what you see in Compound is what

2:07:13you see when you download to Office.

2:07:14We needed one-for-one parity because at the end of the day, these firms only trust what they can download and what they can send.

2:07:22Now, let's talk about performance.

2:07:25Why is a headless engine so much better compared to using a VM or using desktop Excel?

2:07:30Well, for one, desktop Excel or PowerPoint or Word is bound to that CPU.

2:07:35With headless engines, you can do tasks in parallel much, much faster.

2:07:39You can build out a complex model in a much shorter amount of time.

2:07:42You can recalculate 20 megabyte Excel's 4x faster.

2:07:47So every single piece of work an analyst would expect an agent to do,

2:07:51because, again, their expectation is quality of a human at much lower speed and much lower cost.

2:07:56You have to have a headless engine to do this.

2:07:59If you tried to scale this up with Excel and PowerPoint, I think you'd be going down the wrong path.

2:08:05But it's not just about performance.

2:08:07Owning the editor actually allows you to create a much richer product experience

2:08:11that allows you to work and collaborate with agents asynchronously

2:08:14much better than you can with other products.

2:08:17So this entire slide deck you're seeing today,

2:08:20I built in Compound just by dropping in comments.

2:08:23I had it create a first draft,

2:08:25and as you can see here on the UI,

2:08:27I dropped in comments for every single piece of formatting.

2:08:29For my consulting days, for my co2 days,

2:08:32all the learnings I had on what makes a great slide,

2:08:34I imparted with the agent.

2:08:36This can also work for multiplayer.

2:08:38You can have multiple people part of the same team

2:08:40using the same multiplayer infrastructure we set up, dropping in comments.

2:08:44So for a team of five, you can rip through a 100-page deck in an afternoon

2:08:48rather than sitting in a room revising it for multiple weeks.

2:08:53Finally, with respect to building your own engine,

2:08:56it also allows us to run iterative checking loops much more as well.

2:08:59So if you have a task that, for example, is writing a complex model,

2:09:03it might take a few hours.

2:09:05But how can we make that faster? How can we make it more accurate?

2:09:08If you are using an openpyxl code library, there is no render you can use to check formatting.

2:09:14You are just guessing and hoping that the model writes the right thing and maybe you

2:09:17do some parsing to see a cell as a particular color or has a particular font.

2:09:21If you try to use Microsoft's own interface, you are going to be limited by what Microsoft

2:09:26provides you, which is admittedly very little.

2:09:29With an own engine, you actually own the write, render, check and fix loop.

2:09:34so you can rapidly iterate on the output for the user.

2:09:39So the last thing I sort of want to discuss today

2:09:41beyond multiplayer and building our own office

2:09:44is how to deal with the context that these firms have.

2:09:50For firms on the buy side,

2:09:51they deal with situations where it crosses both breadth and depth of data.

2:09:55You may have situations where you have a data room of over 15,000 files,

2:09:59and

2:10:00then files in that data room might be well over 20 megabytes.

2:10:03People in finance complain all the time, hey, I have an Excel model that's 30 megabytes, it takes five minutes to recalculate because we have two million formulas and five sensitivity tables that need to recalculate every single time.

2:10:14So how do you deal with this?

2:10:16Well, for breadth, I think, again, we take a look at a page out of the coding book and apply agent swarms to the large number of files.

2:10:23files, no longer do you have to index everything in a vector DB unless it's for a very specific

2:10:28use case.

2:10:29It's actually much preferable to use coding agents to read files, either through grep

2:10:33or through some other methodology, and then have a lead agent slice the contents of the

2:10:39file directory and then have swarms of agents come back to you with insights.

2:10:43And then you iterate that in a loop until you're satisfied with the output required.

2:10:48Furthermore, through this process, you're actually able to ground every single finding

2:10:52in citations in the source document so that you know exactly what you show on the screen

2:10:56is linked to some number that the analyst can trust.

2:11:01If we think about the depth of data, take that 30 megabyte workbook, how can you actually

2:11:07process this more accurately?

2:11:09In today's world, if you were to just use ChatGPT or Claude off the shelf to process

2:11:14that 30 megabyte model, it would write code, it would use open source packages like open

2:11:18Excel, it would be expensive and slow because it's printing out every single piece of context

2:11:24about that model in code for the model to read.

2:11:27But because we've developed our own engine for Excel, we're actually not only more accurate

2:11:31but a lot faster and cheaper because the engine processes it and then lays it out in a very

2:11:36easy to read and easy to process format for the model.

2:11:40This means we can expose a much richer set of APIs and a much richer set of tools for

2:11:46the agent to work over.

2:11:46And that allows us to process these models in a much faster manner.

2:11:52So if we sort of take a step back and think about, okay, what is all of this context built

2:11:57for?

2:11:58At the end of the day, what we want to do is prevent people from spending time finding

2:12:02files, from reminding the model this is how to do things.

2:12:06Instead, they should be focused on imparting their judgment on the deal process.

2:12:09They should be focused on tailoring, training agents, and deploying them on every part of

2:12:15the deal flow.

2:12:15And so it goes from the bottom level, connected sources, off-the-shelf connectors to SharePoint or Outlook,

2:12:23to the cited findings grounded in the sources that matter.

2:12:26And then finally, embedding in the preferences, company knowledge that matters.

2:12:30How do you do a model? How should it look? Which differs by every single firm.

2:12:33So that, for humans, they spend most of their time imparting judgment.

2:12:38They spend most of their time thinking about, is this actually a good deal?

2:12:41Not, did all the numbers tie? Does the model look right?

2:12:44will my VP yell at me because it looks a different way.

2:12:49So, oh, Kirscher needs to update.

2:12:55If we take a step back and think about the type of tasks that currently are on autopilot

2:13:02versus what are on copilot, I would say there's already several finance tasks.

2:13:06You can do pretty well with off-the-shelf tools.

2:13:08Spreading comps, as the chat GPT head of finance mentioned earlier, they have now their own

2:13:13products for this, but I think there are a lot of longer running tasks that are not capable

2:13:17with existing solutions.

2:13:18How do you draft a 50-page IC presentation off the cuff?

2:13:22How do you get agents to build out a model exactly the way you want it for a private

2:13:28equity professional or a hedge fund professional?

2:13:31I think those are tasks that with off-the-shelf tools still exist within the co-pilot realm.

2:13:36People want to be embedded deeply in that process without letting go.

2:13:42But with some of the tools we've built today, I think we're able to expand the aperture

2:13:45for which Autopilot can take over in finance firms.

2:13:50So rather than just using tools embedded in Excel as plugins, hand-holding along the way,

2:13:56you can start delegating.

2:13:57You can start becoming more ambitious about what AI is capable of.

2:14:01If I think about where we are today in the world of finance, it very much reminds me

2:14:05of when Opus 4.5 launched last December, where people stopped using code as a simple co-pilot

2:14:13to generate the next file or the next line of code, but they started delegating far more

2:14:18ambitious tasks. They started realizing, maybe I can just truly vibe it. If I have sufficient

2:14:23checks, if I have sufficient tests, maybe I can just trust all the code it writes. I think

2:14:29with some of the tooling we've built today, along with what we're planning in the future,

2:14:34these are the type of problems you have to solve before you get to that point for finance.

2:14:38How can analysts, how can the entire deal team become more ambitious with AI?

2:14:42How can they just drop in a data room and decide, okay, I'm going to trust every single one of the outputs.

2:14:47And then let's do that tenfold so we can see more deals, so we can expand the aperture of what matters.

2:14:53So to conclude, enterprise agents are certainly coming to finance.

2:14:57I strongly believe we're at an inflection point in the adoption curve

2:15:00and that people are slowly becoming more ambitious

2:15:02and they're moving away from co-pilots to autopilots.

2:15:05And so this was sort of how we've approached it here at Compound.

2:15:09If you work at a firm and you're interested in deploying our agents

2:15:12to drive more of your deal work, please reach out.

2:15:15Or if you're an engineer and you're curious about talking about our approach

2:15:18and sharing ideas, please either reach out online

2:15:20or I'll be around if you want to find me.

2:15:22Thanks so much.