8,000 Hours of Work Inside an 8,064-Hour Window

• Client. Mid-size commercial bank, ~1.8M transactions per month across card, ACH, wire, real-time rails, and nostro/vostro accounts
• Starting point. Month-end close running 8 business days. 96 days a year spent closing.
• What CreateOS built. A six-agent reconciliation crew with fork-per-exception parallelism, deployed self-hosted inside the bank's boundary
• Close time. Down 75% committed. As low as hours in the cleanest cycles.
• Error rate. From the 2% to 5% manual band toward 0.01%
• Post-close adjustments. Materially reduced
• Unauthorized postings. Zero, enforced in the kernel
• Audit coverage. 100% of matches, exceptions, and postings logged

The matching platform was fine, clearing 97% of 1.8 million monthly transactions automatically. The close was not slow because the matching was slow. It was slow because of the queue.

• 8,000 analyst-hours of work inside an 8,064-hour window. Around 21,600 of the 54,000 monthly exceptions landed in the month-end window, each a small investigation averaging 22 minutes, against 126 analysts working eight-hour days for eight business days.
• The month-end crunch was arithmetic, not culture. The team was exactly, precariously sized for a close with no surprises in it, and closes have surprises in them. A rail outage or one nasty break became overtime and a missed deadline.
• Financial reporting waited eight days. Eight days in which leadership, the board, and regulators look at a period the bank cannot yet speak to with confidence.
• Liquidity sat trapped against unconfirmed positions. Every day of close is a day of capital held against uncertainty that, in the overwhelming majority of cases, resolves to nothing.
• Treasury and risk ran on week-old information. And in the worst case materially wrong information, with the manual error rate in the 2% to 5% band research consistently finds. Post-close adjustments were routine.
• The exceptions that ran out of clock aged into losses. Write-offs, uncaptured fees, and duplicate payments nobody clawed back.
• Nobody could explain how it would be allowed near the ledger. The bank wanted to close in a day. What it could not find was a way an autonomous system would get there that the external auditor would accept.

The insight that unlocked this is almost embarrassingly simple, and it is the thing a rules engine structurally cannot do anything about.

The close is not slow because each exception is hard. It is slow because the exceptions are worked in a line. Eight thousand hours of investigation poured through 126 people, one item at a time, is eight days no matter how good those people are. The constraint is the serialization, not the work.

• Matching stays deterministic, rules-based and exact. A guessed match is a misstated book, so probabilistic reasoning is structurally barred from asserting a match.
• Each break is traced to root cause, not just flagged. Investigation is reasoning work over messy cross-system context, which is exactly what a rules engine cannot do.
• Fork-per-exception is what compresses the close. The 21,600 month-end items do not queue behind the hardest one. They are worked concurrently in thousands of isolated environments that spin up, investigate, resolve or route, and disappear.
• Blocked items pause instead of burning compute. An exception waiting on counterparty information resumes the moment the data lands.
• Eight thousand sequential hours becomes a parallel workload. That is the whole mechanism, and it is only available because we own the runtime rather than renting it.
• Posting is separated from investigation. The agent that investigates a break is not the agent that posts the resolution, and the bank's sign-off thresholds sit with the orchestrator, with every step logged.

The second half of the problem was permission, and this is where most agentic reconciliation projects die. The controller's position was reasonable and firm: no autonomous system posts to my ledger without a hard guarantee on what it can touch.

We gave them one, and we gave it to them at the kernel.

Outbound network access is allowlisted in the kernel using eBPF. The resolution agent can reach the sanctioned ledger and payment paths and nothing else. An agent that is wrong, or compromised, or manipulated, cannot post outside policy or move money outside policy, because the network path does not exist. This is not a model instruction that a clever prompt might talk its way around. It is enforced below the agent, in infrastructure the agent cannot see or reach.

Postings above the bank's thresholds route to a named human. Segregation of duties survives intact. Every match, exception, and posting is logged with its rationale, producing a chain the external auditor can replay.

Everything runs self-hosted inside the bank's region and boundary. Ledger and payment data never leave. CreateOS is SOC 2 Type II and ISO 27001 certified, which meant procurement was a process rather than a war.

Nine weeks of shadow mode preceded any real posting. The agents worked live exceptions in parallel with the team, binding nothing, while we compared their resolutions to the analysts' and tuned. Proving the books came out right was the gate on everything else.

Close time down 75%, committed: eight business days to two, so ninety-six days a year in close became roughly twenty-four.

• Hours is the ceiling, two days is the commitment. In the cleanest cycles, on scoped account types with no rail surprises, the reconciled position assembled in hours. We do not sell the ceiling: any vendor offering a three-hour close as a contractual floor is either not going to hit it or is not counting the same things you are.
• The month-end crunch stopped being arithmetic. With investigation running in parallel and average handling down from 22 minutes to roughly 9, a late counterparty file is an inconvenience rather than a missed close.
• Error rate from the 2% to 5% manual band toward 0.01%. Post-close adjustments fell accordingly, so the controller signs a close they have less reason to revisit.
• Treasury and risk work off current positions. Liquidity previously held against unconfirmed positions comes free days earlier. We deliberately do not headline a dollar figure, because it depends on the balance sheet and cost of funds, and a soft input in a hard column is how a finance reviewer learns to distrust the whole case.
• Exceptions stopped ageing out. The breaks that went unworked because the close ran out of clock now get worked, and the leakage quietly becoming write-offs gets surfaced against the real ledger.
• Zero unauthorized postings, 100% audit coverage. Enforced in the kernel rather than asserted in a policy document, with every match, exception, and posting logged with rationale and replayable for an external auditor.

Not speed. Control.

A faster close is the visible outcome, and it is the one that gets the meeting. But a controller who has been doing this for twenty years knows that a fast close you cannot defend is worse than a slow close you can. They have seen automation that produced a number quickly and could not explain where it came from.

What made this deployable was that the guarantees ran the other way from the usual pitch. The agents got faster because of parallelism, which costs the controller nothing in assurance. And the agents got permission to post because the constraint on posting lives in the kernel, below the model, in a place no amount of agent misbehaviour can reach.

Speed came from the runtime. Safety came from the runtime. That is not a coincidence, and it is not something a vendor who rents their infrastructure can offer you.

Phase 0, weeks 1 to 2. Baseline. We measure the actual close time, exception volume and handling time, current auto-match rate, error and post-close adjustment rate, and the liquidity held against unconfirmed positions. This becomes the contractual yardstick.

Phase 1, weeks 2 to 6. Build and integrate. Stand up the agent crew, integrate to the general ledger, payment rails, and existing reconciliation tooling along allowlisted paths, encode matching rules and control thresholds, deploy self-hosted inside the boundary.

Phase 2, weeks 6 to 9. Shadow run. Agents work real exceptions in parallel with the team, posting nothing. Resolutions compared to the analysts', accuracy confirmed, leakage quantified.

Phase 3, weeks 9 onward. Controlled go-live. Automated posting enabled first for the lowest-risk within-threshold exception types, everything above threshold routed to a human, full audit logging on, scope expanding as the audit record builds confidence.

Success criteria, agreed up front: close time down at least 75%, exception-handling time down at least 60%, reconciliation accuracy at or above the current process, zero unauthorized postings, 100% audit coverage.