How Claude Cowork Makes Excel Files

Claude Cowork is one of the most capable AI agents available today. It can read your local files, process PDFs, draft memos, and produce deliverables directly on your desktop. For many tasks, the output is genuinely impressive. But there is one category of work where the results are consistently hit-or-miss: complex Excel files.

If you have asked Claude Cowork to build a financial model, populate a firm template, or edit a workbook with pivot tables and macros, you may have noticed the gaps -- a formula that does not calculate, formatting that shifted, a macro button that disappeared. The issue is not Claude's reasoning. Claude understands what a properly built spreadsheet should look like. The issue is in how the file actually gets made.

Under the Hood: Openpyxl and LibreOffice

Claude Cowork runs inside a sandboxed Linux virtual machine on your Mac. There is no Microsoft Office installed. So when you ask it to create or edit a spreadsheet, it relies on two open-source tools: a Python library called openpyxl and a local installation of LibreOffice.

Openpyxl handles the core file manipulation -- creating workbooks, writing data to cells, applying formatting, and inserting formulas. LibreOffice acts as a backend for additional tasks like file conversions, rendering, and some operations that openpyxl cannot handle on its own. Together, they give Claude a reasonable toolkit for producing .xlsx files without needing Excel itself.

For straightforward outputs -- a clean data table, a formatted summary, a basic model with standard formulas -- this combination works well. The problem is that "works well for basic files" and "works well for the files your team actually produces" are often two very different things.

Where the Tooling Falls Short

Neither openpyxl nor LibreOffice is Excel. They can approximate many of Excel's features, but the further you move from simple tables and standard formulas, the more the approximation breaks down.

Formulas Without Verification

Openpyxl writes formulas as plain text strings. When Claude places =VLOOKUP(A2,Sheet2!A:D,4,FALSE) in a cell, the library stores the characters but does not evaluate them. The formula only calculates when a human opens the file in Excel. This means Claude cannot verify whether its own formulas produce the correct result. A cell reference off by one row, a range that does not quite cover the right data -- these errors are invisible until someone checks the output manually.

LibreOffice can help with some formula evaluation, but its calculation engine does not perfectly mirror Excel's. Differences in how the two applications handle edge cases -- rounding, error propagation, certain financial functions -- mean that a formula that evaluates correctly in LibreOffice may behave slightly differently in Excel.

Modern Excel Functions

Dynamic array functions like XLOOKUP, FILTER, SORT, and UNIQUE are now standard in most institutional workflows. Openpyxl's support for these is incomplete. It may wrap them in legacy array syntax, add implicit intersection operators, or corrupt them on save. LibreOffice has its own compatibility gaps with Excel's newer function set. If your firm's templates rely on modern Excel features, the file that comes back may not behave as expected.

Macros and VBA

Neither openpyxl nor LibreOffice can execute VBA macros. Openpyxl can attempt to preserve the VBA binary when editing a .xlsm file, but form controls, buttons, and ActiveX objects are frequently stripped or broken in the process. LibreOffice uses its own macro language (StarBasic) and does not natively run Excel VBA. For firms that rely on macro-enabled workbooks -- and many do for formatting routines, data refreshes, or custom calculations -- this is a hard limitation.

Pivot Tables and Advanced Features

Openpyxl cannot create native Excel pivot tables from scratch. It can preserve existing ones, but building a new interactive pivot -- the kind you would use to quickly slice a rent roll by expiration year or summarize expenses by category -- is not possible. Similarly, features like Power Query, Power Pivot, Data Tables (What-If Analysis), and complex conditional formatting rules are either unsupported or only partially preserved. LibreOffice has its own versions of some of these features, but the translation back to .xlsx format is not always clean.

Template Integrity

Many firms work from standardized Excel templates with carefully built formatting, named ranges, data validation, and tab structures. When these files pass through openpyxl or LibreOffice, the elements that the tools do not fully understand can get damaged. Conditional formatting ranges may not adjust to new data. Dropdown lists referencing other sheets may stop working. The template your team spent hours perfecting comes back with subtle but meaningful breakage.

Good Enough vs. Good

None of this makes Claude Cowork a bad tool. For producing first drafts, extracting data, and building simple spreadsheets from scratch, the openpyxl-plus-LibreOffice combination is a genuine productivity gain. The issue is that "good enough for a first draft" is not the same as "ready to send to the IC" or "ready to hand to a lender."

The gap is in the last mile. Claude understands what a sensitivity table should look like, how a DCF should be structured, and what formulas belong in a debt sizing model. But translating that understanding into a .xlsx file that behaves exactly the way Excel expects -- with every formula calculating, every macro firing, every pivot refreshing -- is a harder problem than it appears. Openpyxl and LibreOffice get Claude most of the way there. The last 10-20% is where things break.

For deal teams whose deliverables are complex Excel files, that last 10-20% is the part that matters most.

Where Purpose-Built Tooling Comes In

This is the kind of problem that general-purpose AI agents are not built to prioritize. Anthropic's job is to make Claude the best general reasoning engine available -- and it is. The specific challenge of producing institutional-quality spreadsheets requires tooling that treats Excel fidelity as a first-class problem, not a side effect of a Python library.

Purpose-built AI coworkers -- like those from Lumetric -- are designed around this exact gap. Instead of approximating Excel's behavior through open-source workarounds, they are built to produce spreadsheets that work the way your team expects: functional formulas, intact templates, and formatting that survives the round trip. Not a general agent that gets you 80% of the way there, but a coworker built for the deliverable from day one.