Own the weights

For as long as this generation of AI has existed, sovereignty and capability have pulled in opposite directions. If you wanted the best model, you sent your data to someone else's cloud and accepted their terms, their roadmap, their price sheet. If you wanted control, you ran something open and accepted that it was a generation behind. Every enterprise AI strategy of the past three years has been, underneath the slideware, a position on that trade-off. As of the middle of 2026, the trade-off has quietly collapsed.

The current crop of open-weight models — GLM-5 and its successors, DeepSeek V4, Kimi K2.6, Qwen 3.6 — did not close the gap by topping a chat leaderboard. They closed the gap that matters for enterprise work: multi-step task completion, accurate tool calls a thousand turns into a session, failure modes an agent harness can catch and recover from. On the agentic benchmarks that predict whether a system survives contact with a real ticket queue, the best open models now sit beside — and on some tasks above — the closed frontier of a year ago. And nearly all of them ship under MIT licences.

The question is no longer whether open models are good enough. It is whether your organisation is arranged to benefit from the fact that they are.

Licences before leaderboards

The licence matters more than the score. MIT means you can fine-tune the model, merge it, distil it into something smaller, and deploy it commercially — with no usage clause that changes next quarter, no telemetry phoning home, no terms of service between you and your own system. A benchmark advantage decays in months; the right to shape and keep the artefact does not. When an enterprise evaluates models by leaderboard position alone, it is reading the sticker price and ignoring the lease terms.

Compare the alternative honestly. An API model — however brilliant — puts your capabilities on someone else's roadmap, your unit economics on someone else's price sheet, and your most sensitive data on a residency exception that your compliance team renews annually and understands vaguely. None of that is an argument against using frontier APIs. It is an argument against depending on them structurally, the way the last decade depended on SaaS.

Memory you can compile

Here is what ownership actually buys, and it is the point this series has been circling since the first essay. An enterprise's advantage was never the model; models are becoming a commodity in real time. The advantage is memory — the accumulated record of how your organisation decides, resolves, phrases, escalates, and recovers. With a rented model, the best you can do is show it that memory, one context window at a time. With your own weights, you can compile it in. Every resolved ticket, every corrected draft, every successful tool trace becomes training signal for an adapter — a small, cheap, version-controlled file of weights that carries your institution's way of working. The base model stays frozen and replaceable. The adapters are yours, trained on data that never left the building, hot-swapped per department the way you deploy any other artefact.

With an API you can prompt with your data. With your own weights, you can become your data.

And this is no longer research-lab work. Parameter-efficient fine-tuning has cut the cost of training by more than ninety percent against full fine-tunes of a few years ago; the serving stack — vLLM or SGLang behind an ordinary internal API, on Kubernetes you already run — is boring, documented, and speaks the same wire format your existing agent code already uses. Standing it up is a build week, not a moonshot. The hard part, as ever, is not the infrastructure. It is being the kind of organisation that captures its own operational record well enough to learn from it.

The honest economics

Self-hosting is not automatically cheaper, and anyone who tells you otherwise is selling GPUs. A serious open model wants serious hardware, and against the cheapest API pricing on earth, the break-even needs real volume. But that is the wrong comparison. The right comparison is frontier-API pricing on the traffic an agentic layer actually generates — thousands of long, tool-heavy sessions a day, the L1 and L2 queues, the document pipelines, the reconciliations — plus the unpriced cost of the trap: the vendor dependency you cannot exit and the data you cannot use. Priced that way, the crossover arrives early for any enterprise whose agents do real work. And sovereignty is not on the meter at all: it is either structural or it is absent.

The router, not the religion

None of this requires abandoning the frontier. The architecture that is winning is not open-versus-closed; it is a router that you own. High-volume, domain-tuned, sensitive traffic runs on your fine-tuned open weights, on your metal. The rare, genuinely hard, non-sensitive escalation goes to whichever frontier API is best this quarter — as a subcontractor, swapped by changing one line of configuration. The enterprise owns the router, the memory, the tools, and the adapters: the connective tissue. The models on either side of it compete for the privilege of being called.

No model vendor — open or closed — should ever be load-bearing.

The path there is a graduation, not a leap. Start on a frontier API, because capability buys you the fastest proof. Instrument everything from day one — every trace, every resolution, every correction is future training data, so capture it as if it were revenue. Then, as the record compounds, graduate the high-volume paths onto your own weights, one workload at a time. This is the whole arc of these essays in a single motion: the descent commoditises the model, memory becomes the moat, the layer that carries the memory must be yours, and the collapsing cost of building makes all of it practical. The last step is simply to hold the thing that learns. Build the system that fits your organisation — and own the mind you are training to run it.