Building agents, not dashboards: how we think about AI at Peaky.
There are two ways to add AI to a finance product.
The first is to bolt a chatbot onto a dashboard. The user asks a question. The system retrieves the answer. The interface looks more conversational. The underlying work the system does is unchanged.
The second is to build the system around agents that do work in the background. The user does not have to ask. The system already moved.
We chose the second approach at Peaky. This post explains why.
The bolt-on pattern
Most “AI for finance” products today are version one. The product was originally a dashboard or a forecasting tool. The team added a chatbot. Now the marketing copy says “AI-powered”.
This pattern has a few characteristics.
The AI is reactive. It responds to user prompts. If the user does not ask, the AI does not move.
The AI does not have agency. It can retrieve information, summarise content, or generate a chart. It cannot take action on its own. It cannot decide that something is worth surfacing without being asked.
The underlying product architecture is unchanged. The dashboard is still the primary interface. The AI is a layer of conversational convenience on top.
This is genuinely useful for some workflows. It is also limited. The user still has to know what to ask. The system still produces deliverables on a cadence the user controls. The work happens in batches.
The agent pattern
The alternative is to design the system around agents that do work continuously without being asked.
An agent has three properties.
It has a specific job. Not a general intelligence. A bounded responsibility.
It runs continuously, in the background, without requiring user input.
It surfaces output when something is worth surfacing. Not on a schedule. When the work it is doing produces a result that the user should see.
In Peaky, each agent has a specific job. One maps ledgers. One maintains the forecast. One generates statements. One watches for drift. One handles collaborative budgeting. Each one runs whenever the underlying data updates. Each one surfaces output when its job produces something the team should see.
The user does not ask any of them to start. They are always running. The user only sees them when there is something worth seeing.
This is a fundamentally different shape of product. Not a dashboard with a chatbot. A team of specialised colleagues that handle the routine work in the background.
Why this matters for finance
Finance is unusually well suited to the agent pattern.
The work is well-defined. Most finance tasks have clear inputs, clear outputs, and clear validation rules. This is exactly what bounded agents are good at.
The work is repetitive. Reconciling ledgers, refreshing forecasts, generating statements, comparing variances. These tasks happen on schedule, repeat across cycles, and follow consistent patterns. They are the kind of work that can be automated reliably.
The work has high time-cost. Each task takes hours or days when done by a finance team. The compounding cost of doing it manually month after month is what produces the four-day rebuilds and the lost Sundays.
The work benefits from continuous execution. Catching drift early, keeping the model current, generating statements on demand. These are valuable specifically because they happen continuously rather than in batch.
Other product categories have weaker fits. Customer-facing chat support is partially well-suited to the agent pattern but requires more judgement than the current generation of models can reliably handle. Content generation can be agent-driven but lacks the structured validation that finance tasks have. Finance, in contrast, has structure, repetition, and well-defined success criteria.
The architecture choices
A few specific architecture choices follow from the agent pattern.
Specialised agents over a single monolithic model. Each agent is built around a specific job. We could have built one large model that does everything. We did not, because routing tasks to the right specialist produces better accuracy and lower cost.
Lightweight models for lightweight tasks. Not every task needs heavy reasoning. Mapping a ledger account against a known structure can be done by a smaller, faster model. Reserving the heavier models for higher-stakes tasks (impact analysis, drift recommendation) keeps the cost per customer manageable.
Event-driven over polling. Agents run when something changes, not on a fixed schedule. A new transaction in the accounting system triggers the ledger-mapping agent to consider remapping. A new pipeline change triggers the forecasting agent to consider refreshing the forecast. The system does only the work that is needed, when it is needed.
Caching and reuse. Many finance tasks operate on similar inputs across customers. Caching mapped structures, reusable model templates, and frequently accessed reference data keeps token costs predictable and lets the platform scale without margin compression.
Together these choices produce a system that gets cheaper to operate per customer as the customer base grows. The infrastructure compounds.
Why users stay in control
A common concern with agent-based products is that the system might do something the user did not want.
We designed Peaky to keep the user in control of every consequential decision. The agents do not change the plan unilaterally. They surface signals. They propose adjustments. They generate recommendations.
The user accepts, modifies, or rejects. The system never overrides human judgement on a decision that matters.
This is a deliberate choice. The job of the agents is to reduce the work, not the authority. Finance leaders should still own the forecast. They should still own the assumptions. They should still own the narrative. The agents do the mechanical work that historically sat between the leader and the decision.
What this produces
The combined effect of the agent pattern, applied to financial planning, is a different kind of product.
A finance team that uses Peaky stops thinking about closes, refreshes, and rebuilds. They start thinking about signals, decisions, and steering.
A CFO who uses Peaky stops being the one who has to push the model forward. They start being the one who decides what the model’s output means.
A CEO who uses Peaky stops asking “what’s our number” and waiting for finance to assemble it. They open the live plan, see the current number, and have the strategic conversation they wanted to have.
This is what continuous financial planning looks like at the user level. Underneath, it is a system of agents doing the work that used to happen in batches. On top, it is a finance function that operates in a fundamentally different shape than the previous generation.
The deeper bet
The deeper bet behind Peaky is that agent-based finance is going to become the default within the next five years.
Not because the marketing convinces buyers. Because the work pattern is structurally better suited to the agent pattern than to the batch pattern. Once a finance team experiences continuous detection, the batch cadence stops feeling like a productivity choice and starts feeling like an accumulated cost.
The companies that move first will have a meaningful operational advantage. The ones that wait will eventually catch up, but they will be paying the cost of the gap for as long as they wait.
We are building Peaky to be the system that leads this shift. If you want to see what agent-based finance looks like on your own data, you can start a trial at peaky.ai.
The financial infrastructure for scaling without surprises.


