-
-
Cherry CFO From documents to decisions
-
Upload evidence
-
AI analyses and builds your workspace
-
Investigate exception
-
Review and decide
-
Trusted Outcomes
Inspiration
Finance teams do not usually struggle because they lack data. They struggle because the evidence required to make a decision is scattered across spreadsheets, administrator reports, accounting records, side-letter rules, financial statements, and supporting documents.
For a fund controller reviewing NAV, the real work is often not simply calculating a number. It is understanding:
- Which evidence is present?
- Which controls can actually be performed?
- Which figures reconcile?
- What is causing an exception?
- Is the issue material?
- What needs to go back to the administrator?
- And ultimately: is there enough evidence for a human to sign off?
We wanted to build an autonomous finance agent that understands that distinction.
Instead of creating another AI chatbot that answers questions about finance documents, we built Cherry CFO to perform a real Office of the CFO workflow.
For Syndicate, we focused specifically on the NAV Quality Controller workflow: turning a fragmented NAV close pack into an evidence-led, controlled and human-governed review process.
Our guiding principle became:
AI can investigate the finance work. Deterministic controls validate the numbers. Humans retain financial judgement.
What it does
Cherry CFO - Autonomous Finance Agent is an agentic NAV close workspace for fund controllers and finance teams.
A user can bring the NAV close pack exactly as it exists and upload multiple files from different sources, including:
- administrator NAV files;
- investor-level general ledger exports;
- Excel workbooks;
- financial statements;
- side-letter rules;
- bank or custodian evidence;
- CSV and JSON data;
- PDFs and supporting documents;
- ZIP evidence packs.
Cherry CFO then turns those disconnected inputs into a visual finance workspace.
1. Evidence intake and classification
Documents are classified and validated individually.
Instead of assuming that every required source is available, Cherry CFO builds an explicit evidence manifest showing:
- what each document appears to contain;
- whether it passed its input contract;
- what controls it can support;
- validation warnings;
- source identifiers; and
- SHA-256 evidence lineage.
2. Evidence readiness
Before running financial controls, Cherry CFO determines what can actually be checked with the evidence provided.
Missing information is not silently invented.
If a control needs evidence that is not available, that control remains unavailable or becomes an explicit evidence gap.
3. Deterministic NAV controls
Once sufficient evidence exists, Cherry CFO runs deterministic finance checks.
The LLM does not manufacture authoritative NAV figures.
Financial calculations and control outcomes remain deterministic and auditable.
The workspace can surface:
- NAV footing issues;
- balance-sheet inconsistencies;
- NAV bridge breaks;
- investor-capital discrepancies;
- evidence gaps;
- material exceptions; and
- other items requiring controller attention.
4. Agentic exception investigation
Once deterministic controls identify an issue, the agent can investigate the surrounding evidence.
Its job is to help answer:
- What failed?
- What evidence supports the finding?
- What is the likely root cause?
- Which items belong together?
- What should be requested from the administrator?
- What action should the controller consider next?
The agent can consolidate many individual findings into a more useful remediation package.
It cannot override the deterministic control result.
5. Human judgement
Cherry CFO deliberately treats human judgement as a first-class workflow state.
After the controls and agentic investigation, the controller can record an explicit decision such as:
- Approve NAV
- Approve with exception
- Request evidence
- Return to administrator
- Escalate
The human sees the evidence, controls, exceptions, and investigation before deciding.
6. Dynamic Canvas + Document view
We wanted the interface to feel like a finance workspace rather than a traditional dashboard.
In Canvas mode, evidence and generated finance objects appear dynamically as connected cards:
Administrator NAV
│
Investor GL ────────┐
│ │
Side-letter rules │
│ ▼
Supporting docs → Evidence readiness
│
▼
NAV controls
│
┌────┴────┐
│ │
Pass Exceptions
│
▼
Agentic review
│
▼
Human decision
│
▼
Audit trail
Cards are draggable and inspectable, with evidence lineage available directly from the workspace.
In Document mode, the same workflow becomes a structured NAV close review containing:
executive summary;
evidence pack;
NAV controls;
open findings;
remediation information; and
human decision.
How we built it
Cherry CFO combines agentic reasoning with deterministic financial controls.
Backend
The finance workflow is built with:
Python
FastAPI
Pydantic
Google ADK
Gemini
deterministic Python financial controls
document classification and extraction
structured evidence contracts
audit and evidence lineage
The workflow is exposed through explicit finance APIs for:
Create NAV case
↓
Classify evidence
↓
Assess readiness
↓
Run deterministic NAV controls
↓
Run agentic review
↓
Record human decision
Frontend
For the Syndicate build we created a new dynamic NAV workbench inspired by modern collaborative design tools.
It includes:
an infinite-style canvas;
drag-and-drop document upload;
multi-file and multi-batch evidence intake;
folder upload;
draggable finance components;
dynamic relationship lines;
an evidence inspector;
document provenance;
a bottom evidence asset dock;
Canvas / Document switching;
agent interaction; and
a dedicated human decision workflow.
Human-governed architecture
One of our most important architectural decisions was separating reasoning authority from financial authority.
The model is good at interpreting context and explaining exceptions.
It is not allowed to turn uncertain evidence into an authoritative financial result.
Our architecture therefore follows:
AI understands
↓
Deterministic controls verify
↓
AI investigates exceptions
↓
Human makes judgement
AO
We used AO (Agent Orchestrator) during the Syndicate build to coordinate focused engineering work across the project.
We separated work into specialised sessions covering areas such as:
Office of the CFO workflow design;
finance-control architecture;
exception handling;
human-review design;
reliability and evaluation;
UI/workbench development; and
demo hardening.
This allowed us to work on multiple parts of the system while keeping them aligned around one end-to-end NAV controller workflow.
Pre-existing foundation
Cherry Money and parts of our general agentic-finance foundation existed before Syndicate.
For the hackathon, we deliberately focused on building and extending the NAV Controller workflow, governed automation, evaluation approach and dynamic finance workbench rather than claiming the entire finance platform was created during the event.
Challenges we ran into
Knowing where autonomy should stop
The hardest problem was not getting AI to read financial information.
It was deciding:
When should the system trust itself, and when should it stop?
In finance, a confident but unsupported answer can be worse than no automation at all.
We therefore had to design clear boundaries between:
deterministic results;
model interpretation;
missing evidence;
genuine exceptions; and
decisions requiring human judgement.
Working with incomplete evidence
Real finance workflows are rarely perfectly packaged.
A controller might receive the NAV workbook today, the investor GL later and supporting evidence from another system.
We therefore designed Cherry CFO so that evidence can arrive incrementally.
The system updates what it knows and enables only the controls that the evidence can genuinely support.
Making provenance visible
A judge—or accountant—should be able to ask:
"Where did this finding come from?"
We had to make evidence lineage visible in the product rather than hiding it inside logs.
Each source therefore remains identifiable throughout the workflow.
Building a useful agent rather than a finance chatbot
It was tempting to simply let the LLM answer questions over uploaded files.
Instead, we had to model the actual finance workflow:
evidence → readiness → controls → exceptions → remediation → human decision
That took more thought, but produced a much more realistic Office of the CFO application.
Designing for a three-minute demo
The underlying finance workflow can become complex very quickly.
We had to resist building every possible CFO function and instead make one specific controller workflow understandable, visual and credible.
Accomplishments that we're proud of
We are particularly proud that Cherry CFO is not just a conversational layer over finance data.
It performs a governed workflow.
Evidence-aware automation
The system understands that missing evidence is itself meaningful.
It will not silently fabricate what is required to complete a control.
Deterministic financial authority
Authoritative finance results are produced by deterministic controls rather than model-generated arithmetic.
Human judgement is built into the architecture
Human review is not an error state.
It is an intentional part of the workflow.
Evidence lineage
Uploaded evidence remains traceable through the resulting control and review process.
A dynamic finance workspace
The Canvas experience transforms a static close process into a visual graph of:
documents → controls → exceptions → decisions
This makes the agent's work much easier to understand.
One workspace for the entire review
The same state can move between an interactive canvas and an audit-style controller document without rebuilding the analysis manually.
Reliability over spectacle
We chose not to give the model unrestricted authority simply to make the demo appear more autonomous.
A safe refusal to approve unsupported NAV is a feature, not a failure.
What we learned
The biggest lesson was:
Useful financial autonomy is not maximum autonomy.
The most valuable finance agent is not necessarily the one that makes the most decisions.
It is the one that removes the most repetitive investigation while making the remaining human decisions easier and safer.
We also learned that agents become much more useful when their tools represent business workflows, rather than exposing hundreds of low-level technical operations.
For example, a controller should think in terms of:
assess evidence readiness;
run NAV controls;
investigate exceptions;
prepare remediation;
record a decision.
Not database calls or individual API operations.
Another important lesson was that agent quality needs to be evaluated using the final financial state, not simply whether the generated explanation sounds convincing.
For finance automation, important questions include:
Did the correct control run?
Was unsupported automation blocked?
Was the correct exception identified?
Was the source evidence preserved?
Was human review required at the correct point?
Did the agent avoid changing authoritative financial state?
Finally, we learned that visualising agent work can make autonomy significantly easier to trust.
When accountants can literally see:
what came in → what was checked → what failed → why → what needs their decision
the agent becomes less of a black box.
What's next for Cherry CFO - Autonomous Finance Agent
The NAV Quality Controller is one Office of the CFO workflow.
Our broader vision for Cherry CFO is an autonomous finance operations layer where agents perform repetitive financial work while humans retain control over material judgement.
Next we want to extend the same architecture into:
month-end close;
account reconciliation;
cash application;
accounts payable;
invoice processing;
audit evidence gathering;
management reporting;
variance investigation;
forecast updates;
intercompany reconciliation; and
controller close checklists.
For the NAV Controller specifically, next steps include:
richer administrator and custodian integrations;
accounting-system connectors;
persistent review workspaces;
more NAV-control libraries;
materiality and authority policies;
multi-period comparison;
automatic administrator remediation packages;
reviewer assignment;
complete evidence-pack export;
controller metrics and close-cycle analytics; and
evaluation against anonymised real-world NAV cases.
Our long-term goal is simple:
Cherry CFO does the repetitive finance work required to reach a decision. Humans remain responsible for the decisions that matter.
Log in or sign up for Devpost to join the conversation.