FinPilot — Autonomous Office of the CFO
Inspiration
Month-end close is still filled with repetitive finance operations: reconciling transactions, investigating mismatches, preparing journal entries, collecting evidence, and waiting for approvals.
We asked:
What if a CFO could simply say, “Close September,” and an AI system could execute the workflow instead of just explaining it?
That question inspired FinPilot.
We did not want to build another finance chatbot that answers questions about spreadsheets. We wanted to build an autonomous finance operations system that can investigate issues, gather evidence, make recommendations, execute safe actions, and stop whenever human judgment is required.
Our core idea became:
Evidence before action. Policy before autonomy. Materiality determines human involvement.
What it does
FinPilot converts a high-level CFO goal into an executable workflow.
For example:
“Close September.”
FinPilot orchestrates:
Ingest → Reconcile → Detect Exceptions → Investigate → Gather Evidence → Apply Policy → Assess Risk & Materiality → Resolve or Escalate → Prepare Journal Entries → Approve → Close → Generate Audit Evidence
It can detect and investigate:
- Amount mismatches
- Duplicate invoices
- Duplicate transactions
- Missing ledger entries
- Missing bank transactions
- Timing differences
- Bank fees
- FX variances
- Incorrect GL mappings
- Policy violations
- Suspicious transactions
The important part is that FinPilot does not give an LLM unrestricted access to financial records.
Instead, every proposed financial action follows:
AI recommendation → deterministic validation → policy check → risk/materiality check → human approval when required → typed execution
This allows FinPilot to automate low-risk work while keeping humans in control of material or sensitive decisions.
How we built it
We designed FinPilot as a multi-component autonomous finance system.
The system includes:
Orchestrator Agent — coordinates the overall close workflow.
Reconciliation Agent — matches bank, ledger, invoice, payment, and transaction records.
Investigation Agent — investigates exceptions and gathers supporting evidence.
Policy Engine — checks whether proposed actions comply with configured accounting policies.
Risk & Materiality Engine — determines whether the action can be automated or requires human review.
Human Approval Gate — pauses the workflow when approval is required and resumes from a persisted checkpoint.
Journal Entry Engine — validates balanced debit/credit entries and uses idempotency to prevent duplicate posting.
Financial Evidence Graph — connects financial entities and evidence across the workflow.
Audit Ledger — records decisions, approvals, actions, and outcomes.
Our frontend is built using Next.js, React, TypeScript, and Tailwind CSS.
The backend uses Python and FastAPI, with a data layer designed around PostgreSQL and pgvector.
For the hackathon, we created deterministic synthetic financial data and controlled scenarios so the complete autonomous workflow can be demonstrated consistently.
Challenges we ran into
The hardest challenge was not getting an AI model to generate an answer.
It was deciding when an AI-generated decision should actually be allowed to affect financial operations.
We had to design a clear boundary between:
Reasoning → Evidence → Policy → Risk → Approval → Execution
We also faced several engineering challenges:
Reliable autonomous workflows
Agents can fail, services can timeout, and humans can take time to approve decisions.
We therefore designed the workflow around checkpoints, retries, and resumability.
Preventing duplicate financial actions
A retry must never accidentally create the same journal entry twice.
We addressed this through validation and idempotency controls.
Explainability
A finance user cannot simply trust:
“The AI thinks this is a bank fee.”
FinPilot must show the supporting evidence and the policy used to reach the decision.
Human-in-the-loop autonomy
We had to make the system autonomous without making it reckless.
That led to our risk and materiality model, where high-risk, suspicious, policy-sensitive, or material transactions are automatically routed for human approval.
Accomplishments that we're proud of
We are proud that FinPilot demonstrates an end-to-end autonomous finance workflow, rather than stopping at a conversational AI interface.
The system can:
Process data → reconcile records → identify exceptions → investigate them → gather evidence → apply policies → evaluate risk and materiality → resolve safe cases → request human approval when needed → generate journal proposals → maintain an audit trail
One of our showcase scenarios involves:
CloudScale India
Invoice: ₹5,00,000
Bank settlement: ₹4,82,000
Variance: ₹18,000
Instead of simply flagging the difference, FinPilot investigates the discrepancy using connected financial evidence and determines whether it can be explained.
We also demonstrate a:
₹18,40,000 journal entry
that exceeds the configured approval threshold.
Rather than bypassing the control, FinPilot pauses and requests Controller approval before continuing the workflow.
That behavior is central to our product:
Autonomy when safe. Human control when necessary.
What we learned
Our biggest lesson was that trustworthy enterprise AI is a systems problem, not just a model problem.
A powerful LLM alone is not enough for financial automation.
We learned that a production-style autonomous system needs deterministic controls around the model:
Evidence makes decisions traceable.
Policy defines what is allowed.
Risk and materiality determine the level of autonomy.
Approval gates preserve human authority.
Idempotency and checkpoints make execution reliable.
Audit trails make the system accountable.
This changed how we think about agentic AI.
The goal is not to make the AI do everything.
The goal is to make the AI know what it can safely do, prove why it is doing it, and know when to stop.
What's next for FinPilot
Month-end close is only the beginning.
Our next goal is to expand FinPilot into a broader Autonomous Office of the CFO.
The same architecture can support:
Continuous Reconciliation
Accounts Payable & Accounts Receivable
Cash Management
Financial Forecasting
Variance Analysis
Continuous Controls Monitoring
Audit Preparation
We also want to connect FinPilot to real ERP, banking, accounting, and payment systems while strengthening policy management, forecasting, evidence retrieval, and human approval workflows.
Our long-term vision is:
AI handles the repetitive operational work of finance. Humans remain in control of material decisions.
FinPilot — Close the books. Not just chat about them.
Built With
- accounting
- agentic-ai
- ai-agents
- audit
- data-reconciliation
- docker
- fastapi
- financial-automation
- fintech
- llm
- next.js
- pgvector
- postgresql
- python
- react
- rest-api
- risk-management
- tailwind-css
- typescript
- workflow-automation
