For the past few years, most finance teams have used generative AI the way you’d use a sharp intern who has no company knowledge, system access, or even an employee badge.
We dumped in financial statements and had it draft commentary, let it summarize technical accounting memos for us, and handed it excel workouts to find out what went wrong in cell H47 … which, as every finance professional knows, is where an otherwise pleasant afternoon goes to die.
An agent works differently. Instead of handing the model a single task and waiting for an answer, you hand it an objective and let it work through a series of steps to get there.
My favorite example of a finance function that AI is surprisingly good at is the monthly variance analysis. I’ve used this as a great starter example of using AI inf finance going all the way to the ChatGPT 3.5 days. We can ask AI to review actuals against budget, identify material variances, pulls, transaction detail, compare against prior periods, hunt for operating drivers, and now even email business partners for more detail, draft commentary, check the numbers, and send it up.
In the past that was a whole series of individual prompts. We had to use Chain of Thought (CoT) and other methods to essentially babysit the chatbot through the whole process. Now though, we can knock out a huge swath of every one of those tasks in a single prompt. (Though I’d probably stop short of letting it fire off the AI slop cannon in those two emails. Draft, sure … but let me take a look before you ping Hank in treasury.)
That distinction is growing increasingly stark. KPMG reported in May that 93% of US companies expect to be deploying or scaling AI in their finance functions within 18 months, with half of them planning to orchestrate multi-agent systems across workflows.
Which means it’s worth understanding what these things are before every SaaS company on earth adds the word “agent” to its homepage (or has this already happened?).
What an AI agent is
As a somewhat pedantic defender of what an agent actually is, I’ve finally had to concede that there’s no single agreed definition.
Here’s mine:
An AI agent is a system that pursues an objective, decides what to do next, uses tools, evaluates results, and keeps iterating until it hits a stopping condition or needs a human.
The core loop runs like this:
This is distinctly different than the behavior everyone recognizes from chat tools, which default to request and response.
An agent adds a loop on top of that. It acts, looks at what came back, then decides what to do next without human intervention.
Here’s what I mean:
Prompt 1: Chatbot
“Explain why operating expenses were over budget.”The model answers.Prompt 2: Agent
“Investigate operating expense variances and prepare management commentary.”An agent retrieves data, identifies anomalies, pulls supporting detail, compares periods, runs calculations, and refines its analysis step by step.
The mechanism here is persistence with feedback. The model doesn’t get smarter between steps three and four. It gets another look at what happened and another chance to correct course. This is the “loop.” The loop introduces autonomy, which is useful under constraint … and more than a little dangerous without it.
Finance has spent a century building controls, and the reasons for doing that haven’t changed.
Why agents got better
Agents aren’t new. What changed is the stack around them.
They hold together over longer chains of work
Modern models are better at breaking a task into steps, catching their own mistakes, and staying coherent across a long sequence. METR tracks how the length of task a frontier model can carry has moved over time, and that timeline continues to incrementally increase … to the point where users frequently have to throttle back the agent to prevent it from overstepping the ask.
And this is important in our profession because finance work is rarely one step. It’s a chain of dependent decisions, each of which assumes the previous one didn’t go sideways.
Agents can use tools
Without tools the models can respond and for the last couple of years they can even reason. But tools give them the ability to act.
Which means they can do things like query systems, run calculations, retrieve documents, execute workflows, and interact with enterprise software. Agents open a whole new realm of possibility. A model that understands the P&L at this point pretty much seems like a parlor trick. But a model that can operate inside the systems producing the P&L becomes a workflow participant … with everything that implies about access and review.
The surrounding infrastructure matured
This part is the least visible, but arguably the most important. Modern agent systems include orchestration layers, memory, tool routing, permissions, logging, and recovery mechanisms.
So the model isn’t operating alone anymore. It’s sitting inside a controlled environment designed to make it useful in production. And that layer is what moves an agent from a tool that runs on a path you guide to one that runs autonomously in the background until it produces a result.
The harness is now more important than the model
An agent harness is the infrastructure around an AI agent that manages its tools, context, memory, permissions, execution flow, and interactions with external systems.
A useful analogy is hiring a new analyst. You aren’t hiring intelligence in a jar.
You define:
what they’re responsible for
which systems they can access
which decisions they make on their own
what has to be escalated
how their work gets reviewed
how their output is recorded
An agent needs the same structure, and in agent architecture that structure has a name. It’s called the harness.
A typical harness includes:
Objective definition. What the agent is trying to achieve.
Context injection. Which data it can see.
Tool access. Which tools it can reach, at which permission level.
Memory and state. What it has already done.
Permissions. What it’s allowed to do.
Stopping rules. When it should stop.
Validation logic. How outputs get checked.
Human approval gates. Where oversight is mandatory.
Audit logging. What it did and why.
Read that list again, and you’ll notice you already own most of it. Segregation of duties, access controls, materiality thresholds, review evidence, and retention. The harness spec and the control matrix are exactly the same.
The model supplies the reasoning, but everything about control lives in the harness. And this is where finance teams should spend their design time.
Let the systems compute and the model interpret
The design rule that keeps agents out of trouble is to keep arithmetic in the systems built for arithmetic and point the model at the part that requires judgment.
In variance analysis, that splits cleanly:
SQL or the ERP calculates actuals, budget, and variance
rules define materiality thresholds
the agent identifies which variances matter
the agent investigates causes
the agent drafts commentary
a validation layer checks every numeric claim against source
No one wants a language model to improvise revenue figures. What we do want is for it to explain why revenue moved. Computing a variance is arithmetic. Explaining one is analysis, and the two require different tools.
What a finance agent looks like in practice
A production-grade variance agent runs something like this:
Results close and publish.
The agent retrieves actuals and budget.
A calculation engine computes variances.
The agent identifies material deviations.
It pulls supporting ledger detail and context.
It investigates probable drivers.
It drafts commentary for each key variance.
A validation layer checks the numbers.
A human reviewer approves or edits.
The final report goes out.
At no point is the agent “free-running.” It’s operating inside a structured process with gates. And that structure is what makes it usable in finance.
Production is where the interesting problems live
At this point, we’ve all seen AI do some amazing work in finance. From analyzing a trial balance to building out DCF models and waterfall charts from scratch. (Just don’t ask AI to build a pivot table in Excel!)
The real question now though is if it can perform all these tasks repeatedly, reliably, with an audit trail, under existing controls, and inside enterprise systems
Early production deployments cluster in reconciliation and close reporting, which makes sense. Those workflows have the clearest rules, the most repetitive exception handling, and the least tolerance for creative interpretation, so they’re the easiest place to prove a harness works before pointing one at something ambiguous.
Efficiency is obviously the main benefit and driver here. And where finance needs to focus now is around how more and more of our workflows becoming partially executable by software that makes intermediate decisions along the way. This actually changes the whole workflow design process.
Five questions to ask before you scope one
What’s the objective of the process?
What data is required to complete it?
What tools or systems must be accessed?
What should be deterministic and what should be AI-driven?
Where does human approval stay mandatory?
These map to how agent systems are built. They also map to how finance controls are governed. That overlap is the reason your controllers are actually better positioned to design these systems than anyone else in the building.
The shift
The first wave of AI in finance was assistance. The second is execution.
That doesn’t mean finance teams are bring replaced. It means the work is being reallocated: systems compute, agents investigate, validation layers check, and humans decide. But only when the system is designed for it.
Once software can take actions, “did it answer correctly” stops being the interesting question, and “can we explain everything it did” takes its place. Finance will always care less about intelligence than about evidence. That’s probably the correct instinct.
Autonomous or not, somebody eventually asks for the receipts.
The Pro edition this week looks under the hood of an agent harness.
Subscribers get every layer between the model and the approved commentary, how decisions move through them, and what permissions, validation, escalation, and logging have to look like before finance signs off.
It comes with the Governed Finance Agent Reference Architecture, two pages: the full schematic, and a nine-section review checklist you can work through in a design review rather than reconstruct from memory afterward.
Unlock the full architecture and review checklist:



