AI Agents for Financial Analysis: The Prompt That Stops Made-Up Numbers

Can you actually trust an AI agent with your company's numbers? That's the question every finance team asks before letting a model near a P&L, and the honest answer is: only if the prompt forces the agent to compute rather than narrate. A model asked to "analyze these financials" will produce a confident story. Whether the numbers in that story are real is a separate question entirely - and the default prompt never asks it.

This teardown fixes that. It takes the prompt most people use for AI agents for financial analysis and rebuilds it into one where every ratio traces back to a line item and every total reconciles.

Before: The Weak Prompt

Here's the version that shows up everywhere:

You are a senior financial analyst. Analyze the financial statements below and
provide key insights, trends, and recommendations. Be thorough and specific.

{financial_data}

What this does: it asks the model to narrate an analysis of the statements, with no requirement that any figure it cites was actually computed from the data.

It reads impressively. Margins are "improving," liquidity is "healthy," the recommendation section sounds like a real analyst wrote it. And some of the numbers are subtly wrong - a gross margin off by four points, a current ratio that doesn't match the balance sheet - because the model estimated them from the shape of the data instead of calculating them.

Why AI Agents for Financial Analysis Fail Here

The prompt rewards fluency, and finance is the one domain where fluency without arithmetic is dangerous. "Provide insights" tells the model to sound analytical, and it will - producing plausible ratios that feel right and occasionally aren't. In casual writing, a number that's directionally correct is fine. In a financial analysis, a number that's directionally correct is a landmine, because someone will act on it.

The deeper problem is that nothing forces reconciliation. A human analyst instinctively checks that the segments sum to the total, that this quarter ties to last quarter's ending balance. The naive prompt asks for none of that, so the model happily reports figures that don't add up - and no step in the process ever catches it.

⚠️ Common mistake: assuming a model that's good at math word-problems is good at financial arithmetic on your data. It's not the same task. Getting "if a train leaves Chicago" right doesn't mean it will correctly compute a weighted-average cost of capital across twelve line items without a tool to run the numbers. Language models approximate arithmetic; they don't reliably execute it.

After: The Improved Prompt

The rewrite forces computation, citation, and reconciliation - and hands the actual arithmetic to code the agent writes and runs.

You are a financial analyst agent with a Python tool. Rules:

1. NEVER state a computed figure you did not calculate in code. For every
   ratio or growth number, write and run the calculation.
2. For each figure, cite the exact source line items and their values.
3. RECONCILE: verify segment figures sum to reported totals. Flag any
   variance over 0.5% as a data-quality issue, do not smooth it over.
4. If a needed line item is missing, write "[MISSING: <item>]" - never
   estimate it.

Then write the narrative using ONLY figures produced in steps 1-3.

{financial_data}

What this does: it makes the agent compute every number in code, cite the source line items, reconcile parts against totals, and flag missing data - only then writing the narrative from verified figures.

The ordering is deliberate. Compute and reconcile first, narrate last. By the time the agent writes prose, every number in it already survived a calculation and a reconciliation check. The story is built on audited figures, not the other way around.

Breaking Down Each Element

Rule 1 - compute in code - is the foundation. Pairing the agent with a Python tool and forbidding hand-waved figures turns "the model's guess at gross margin" into "the model ran

gross_profit / revenue

Rule 2 - cite line items - makes every figure auditable. When the agent reports a 22% operating margin, you can see the two exact values it divided. A reviewer verifies the whole analysis by spot-checking citations instead of re-deriving everything.

Rule 3 - reconcile - is the insight most guides never mention. Forcing the agent to check that segments sum to totals catches both bad input data and its own mistakes. A flagged 3% variance between segment revenue and total revenue is exactly the kind of thing that means someone fat-fingered a spreadsheet - and you want it surfaced loudly, not quietly averaged away.

