Cherry Agent: Autonomous Finance Ops for SMEs

Cherry Agent - Autonomous Finops Agent
System Architecture
Finance Ops Dashboard
Invoice intake and extraction
Human in the loop approvals
Audit Trail and bookkeeping
Smart Reconciliation

Inspiration

Small-business owners often spend far too much time doing finance administration instead of running their business.

A single invoice can trigger a surprising amount of repetitive work: reading the document, identifying the supplier, categorising the expense, checking the bank account, matching the transaction, deciding whether approval is required, recording the evidence, and eventually reconciling everything for bookkeeping.

Most finance software still expects the human to drive every step.

We wanted to reverse that relationship.

Cherry Agent was inspired by a simple idea:

What if an SME had a finance operations agent that quietly handled the routine work in the background and only involved the human when a genuine decision, exception, or approval was required?

Rather than building another chatbot that explains what someone should do, we wanted to build an agent that actually performs the finance workflow while keeping the human in control of consequential decisions.

What it does

Cherry Agent is an autonomous finance operations agent for SMEs.

It turns fragmented financial activity into a controlled workflow:

Bills / receipts → understand → categorise → reconcile → policy check → approval → audit trail

Cherry Agent can:

analyse invoices, bills and receipts;
extract and structure financial information;
categorise transactions;
compare financial documents with bank activity;
identify likely reconciliation matches;
detect missing, duplicated or inconsistent evidence;
apply business rules and approval policies;
complete low-risk routine steps automatically;
escalate exceptions or sensitive actions to a human;
maintain an evidence trail showing what the agent saw, decided and did.

The goal is not to remove humans from financial decisions.

The goal is to remove humans from repetitive financial administration.

For example, instead of asking a business owner to inspect every transaction, Cherry Agent can process the normal cases automatically and surface something like:

Approval required: Supplier bank details changed on this invoice. Please verify before payment.

That is the experience we wanted: automation by default, human judgment where it matters.

How we built it

Cherry Agent is built around the Strands Agents SDK, which provides the core agentic loop and lets the agent reason about a task, select appropriate tools, inspect the results and decide what should happen next.

We designed the agent around a set of bounded finance tools rather than giving an LLM unrestricted access to financial systems.

The workflow is approximately:

Receive financial evidence
An invoice, receipt, transaction or finance task enters the system.
Understand the task
The Strands agent determines what information and tools are required.
Use specialised tools
The agent can invoke tools for document extraction, transaction matching, categorisation, reconciliation, policy checks and evidence retrieval.
Apply deterministic financial controls
Important financial rules are evaluated by deterministic code rather than relying entirely on an LLM.
Decide whether to continue or escalate
Routine, sufficiently evidenced actions can progress automatically. Ambiguous or sensitive cases become human-review tasks.
Create an audit trail
The system records evidence, tool results, reasoning context and the resulting action so the workflow is explainable and reviewable.

The application uses a Python/FastAPI backend to expose the finance workflows and agent tools.

We also designed Cherry Agent so that it can work with Cherry Money, our pre-existing SME accounting and open-banking platform, as an optional financial context/data source. Cherry Money itself predates this hackathon; the autonomous Cherry Agent workflow and Strands-based agent implementation are the hackathon project.

A key architectural principle is:

The agent proposes and orchestrates; deterministic controls define financial authority.

This gives us the flexibility of an AI agent without treating probabilistic model output as an accounting control.

Challenges we ran into

1. Autonomy versus financial safety

Finance is different from many agent use cases because a small mistake can have real consequences.

We did not want an agent that confidently guessed when information was missing.

We therefore designed explicit boundaries between:

tasks the agent can complete;
tasks requiring stronger evidence;
tasks requiring human approval.

The difficult part was making the system useful enough to feel autonomous without making it dangerously autonomous.

2. Turning messy evidence into reliable actions

Invoices, receipts and transaction descriptions do not arrive in a perfect schema.

Names differ, references are inconsistent, amounts can appear in several places and bank descriptions can be abbreviated.

The agent therefore needs both semantic understanding and deterministic validation before deciding that two pieces of financial evidence represent the same event.

3. Preventing hallucinations from becoming financial decisions

LLMs are excellent at interpreting context, but financial controls need predictable outcomes.

We separated AI interpretation from financial validation.

The agent can determine which tools should be used and interpret the broader workflow, while important calculations, reconciliation checks and policy conditions remain deterministic.

4. Knowing when not to automate

One of the most important behaviours we implemented is stopping.

Changed bank details, weak evidence, conflicting values or unusual transactions should not simply be pushed through because an agent wants to complete its goal.

A good finance agent needs to know when the correct action is:

"I need a human decision."

Accomplishments that we're proud of

We are especially proud that Cherry Agent is more than a finance chatbot.

It represents a complete agentic workflow where the system can:

understand → plan → use tools → validate → act → escalate → record evidence

We are also proud of the human-in-the-loop model.

Rather than treating human approval as a failure of automation, we treat it as one of the agent's available actions.

Another important accomplishment was combining agent reasoning with deterministic financial controls. This lets us benefit from AI's ability to understand messy real-world context while preserving predictable safeguards for accounting and financial operations.

Most importantly, the project tackles a problem we experience with real small organisations: finance administration is made up of hundreds of individually small tasks that collectively consume a significant amount of time.

Cherry Agent is designed to give that time back.

What we learned

The biggest lesson was that the most useful agents are not necessarily the ones that make the most decisions.

They are the ones that know:

what they can safely handle;
which tool to use;
what evidence is sufficient;
when confidence is too low;
and when a person needs to become involved.

We also learned that agentic finance benefits from combining two very different approaches:

probabilistic AI for understanding and orchestration + deterministic software for financial controls.

Strands Agents gave us a useful way to model the orchestration layer around specialised tools rather than putting the whole workflow inside one large prompt.

We also realised that the audit trail is not an optional feature.

For professional agents, users need to understand not only what happened, but also:

what evidence was used;
which tools ran;
which control failed;
why the agent escalated something;
and what the human needs to do next.

That observability is essential for building trust.

What's next for Cherry Agent: Autonomous Finance Ops for SMEs

Our next goal is to move from individual finance workflows toward a persistent AI finance operations layer for small businesses.

We want Cherry Agent to continuously watch the financial workflow and quietly handle routine work such as:

accounts payable;
receipt processing;
transaction categorisation;
bank reconciliation;
invoice follow-up;
approval routing;
cash-flow monitoring;
bookkeeping preparation;
and month-end evidence collection.

We also want to deepen the integration with open banking so that the agent can understand financial activity in near real time while maintaining explicit approval boundaries around sensitive actions.

Future development will focus on:

richer multi-agent finance workflows;
configurable company approval policies;
stronger anomaly and duplicate detection;
persistent business context;
open-banking integrations;
accounting integrations;
explainable audit evidence;
and production-grade deployment and monitoring on AWS.

Our longer-term vision is simple:

A small business should not need a large finance operations team just to keep its financial administration under control.

Cherry Agent should handle the repetitive work continuously and quietly — and bring the human back into the loop only when human judgment genuinely adds value.