A finance operating system — an agent that routes the work, calls the specialist, and ships the output

Context

The single-purpose tools — the reconciliation engine, the payments validator, the statements engine — each solve one job well. But a finance function isn't one job; it's a stream of different requests landing all day, each needing a different skill. The next step up isn't another tool. It's the layer that *knows which tool the request needs* and runs it end to end.

Challenge

Build something that behaves like a finance team, not a macro. It has to read an arbitrary request, understand what's actually being asked, route it to the capability that handles it, gather the right files and reference material itself, do the work, and hand back a finished deliverable — without a human stitching the steps together each time. And it has to keep the function's contexts cleanly separated, the way a real team does.

What I built

A kernel-and-agents operating system for finance work. At the centre is a router that classifies an incoming request and dispatches it; around it sit specialist agents, each with its own skills:

• File-aware navigator — knows where things live and pulls the relevant files into context instead of being handed them.
• Subject-matter / consultation agent — answers the technical finance questions (treatment, controls, method) before the work starts.
• Execution agents with skills — a reconciliation agent that runs the recon skill, an analysis agent that builds scenarios, a developer agent that writes the tool when one doesn't exist yet.

In practice: drop a file and ask *"reconcile this"* → the router hands it to the reconciliation agent → it runs the skill → output. Then ask *"run the US-market scenario analysis, compare against last year's actuals, show how far we can push it"* → the analysis agent picks up the files, pulls the reference data it needs, does the modelling, and produces a finished presentation. One conversation, many specialists, finished deliverables — not a pile of half-steps.

Outcome

The function stops being a person operating tools and becomes a system that operates itself under direction. Routine requests resolve without anyone choosing which tool to open; complex ones — a multi-year scenario analysis ending in a deck — run as a single instruction instead of a week of assembly. It's the difference between *having* automation and *running a function on it*.