- Home
- Skills
- Finance & Accounting
- Excel Model Audit Recomputes and Finds What the Page Hides
Works with the AI Agents you already use
Excel Model Audit Recomputes and Finds What the Page Hides
Recomputes the workbook, compares each result to the stored value, and prices the defects it finds, including plugs and hidden errors.
Free
Excel Model Audit Recomputes and Finds What the Page Hides
Example session with this skill installed
I inherited this P&L and I am about to send it to a lender. Audit it and tell me whether I can rely on the numbers, what is wrong, and what it is worth.
- Read your context and instructions
- Compiled the excel model audit
Excel Model Audit v2.2.0, read-only audit of Northwind FY26 P&L (demo)
score 92/100 (grade D). Do not rely on this build
high 8 medium 3 low 3
quantified exposure 121,041.08
recomputed 129/133 formulas (97.0%), 2 stale, 1 hidden errors, 1 circular
wrote out/audit.json
wrote out/audit.md
wrote out/audit.html
wrote out/audit.xlsx
The audit wrote four files. audit.md holds the workpaper with the verdict, recomputation table and all 14 findings. audit.html is the same report as a filterable page. audit.xlsx turns the findings into a filterable sheet. audit.json is the structured data.
The verdict is 92/100, grade D. One finding alone, a total that stops one row early, is priced at 5,640. The report also flags a stale cache, a hidden error, a circular pair and an external workbook link.
Connects securely to your tools. The creator never sees your data.
About this skill
A model can tie today and be wrong. The number on the page is whatever was cached the last time something wrote the file, not necessarily what the formula produces.
Excel Model Audit is the review that checks both. It inspects the structure and it re-derives the numbers, using its own calculation engine. Then it prices what it found.
What it does that a checklist cannot
Recomputes the workbook
Every formula the engine can evaluate is re-derived from first principles and compared against the value stored in the file. Where they disagree, you get both numbers and the difference. This is the check that finds the figure someone has already circulated after the formula stopped supporting it.
Finds hidden errors
A cell showing 1,370 while its formula resolves to #REF!. Nothing on screen warns you, and the moment
anyone recalculates, the number becomes an error.
Catches circular references by evaluation
The engine records the cell stack as it walks, so a loop is reported at the point where it closes rather than hanging the run.
Runs your reconciliations
Define tie-outs in policy.json in plain Excel syntax, such as total revenue equals the sum of its lines,
assets equal liabilities plus equity, or retained earnings rolling forward. The audit evaluates them
against the file every run.
"tie_outs": [{
"name": "Total revenue equals the sum of every product line",
"expression": "'P&L'!B9-SUM('P&L'!B5:B8)",
"tolerance": 0.5
}]
Evaluates modern formulas
Excel moved to LET and LAMBDA, and a tool that cannot read them quietly stops checking the most
recently written part of a workbook. This one evaluates both. That covers LET bindings, a LET inside
a LET where the inner name shadows the outer, ranges as bindings, a LAMBDA called immediately as
=LAMBDA(x,y,x+y)(2,3), and a LAMBDA held in a defined name so =ADDONE(4) resolves. Recursion is
capped, so a self-calling LAMBDA returns #NUM! in milliseconds instead of hanging the run. On a
fixture built entirely from these constructs, recomputation went from 0 of 13 formulas (0%) to 11 of
13 (84.6%). The two left out are genuine dynamic-array cases, and the report names them.
Prices the damage
Findings that can be measured carry an impact in the workbook's own units. That means the size of a stale difference, the sum of the cells a total leaves out, or the size of a failed reconciliation. The report totals them into a quantified exposure.
Tracks change between versions
--save-baseline fingerprints a model. --baseline diffs the next version against it and separates
changed calculations from changed inputs, because the two carry completely different risk.
The other thirteen checks
Structural defects, each with cell-level evidence.
| Check | Example |
|---|---|
| Typed number in a calculated row | A plugged 12,500 in an opex row that is otherwise formula-driven |
| Total short of its block | SUM(B5:B7) while row 8 holds Product D and belongs in the total |
| Formula pattern break | One cell in a twelve-period row that adds instead of multiplying |
| External workbook links | A figure that silently depends on last year's file |
| Broken defined names | A named range pointing at a deleted block |
| Percent and decimal mixing | 0.25 displayed where the row shows 25% |
| Hidden content | A hidden sheet or hidden rows carrying live figures |
| Volatile functions | NOW(), OFFSET(), INDIRECT() in reported cells |
| Merged data ranges, over-long formulas, deep nested IFs | Review friction that hides logic |
What you get back
Four artefacts from one command.
| File | For |
|---|---|
audit.md | The workpaper. Verdict, recomputation table, findings, limits, sign-off |
audit.html | The same report, self-contained and filterable. Send this to a reviewer |
audit.xlsx | Findings as a filterable Excel sheet, colour-coded by severity. Drop it into a tracker |
audit.json | Structured findings for a pipeline |
Plus changes.md when you diff against a baseline.
A real run
score 92/100 (grade D). Do not rely on this build
high 8 medium 3 low 3
quantified exposure 121,041.08
recomputed 129/133 formulas (97.0%), 2 stale, 1 hidden errors, 1 circular
Three independent checks converge on the same defect in that model. The structural pass finds a total stopping one row early, the tie-out fails by exactly the missing line's value, and the impact prices it at 5,640.
Why it is safe to run on a client file
- Read-only. The workbook is never written to, recalculated in place, or repaired. The self-check asserts the file is byte-identical after an audit.
- No third-party packages. Standard library Python only, including the calculation engine and the Excel writer. Nothing to install, nothing to audit.
- No network, no environment variables and no subprocesses. Runs on an air-gapped machine.
- VBA is never executed.
.xlsmfiles are read as archives. - The engine reports its own coverage. Anything outside its library is named, never guessed. A clean recomputation is therefore never mistaken for a complete one.
Who it is for
FP&A analysts reviewing someone else's model. Accountants doing a pre-close check. Founders whose forecast is about to meet a lender. Consultants in diligence who inherited a workbook with no documentation. Anyone who has sent out a model and found the plug three weeks later.
Works in a minute
python3 audit.py "/abs/path/model.xlsx" --out ./model-audit --html --xlsx
Requires Python 3.9+ with code execution in the agent. One file, standard library only. The OOXML reader,
the calculation engine, both report writers and the self-check all live inside audit.py, because Agensi
runs each script from a temporary file. Nothing to install.
Flags include --policy for tie-outs and severity overrides, --min-severity high, --no-recalc for a
structural-only pass, --save-baseline and --baseline for change control, and --self-check to verify
the engine on synthetic workbooks before trusting it on a real one.
Honest about scope
This is a structural and numerical review, not an audit opinion. It does not judge revenue recognition,
tax treatment or whether an assumption is reasonable, and it does not open legacy .xls files. The engine
implements the ~70 functions that carry real financial models, and it evaluates LET and LAMBDA,
including a LAMBDA held in a defined name and a LAMBDA that calls itself, which is capped so a runaway one
returns #NUM! instead of hanging. Dynamic arrays, Power Query and VBA sit outside it. A model that
depends on them reports lower coverage, and the report names which formulas it could not verify rather
than pretending.
Pairs with excel-formula-trace (free) for following any finding back to its inputs.
Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Finance & Accounting.
Read-only. It does not judge accounting policy, revenue recognition or whether an assumption is reasonable. It does not open legacy .xls files, dynamic arrays, Power Query or VBA. The engine covers about 70 financial functions plus LET and LAMBDA.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before buying a skill.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
1 use
Times used to date
Free to use
No account required to browse
Trust & safety
Security scan
Security scan passed 7 days ago
- Free with an Agensi account
- Software
Python 3.9 or newer
The workbook is read-only. Pass the full path and an output folder, for example ./model-audit.
Permissions
File Scopes
Reads one workbook and writes four report files to the output folder. It never modifies the workbook, runs VBA or makes network calls.