What a one-cell agent edit removed from 4 of 8 Excel workbooks

I measured what that recipe does to real workbooks. On 4 of 8 workbooks, a one-cell edit removed slicers, a timeline, sparklines, an extension data validation, or a whole Power Pivot data model with the pivot tables built on it. On a fifth, it changed the settings of a data bar. The recalculation step reported success with zero errors every time, and Excel opened every damaged file without a repair prompt. The only signal was a Python UserWarning when openpyxl loaded the file.

I build WolfXL, an openpyxl-compatible Excel library for Python with a Rust core. With WolfXL modify mode doing the same edit, the edit step removed nothing from any of the 8 workbooks. With WolfXL Commercial 2.3.0 also doing the recalculation, every part of all 8 workbooks was kept.

The test

One edit:

1. Open the workbook.
2. On the first sheet, set Z1 to =1+1.
3. Save.
4. Recalculate so the file stores the new cached value.
5. Compare every package part, every sheet feature, and every formula's stored value against the original.

An .xlsx file is a ZIP package of XML parts: worksheets, styles, pivot caches, slicers, drawings, data models, and the relationships between them. A one-cell edit should change the cell, its cached value, and little else.

I ran three workflows over the same 8 workbooks: seven files saved by Microsoft Excel and one small synthetic file with an extension data validation and a sparkline group.¹

• The usual path: the xlsx skill's recipe. A test harness ran openpyxl 3.1.5 edit code written to the skill's instructions, then the skill's LibreOffice recalculation script, unmodified. No agent was in the loop, so the result does not depend on how a model phrases the edit.
• WolfXL edit, LibreOffice recalculation: WolfXL modify mode for the edit, then the same LibreOffice recalculation.
• WolfXL end to end: WolfXL modify mode for the edit, then the native calculate() in WolfXL Commercial 2.3.0.

All three produced the correct cached value, 2, in every file. The difference is everything else.

What the usual path removed

Three details make this worse than it looks.

The recalculation said everything was fine. The skill's recalculation script reported success with zero errors on all 8 files, including the one that lost 234 parts.

Excel said everything was fine. All 8 outputs of the usual path opened in Excel 16.113 for Mac without a repair prompt.³

The only warning was a Python warning. openpyxl emits a UserWarning when it drops an extension it does not model, such as "Slicer List extension is not supported and will be removed." For the timeline workbook the warning read "Unknown extension is not supported and will be removed," which does not say what was lost. The saved file and the recalculation result carry no sign of the loss.

Two separate places where the file loses parts

The middle workflow separates the two steps.

With WolfXL doing the edit, the edit step removed nothing on any of the 8 files. Then LibreOffice recalculated, and the file lost parts anyway: the slicer and its caches from the pivot chart workbook, the timeline and its cache from the timeline workbook, and 75 parts from the Power Pivot workbook, including the data model, the pivot tables, and the pivot caches. It also rewrote the data bar settings in the pivot and conditional format workbook.

So there are two failure points:

1. The save. openpyxl rebuilds the file from its own object model. Anything it does not model, it drops.
2. The recalculation. LibreOffice loads the whole workbook into its own model and writes a new file. Anything it does not model, it drops, even when the file it received was intact.

A preserving editor alone does not fix the second one. To get fresh stored values without a second tool rewriting the file, the edit and the recalculation should happen in the same engine. If stored values can wait until someone opens the file in Excel, the other option is to skip the recalculation and mark the workbook so Excel recalculates it on open.

An earlier result points the same way

This is the second time I have measured this. In early September I diffed a save with no edit at all, through the LibreOffice build bundled in a desktop coding agent runtime, across five workbooks. It rewrote between 8 and 151 unrelated package parts per workbook. WolfXL changed zero.⁴ That study is written up in When an AI agent edits a spreadsheet, what happens to the workbook?, with SHA-256-pinned receipts.

A rewritten part is package drift and may be harmless. A removed slicer is lost work. The new study measures the second kind.

What WolfXL does differently

WolfXL modify mode patches the cells you change and copies every other package part through unchanged. The API is openpyxl's, so the edit code barely changes:

import wolfxl

wb = wolfxl.load_workbook("report.xlsx", modify=True)  # keep_vba=True for .xlsm
wb["Inputs"]["B4"] = 42
wb.save("report-edited.xlsx")

WolfXL Commercial adds native formula calculation that writes fresh cached values into the saved file, so the recalculation step never leaves the library. That is the end-to-end path in the table above, measured on WolfXL Commercial 2.3.0.

WolfXL Community is MIT-licensed and on PyPI. It includes modify mode. When this post was published, its formula evaluator computed values in memory without writing cached values back into the file, so its skill recalc step marked the file for Excel to recalculate on open. Update: Community 2.0.10, released October 20, 2026, and later also save cached results for supported formulas.⁵

A skill your agent can use today

I published an agent skill, wolfxl-xlsx, in the public WolfXL repository: github.com/SynthGL/wolfxl-oss/tree/main/skills/wolfxl-xlsx. It is a SKILL.md plus one helper script, MIT-licensed, and it gives an agent four steps:

• inspect lists what an openpyxl save and a LibreOffice recalculation would each remove from this particular file.
• The edit happens on a copy, in WolfXL modify mode.
• recalc recalculates with WolfXL, lists formulas that evaluate to an error, and reports whether fresh values were written into the file.
• verify compares the original and the edited copy and exits 1 if any part or sheet feature went missing.

verify needs only the Python standard library, so it also checks files written by other tools. It checks the package, not cell values: review the recalc error list as well.

Check your own workbooks

The study harness is public at github.com/SynthGL/wolfxl-oss/tree/main/study/agent-edit. It fetches the pinned recalculation script and the Microsoft Power Pivot sample, and reruns the usual path and the middle path with WolfXL Community; the end-to-end path needs a Commercial wheel. To check your own files instead:

python -m pip install wolfxl
git clone https://github.com/SynthGL/wolfxl-oss
cp your-workbook.xlsx edited.xlsx
# make a one-cell edit to edited.xlsx with your usual agent workflow,
# including its recalculation step, then:
python wolfxl-oss/skills/wolfxl-xlsx/scripts/wolfxl_xlsx.py verify your-workbook.xlsx edited.xlsx

Exit 0 with "status": "preserved" means every part and sheet feature in the original is still there. Exit 1 lists parts_missing, families_lost, and sheet_features_lost. Files with slicers, timelines, pivot tables, sparklines, or a Power Pivot model are the ones to try.

Using WolfXL Commercial from agents and CI

Commercial installs from a private package index with a license credential. AI agents, CI jobs, and other automated systems you run for your organization don't need their own seats. They run under the seats of the people who set them up and operate them.⁶

• Try it: a free 60-day Commercial evaluation for nonproduction work at wolfxl.com/evaluate.
• Install it in CI, containers, or an agent sandbox: copy-paste recipes for pip, uv, and Docker at wolfxl.com/agents#install.
• Buy it: One Seat is $299 a year or $30 a month for one person, Five Seats is $999 a year or $99 a month for up to five people, and Organization is $1,999 a year or $199 a month for unlimited users in one legal organization. wolfxl.com/pricing.

Hosted chat sandboxes that install only from public PyPI cannot reach the private index. There, the Community package and the skill's inspect and verify steps still let an agent see which parts are at risk and check the saved file before handing it back.

Limits

This is a small study. It shows that the failure exists on real Excel files and that neither the recalculation result nor Excel reports it. It does not say how often agents hit it. The method and limits are in the footnotes, the harness is public at github.com/SynthGL/wolfxl-oss/tree/main/study/agent-edit, and I would like the hardest sanitized workbook you can share.