⚡ Pro tip: have the agent output a small reconciliation table before the narrative - each total, the sum of its parts, and the variance. It's the first thing an experienced reviewer checks, and putting it up top signals the analysis was actually verified rather than merely written.

Why the Code Tool Changes Everything

The jump from a model that estimates arithmetic to one that runs it is the single most important thing in this whole teardown, so it's worth sitting with why it works. A language model predicts the next token, and for a calculation like

4,182,000 / 19,340,000

Give the same model a code tool and the arithmetic moves to a real interpreter that is exactly right every time. The model's job shrinks to the thing it's genuinely good at: deciding which calculation to run and interpreting the result. Computation goes to code; reasoning stays with the model. That division of labor is the entire reliability story, and it's why "the model is bad at math" is the wrong frame - the model doesn't have to be good at math if it never does the math itself.

The audit trail this produces is a bonus that turns out to be central. Because every figure came from an executed calculation on cited line items, the whole analysis is reconstructable. A reviewer, an auditor, or a skeptical CFO can trace any number back to the exact operation and inputs that produced it. Compare that to the typical financial narrative, where the figures live in someone's spreadsheet and the reasoning lives in their head - the agent's output is arguably more auditable than the human analysis it assists, precisely because it was forced to show its work.

There's a real cost worth naming: this approach is slower and more expensive per report than a one-shot narrative, because the agent is writing and running code, reconciling, and only then writing prose. For a rough internal gut-check, that overhead may not be worth it. For anything that informs a real decision - a budget, an investment, a filing - the extra minutes buy you numbers you can actually stand behind, which is the only kind of financial analysis worth producing.

⚠️ Common mistake: reviewing only the narrative and skipping the reconciliation table and citations. The narrative is the part designed to be readable; the table and citations are the part designed to be checkable. If you only read the story, you've re-created the exact trust problem the whole architecture was built to solve.

Variations for Different Contexts

A FP&A analyst doing variance analysis adds a rule requiring the agent to attribute every budget-vs-actual gap to specific line items and rank them by dollar impact, so the narrative leads with what actually moved rather than what's easy to describe.

An equity researcher comparing companies forces the agent to normalize for different fiscal-year ends and accounting treatments before any cross-company ratio, because comparing raw figures across mismatched periods produces confident nonsense.

A controller running month-end close uses the reconciliation rule as the primary feature - the agent's main job is flagging where the numbers don't tie, turning AI agents for financial analysis into an extra set of eyes on data integrity rather than a narrative generator.

The compute-cite-reconcile skeleton holds across all three; only the domain rules on top change.

⚡ Pro tip: never let the agent round before it reconciles. Rounding early hides the small variances that signal real data problems. Reconcile on full-precision figures, then round only for the final human-readable narrative.

Save and Reuse This

The compute-cite-reconcile pattern is the durable asset here, and it's worth guarding, because the failure mode of a good financial prompt drifting back toward "just analyze this" is a quiet one - the output still looks fine right up until a wrong number reaches a decision.

⚡ Pro tip: version your financial-analysis prompt alongside a set of test statements with known-correct ratios. Re-run them after any edit; if a known ratio comes back wrong, you caught a regression before it touched a real report.

Store your financial-agent prompts and their reconciliation rules in a shared library like PromptABCD so the audited version is the default across your finance team. When numbers drive decisions, the prompt that computes and reconciles should be the one everyone reaches for - not the fluent one that occasionally invents a margin nobody catches until it's in the board deck. Finance is unforgiving of quiet errors precisely because the numbers get acted on, so the discipline of compute-cite-reconcile isn't bureaucratic overhead - it's the minimum bar for letting a model anywhere near figures that matter. Get that discipline into a shared prompt, guard it, and test it against known-good statements, and you turn a fluent guesser into an analyst you can actually trust with the P&L. And once that trust is earned on the numbers, the agent's narrative becomes genuinely useful rather than merely persuasive, because everything it claims is already backed by an executed, reconciled calculation.