The thesis
Governed probability.
AI produces value from probabilistic outputs, and most enterprises can’t use it because nobody has made those outputs accountable. Our answer is a probabilistic core, a deterministic shell, and a decision record for every judgement.
01
Software used to be judged by whether it worked. AI is judged by how often it’s right.
Enterprise software has been deterministic for forty years. The same input gave the same output, a specification described what it would do, a test proved it, and a sign-off meant it was done. Procurement, contracts and audit were all built on that promise.
A model does not keep that promise. It creates value precisely because it handles the cases nobody specified — and it pays for that with an error rate. Wrong is a rate, not a bug. You can drive the rate down; you cannot write it out.
That changes everything downstream. The specification becomes an eval set drawn from your own historical decisions. Testing becomes measurement against it. Acceptance becomes a threshold, not a checklist. Price follows the decision, not the feature.
Most enterprise AI stalls because it is bought and governed as if it were still deterministic software. The demo works, nobody can say how often it will be wrong on live traffic, and so nobody lets it decide anything.
02
Twenty years of deterministic instinct is both the problem and the asset.
Engineers and operators raised on deterministic systems demand certainty. Point that instinct at the core of an AI system and it fails: a probabilistic model cannot give a guarantee, and insisting on one means nothing ships.
Point the same instinct at the edges and it is exactly right. Someone has to know which steps can never be probabilistic — which ledger entry, which filing, which access grant must be exact every time. That knowledge comes from years of building systems that were not allowed to be wrong.
The teams that win hold both modes at once: at ease with a measured error rate at the core, uncompromising at the boundary. We build for that combination. It is rarer than either half.
03
System of record vs system of judgement.
Every enterprise has a system of record: the ERP, the core banking system, the ledger. It stores what happened, and it is authoritative because it is deterministic.
None has a system of judgement. The decisions made on top of the record — approve this claim, characterise this payment, escalate this exception — live in inboxes, spreadsheets and people’s heads. They are made hundreds of times a month and almost never recorded with the inputs and reasoning behind them.
A system of judgement is where those decisions go. Each decision class gets an agent with a measured error rate, a defined boundary, an autonomy level it has earned, and a record of every call: inputs, confidence, outcome and any human override.
It sits beside the system of record, not in place of it. The agent reads from the record and prepares the change; the write stays deterministic. Every judgement is designed to be written to Warrant, the open-source decision ledger we built and publish, and the client owns the records.
04
Autonomy is earned per decision.
Autonomy is not a property of an agent or of a deployment. It is set for each decision class, and every decision class starts at the bottom of the dial.
A decision moves up one level at a time, and only when its measured accuracy holds against the agreed threshold on live traffic for weeks. A breach drops it back automatically; nobody has to notice first.
That is what lets a risk committee say yes. It is not asked to trust a model. It is asked to approve a threshold, and it can watch the evidence against that threshold for as long as the agent runs.
05
Where probability is forbidden.
Some steps are never handed to a model: money movement, statutory filings, access control and writes to the system of record. There the output must be exact, attributable, and reversed only by a deliberate act.
On those steps the rule is simple. Agents prepare; rules and people execute. The agent gathers the evidence, drafts the entry, computes the figure and states its confidence. A deterministic check or a named person commits it.
The clearest example is the remittance-withholding workbench, deployed with a firm that builds and operates capability centres for US clients. For each payment to a non-resident it takes in the document pack, resolves the rules in force on the payment date, characterises the supply and computes the withholding rate. It prepares the forms. It does not file them — the team does.
The judgement is probabilistic and measured. The filing is deterministic and human. Drawing that line precisely is most of the engineering.
06
Why it compounds.
Two motions feed one engine. Engineers deployed inside a business find the decisions worth automating; a factory builds them in 2–4 week sprints on a platform we have already hardened elsewhere. Whatever generalises returns to the catalog.
What returns is more than code. It is one spine — the deterministic shell, the compliance mapping, the deployment — one ledger of decisions, and a shared library of evals.
So each new estate starts with decision archetypes that are already measured: a document classification, a rate determination, an exception ranking. It still earns its autonomy on its own data, but it starts from evidence rather than from zero, which makes it cheaper and faster than the last.
Some of what comes out is a partner’s system. Some of it is spun off as a company of its own.