A close that runs itself, at any number of stores. Fermata matches every payment across banks, ERP and marketplaces.
No rule fits, so three Claude agents meet on it. A self-approval is blocked in code, and the CFO gets one question.
A year closed on its own: 104,820 payments across 14 stores, 99.5% matched by rule, about 50 decisions for people.
Plain code matches payments, not AI. Every change goes through one Convex function, and only the gateway writes the books.
It learns from historic books: from 126 payouts matched by hand, it worked out Shopee keeps 6.5%, and now matches them itself.
And from one answer: the CFO says yes once, and FIN_Z's 3.8% cut becomes a rule, tested 300 out of 300 first.
The same year, closed twice: 85% to 95% matched with learning, flat 84% without. 498 payments left for people, not 10,356.
The closed books at a glance: the real cash position, the monthly close, and what every agent did all year.
Every rule is a small program with a limit: 7 fitted from last year's books, 4 learned from answers, each approved once.
Ask the books out loud. Claude picks the answer, code fills in every number, and Cartesia speaks it.

Try it first

getfermata.tech tells the whole story in a few minutes:

/demo: watch three agents meet on a held story, then answer the CFO's question yourself.
/how: the system, path by path. Click any box.
/dashboard: the closed year, every rule with its backtest and code.
Ask the books: the pill at the bottom of any page. Ask out loud, it answers by voice.

On one synthetic year of 104,820 bank lines: first pass settling climbs from 85% to 95%, against a flat 84% with the rules frozen. 498 lines are left for people at year end instead of 10,356, with 0 wrong store postings.

The seat it fills: Cash. Every bank line matched to what it pays.

Inspiration

Fermata is modelled on a real Indonesian retailer with many stores sharing a handful of bank accounts. Every month a team spends weeks matching bank lines by hand, because marketplaces pay net of commission, lenders pay net of a cut, and one payout covers hundreds of orders. The knowledge of how to match it all isn't lost. It's in the old books, where someone matched every line by hand for years. Hyphenate framed it as systems of record you integrate with and a system of work you build on top. That's what I built.

What it does

Day 0, it learns from the books you already have. It mines last year's matched lines, fits each pattern (a bank fee, a marketplace commission, a lender's cut) and writes it as a rule with a limit and an evidence count. The CFO approves each one once. That's why day one starts at 85%, not zero.

Every day, it settles or holds. If an approved rule explains a bank line, within that rule's limit, it settles and names the rule. If not, it holds the line instead of guessing, and groups it with others that share its cause into a story.

Each story opens a case room. Three Claude agents meet under a manager written in code: the Investigator finds the pattern, the Auditor tries to break it, the Learner drafts the rule. One person gets one question.

Every answer becomes a rule. The rule is backtested on past books, the CFO approves it once, and every held line it explains settles. The same question never comes back.

How we built it

Convex is the whole backend. The sync, the system of work, the agents, the meeting transcripts and the audit trail all live in one Convex deployment:

The close runs month by month as internal mutations that page through bank lines with .paginate and reschedule themselves with ctx.scheduler.runAfter, pausing when a person is needed.
Every state change goes through one transition() function that checks roles and allowed transitions, and writes the change and its audit row in the same transaction. Denied attempts are logged too, so the books are audit ready by default.
Case rooms are Claude agents running as Convex actions, taking turns through the scheduler and writing the transcript to the database.
Answers and approvals are mutations that schedule the learner, which fits and backtests the new rule.
Live views: the console's run, case rooms, rules, record and evaluation screens all read through useQuery, so they update as the close runs.
Ask the books is a Convex action over named read only queries, guarded by @convex-dev/rate-limiter.

Every feature mapped to its file: hackathon.md.

The engine is plain TypeScript, no AI in the hot path. Agents can propose but never post. Only code writes to the books.

How we know it works

All data is synthetic, from a seeded generator modelled on the real retailer. No real records.
An answer key the engine never reads scores it: 100% precision on a held out week, and 0 of 500 deliberately altered lines slipped through.
Learning is measured, not claimed: the same year with rules frozen at day 0 stays flat near 84%. That baseline is simulated.
The two big case rooms ran live on Claude. The rest are scripted and labelled, and autopilot answered from the answer key so the year could close end to end.

Challenges

My first learning curve went from 81% to 98%. Then I ran the same year with learning off and it climbed almost as much, because the generator had planted the curve. I rebuilt the year so only a taught rule can move it, closed it live, and it matched the simulator in every month. Less flashy, completely true.

What we learned

The hard part of autonomous finance isn't matching. It's knowing when not to: holding instead of guessing, and asking one person exactly one question.

What's next

Shadow mode at one store of the retailer it's modelled on, our first design partner: it proposes, people still decide. Then store by store. Fermata learns patterns, not stores, so it gets better as stores are added, not worse.

For sponsor judges

Hyphenate: policy mining on day 0 from the books a retailer already has, hold and ask instead of guessing, and a learning curve measured against a frozen baseline (85% to 95% vs 84%).
Convex: the whole system of work lives in Convex. Every feature mapped to its file in hackathon.md.
Microsoft, Built for the Real World: modelled on a real retailer who is the first design partner. Measured usefulness (498 lines left for people instead of 10,356), a path to production through shadow mode at one store, and agents that can never post to the books on their own.
Cartesia: Ask the books listens and answers out loud with sonic-3.6 and ink-whisper, and the CFO can answer a case room's question by voice, read back before it counts. Voice tokens are short lived, minted by Convex and rate limited.
Mana: Mana was where Fermata started. While I was still brainstorming, it scaffolded a working prototype wired to Convex and Anthropic. It proposed splitting lines that are WAITING (the other side hasn't arrived) from lines that are HELD (something doesn't add up), and that split is still how Fermata decides what to ask a person.