Agentic AI in Finance Needs a Reliable Numbers Layer First

An autonomous agent doesn’t pause to second-guess itself. That’s the whole point. You give it a goal, a set of tools, and the authority to act, and it works the problem until it’s done. Now picture that agent reading “Q3 revenue: 4.1M” off a dashboard that was actually showing a quarter-to-date figure, deciding the company is ahead of plan, and triggering a reforecast that the board sees on Friday. No human typed that number. No human checked it. The agent just acted on what it was given.

That is the real risk in agentic finance, and it has almost nothing to do with how smart the model is.

The pitch for agents is genuinely good. Instead of an AI that answers questions, you get an AI that does work: pulls the data, runs the calculation, drafts the variance commentary, updates the forecast, flags the anomaly, books the journal entry. Gartner expects embedded AI in cloud ERP to drive a roughly 30% faster financial close by 2028, and a large share of finance teams are already piloting or planning agentic workflows. The direction of travel is not in question. The question is what these agents are standing on.

Autonomy multiplies whatever is underneath it

Here’s the uncomfortable math. A chatbot that hallucinates a number wastes one analyst’s afternoon. An agent that hallucinates a number, then takes three downstream actions based on it, then hands those outputs to a second agent, has just propagated a wrong figure through a chain nobody watched in real time. Autonomy is a multiplier. It multiplies good decisions and it multiplies bad inputs with exactly the same enthusiasm.

The governance data should give any CFO pause. By one 2025 estimate, only about 2% of companies had adequate AI guardrails in place, and the overwhelming majority of organizations had already experienced at least one AI incident. Maturity is rare. Roughly one in five companies has a mature AI governance framework. Meanwhile the agents keep shipping. The capability is racing ahead of the controls, which is a familiar and dangerous pattern.

So the instinct to slow down is correct. But “slow down” is not a strategy, and it won’t survive contact with a board that has read the same headlines about autonomous finance. The better answer is to be precise about what has to be solid before you let an agent act, and to build that first.

Three things break, and only one is the model

When a finance agent produces a wrong outcome, the failure almost always traces to one of three places.

The model reasons badly. This is the failure everyone fixes first and it’s the least common cause. Frontier models reason about financial concepts reasonably well now.

The model does the arithmetic itself. Language models tokenize numbers and pattern-match them rather than calculating, which is why they confidently return wrong sums and ratios. We unpack the mechanism in why your AI gets the numbers wrong. The fix is well understood: don’t let the model do the math. Hand calculation to a deterministic engine.

The data underneath was wrong, stale, ambiguous, or unreconciled. This is the big one, and it’s the one nobody likes to talk about because it isn’t a model problem you can buy your way out of with a bigger context window. If the agent reads a figure that doesn’t tie to the ledger, every action it takes after that is built on sand. No amount of model intelligence repairs a wrong input.

Notice that two of the three failures live below the model entirely. You can put the most capable agent in the world on top of unreconciled data and a stochastic calculator, and it will still produce confident, traceless, wrong numbers. Faster than before.

The reliable numbers layer, defined

This is the part the agent hype skips. Before autonomy, you need a layer that does three boring, load-bearing jobs.

• One reconciled model. Pull from QuickBooks, Xero, NetSuite, Sage, a warehouse, or uploaded statements, and resolve them into a single financial model that ties out to the ledger. Not a copy of the data. A reconciled source of truth where 4.1M means one specific, defined, agreed thing.
• Deterministic calculation. When an agent needs a margin, a runway, a covenant ratio, the number comes from an engine that computes it the same way every time, not from a model improvising. Same inputs, same answer, always. That’s what makes a result reproducible instead of a one-time roll of the dice.
• Traceability to source. Every figure the agent touches can be followed back to the document and the calculation path that produced it. A controller can click a number and see where it came from.

Put those three together and you’ve changed what the agent is acting on. It’s no longer reasoning over a dashboard screenshot. It’s retrieving verified figures, calculating against a deterministic engine, and producing outputs that trace back to source. The autonomy is the same. The foundation is not.

We think of this as the order of operations being non-negotiable: trust the numbers, then automate the actions. Reverse it and you’ve automated your way into faster mistakes. This is the same logic behind single source of truth: why reconciled data is the real unlock for AI in finance, which is the precondition rather than a nice-to-have.

”Just give the agent a code interpreter”

A common objection at this point: agents can already call tools, so let the agent run Python and the arithmetic problem disappears. It’s half right, which is the dangerous kind of right.

A code interpreter fixes the arithmetic. The agent stops fumbling long multiplication. Good. But it does nothing about wrong inputs, unreconciled sources, missing provenance, or locale ambiguity, and there’s plenty of the last one in finance. Is 12,345 twelve thousand or twelve point three four five? Depends where the statement came from. A code interpreter happily computes against a bad number. The result is now precise and wrong, which is worse than obviously wrong, because precision reads as trustworthy. We get into the specifics in why “just use a code interpreter” doesn’t make AI finance-safe. Tool use is necessary. It is nowhere near sufficient.

What good agentic finance actually looks like

The teams getting real value from agents in finance are not the ones with the most autonomy. They’re the ones who scoped it carefully.

Human-in-the-loop is treated as a design decision, not a training-wheels phase you outgrow. For high-impact actions, an agent that proposes and a human who approves consistently beats full autonomy on both risk and accountability. The serious deployments enforce least-privilege permissions, log every action, require human approval on consequential steps, and keep a kill switch. You can read the research roundup on agentic AI in financial services for how this is shaking out in practice.

Auto-reforecasting is a good example of the pattern done well: the agent watches for a material variance, proposes an updated forecast, shows its work, and a human signs off. That’s powerful and defensible, but only because the variance it detected was computed against a reconciled baseline rather than a number it half-remembered. We walk through this in agentic FP&A is coming, but agents need a reconciled foundation.

A useful way to read all of this is alongside the broader case for a reliable financial-modeling layer for AI. Agents are simply the most demanding consumer of that layer. They expose every weakness in your data faster and more publicly than a human analyst ever would.

The honest limits

A reliable numbers layer does not make agents infallible. It doesn’t fix a badly specified goal, a model that reasons poorly about a genuinely novel situation, or a process where nobody reviews the high-stakes calls. Reconciliation itself is hard, and getting financial sources to agree to the cent across systems is real engineering, not a checkbox. We’re not selling magic. We’re selling a precondition.

What the layer does is remove the failure modes that are unforgivable in finance: acting on a number that was never real, computing it in a way you can’t reproduce, and reporting it with no trail back to source. Strip those out and what’s left is a set of risks a competent finance team already knows how to manage with permissions, approvals, and review.

Agents will run a lot of finance work this decade. The teams that win won’t be the ones who deployed first. They’ll be the ones whose agents were standing on numbers that were actually true.

If you’re piloting agents and want to see what they look like running on a reconciled model instead of a dashboard guess, book a demo and we’ll walk through it with your data.