We let agents run our monthly close. Here's the control system that makes it safe.

If you’re a finance person, your first reaction to that headline is probably the correct one: scepticism. AI agents touching the general ledger sounds like the kind of thing that ends with a restatement and an awkward conversation with your accountant.

So let’s be precise about the claim. Agents do the work of our monthly close: the reconciliation, the chasing, the drafting, the reporting. They do not have authority over our close. Every journal entry is approved by a human before it posts. Every filing is reviewed by a human before it goes anywhere. Nothing sends externally without sign-off. The agents are very fast, very thorough junior staff with no posting rights.

That distinction (work versus authority) is the whole design. Here are the case notes.

Why we automated the close at all

Our setup is more complicated than the size of the business deserves. We run a Singapore parent company, a UK subsidiary and a sole proprietorship, with transactions flowing through five currencies. Revenue arrives in one currency, infrastructure bills land in another, contractors invoice in a third, and the reporting has to be FX-stated coherently across all of it.

For a solo founder, that close was costing two to three days a month of focused, error-prone work. Worse, it was always done at the worst possible time: month-end, when there’s also a product to ship and customers to look after. The close was never wrong, exactly. It was late, rushed, and held together by the founder’s memory of which Stripe payout maps to which entity.

That’s the honest motivation. Not “AI transformation”. We wanted the close to stop eating the first week of every month.

The control design: the checklist is the contract

The foundation of the whole system is unglamorous: a written close checklist. Every step of the close (bank reconciliations per entity, receipt matching, intercompany eliminations, FX restatement, management reporting) is documented as an explicit, ordered list with defined inputs and defined outputs.

The agents work from that checklist and only that checklist. This matters more than any clever prompting. The checklist is a contract: it defines what the agent is allowed to attempt, what “done” looks like for each step, and what must be escalated rather than guessed. If a transaction doesn’t match a documented pattern, the agent’s job is to flag it, not to improvise a classification.

Finance people will recognise this as nothing new. It’s the same logic as a delegation of authority matrix. We just wrote one for software.

Human approval gates, and where they sit

There are three hard gates, and they’re enforced by design rather than by politeness:

No journal posts without human approval. Agents draft journals with full workings attached: source transaction, proposed accounts, FX rate used and where it came from. A human reviews and approves each batch before anything touches the ledger. On a typical close that review takes under an hour, because the workings are laid out for checking rather than redoing.

Nothing sends externally unsupervised. Receipt-chasing emails to suppliers, queries to our accountants, anything that leaves the building: drafted by agents, sent by a human. The agent’s draft is usually fine. “Usually fine” is not the standard for external correspondence from a finance function.

Filings are human-reviewed, full stop. GST, VAT, corporate filings across two jurisdictions. Agents prepare the workings and pre-fill what can be pre-filled. A human (and for the substantive ones, our accountants) reviews before submission. We don’t see a future version of this where that gate comes out.

Recoverability and the audit trail

The second design principle: everything the agents do must be recoverable and inspectable.

All close artefacts (workings, drafted journals, reconciliation reports, the checklist state itself) live in git and Notion. Every agent action leaves a written record of what it did, what it read, and why it made the call it made. If a number looks wrong in March, we can replay exactly how it was produced, which is, frankly, better than the audit trail most human-run small-company closes have. The pre-agent version of our close lived partly in spreadsheets and partly in one person’s head.

This is also the answer to the reasonable CFO question, “what happens when it gets something wrong?” The same thing that happens when a junior gets something wrong: you catch it at review, you trace it, you fix the underlying instruction. Which brings us to the part where we tell you what broke.

What went wrong early (and what it taught us)

Three failures worth your time:

The misclassification run. Early on, an agent spent a close confidently misclassifying expenses: software subscriptions landing in the wrong accounts, a contractor payment treated as a supplier cost. The root cause was embarrassing: our chart of accounts wasn’t properly documented. The agent was pattern-matching off account names alone, and our account names were ambiguous. A human bookkeeper would have asked. The agent guessed plausibly and wrongly, at scale. The fix was documenting the chart of accounts properly: what each account is for, with examples and counter-examples. Classification errors dropped to roughly nothing after that. The lesson generalises: agents expose every place your process secretly depended on tribal knowledge.

FX rate drift. Two reports in one close pack used rates pulled at different times, so the consolidated numbers didn’t tie. Caught at review (which is exactly what the review gate is for), but it forced us to make the rate source and timestamp an explicit checklist input rather than something each step fetched for itself.

Over-eager receipt chasing. An early draft of the receipt-chasing step queued a follow-up to a supplier we’d already resolved by phone. The human gate caught it before sending, but it’s why “nothing sends externally unsupervised” became a hard rule rather than a default.

None of these were exotic AI failures. They were process failures that the agents surfaced faster and more visibly than a human would have.

What it costs

The honest numbers, because this article is useless without them.

Model usage for the agentic close runs us roughly A$150–300 a month, concentrated in close week. It varies with how messy the month was. Human time at the gates is three to four hours a month: journal review, filing review, exception handling. Call the all-in cost of the system well under A$1,000 a month including that human time at any sensible rate.

When we priced a part-time bookkeeper capable of handling three entities, five currencies and two filing jurisdictions, the quotes we received were several times that, and, more importantly, none of them removed the founder review time. We’d still have been checking the work. Now we check faster work with better paper trails.

What the comparison hides: the setup cost was real. Documenting the chart of accounts, writing the checklist, building the approval workflow: that was a few weeks of part-time effort, and the first two closes were slower than doing it by hand, because we were debugging the process. If your close is simple (one entity, one currency, a competent bookkeeper you trust), the payback maths probably doesn’t work and we’d tell you not to bother. This earns its keep on multi-entity complexity.

What we’d never let it do

Worth stating plainly, because the failure mode in agentic finance is scope creep dressed up as efficiency:

• Post journals autonomously. Ever. The approval gate is the system.
• Move money. Agents have no payment authority, no banking credentials, nothing. They can tell us an invoice is due; they cannot pay it.
• Submit filings. Preparation yes, submission no.
• Make judgement calls on treatment. Anything involving accounting judgement (revenue recognition edge cases, capitalisation questions, intercompany pricing) goes to humans and, where it matters, to our accountants. Agents can assemble the facts for that conversation. They don’t get a vote.
• Communicate with the tax office. Obviously.

Gartner predicted in June 2025 that over 40% of agentic AI projects will be cancelled by end-2027, largely on cost, unclear value and inadequate risk controls. We’d bet a decent share of those failures are systems that automated authority instead of work. The boring version, where agents do legwork and humans hold the gates, is the version that survives contact with an auditor.

Do this next week

Don’t start with agents. Start with the checklist. Write down your close as an explicit, ordered list of steps with defined inputs and outputs, and document your chart of accounts well enough that a stranger could classify a week of transactions from the documentation alone.

If you can’t write that document, you’re not ready to automate the close, and the writing of it will improve your close anyway. If you can write it, you’ve just produced the contract an agent can safely work from, and the hard part is already done.