The Black Box Liability
There is a familiar argument doing the rounds about local AI. It goes like this: frontier models are expensive, small local models are cheap, so run the routine work locally and reserve the big model for the hard problems.
I have a lot of time for local models, and the economics are real. But framing them purely as a cost play undersells what they are for. It treats a question of architecture and governance as a question of the monthly bill, and in doing so it steps around the problem that actually matters.
Regulation is arriving faster than most AI roadmaps assumed. The EU AI Act, ISO 42001, and strict data sovereignty requirements share a single, uncompromising demand: show your workings.
Think about what actually happens when you throw an outcome-driven prompt at a third-party frontier API. The entire reasoning process leaves the building. Every decomposition step. Every intermediate decision. Every tool call. All of it happens inside someone else's infrastructure, invisible to the organisation that owns the outcome. You get an answer back. You never get the workings.
That is acceptable for a consumer application. It is fundamentally unviable for a bank, a hospital, an insurer, or a defence contractor. That is an ungoverned decision process running on sensitive data, and you cannot audit what you cannot see. Fifty years of engineering discipline, outsourced to a black box on someone else's cloud, billed by the token.
The Evolution of Governance
The iterative loop—plan, do, check, act—is not a new concept. We spent decades building rigorous governance around it: stand-ups, retrospectives, definitions of done, and sign-offs. This scaffolding existed because unsupervised trial and error amounts to error with better branding.
Then we automated the loop with LLMs, renamed it "agentic," allowed it to run at machine speed, and quietly discarded the receipts.
To solve this, we must put a local model at the head of the loop. Not as a cost-saving router, but as the orchestrator that strictly owns the reasoning process. The loop stays home. The thinking travels only when it must.
The Orchestrator and the Escalation Contract
A local loop head is not a large model in miniature. Set it up that way and it will fail publicly in front of your compliance team.
The mechanism is decomposition. Break the work into inspectable, governable steps, and a small model configuration will carry the vast majority of end-to-end requests on its own: understand the request, route it, execute the tools, assemble the response.
The loop head owns the state machine. It owns the tool layer, calling systems the enterprise controls without a network round trip. It owns the policy layer, enforcing what this workflow is allowed to touch prior to execution. Above all, it owns the Escalation Contract.
Once the loop head runs locally, escalating to a frontier model stops being the default and becomes a strict decision with defined terms. Big models for big problems. What leaves the building is a compressed, policy-filtered brief, never the raw context. The system logs exactly why it leaves (because the task exceeded local capabilities), under whose authority, and what comes back, which the local orchestrator validates before acting. Trust, but verify.
The frontier model becomes your subcontractor. Expensive, brilliant, and called in exclusively for the problems that warrant it, working to a brief you wrote, on data you chose to share, with a paper trail a regulator can read.
That is a governance architecture. Cost savings are a pleasant side effect.
The Engineering Reality
Two hard engineering problems sit inside this architecture. Anyone selling it without naming them is selling a diagram.
First, context degradation. Agentic loops accumulate history at a frightening rate. Local hardware hits its memory ceiling fast. Without serious state compression at the loop head, the system degrades exactly when the workflow gets interesting. Summarisation is load-bearing.
Second, failure detection. Small models are highly effective at structured routing and expected tool calls. They are poor at noticing when a tool output has gone off-script or when recovery requires reasoning they lack. The dangerous failure is not the local model making an error; it is the local model not knowing it made an error. The Escalation Contract only holds if the loop head can spot its own ceiling and hand off cleanly, context intact.
These are rigorous platform disciplines, not weekend integrations.
The Sovereign Loop
An architecture where the reasoning loop runs on infrastructure you control, where every step is inspectable, and where every escalation is a logged decision with defined terms, represents fifty years of delivery discipline reapplied to the fastest loop we have ever built.
It is the only version of agentic AI that a regulated enterprise can realistically deploy.
The industry misreads the economics of AI. Sovereign workloads are coming home. The Escalation Contract is the architecture that serves this reality. The loop stays home, the thinking travels only when it must, and every journey remains on the record.