Own the weights

TL;DR

Open models have caught up where it counts. MIT licences mean you can fine-tune them on your own record and keep the result. The posture that wins: high-volume work on your own weights, a frontier API as a swappable subcontractor, and no vendor load-bearing.

For as long as this generation of AI has existed, sovereignty and capability pulled in opposite directions. Want the best model? Send your data to someone else's cloud and accept their terms, their roadmap, their price sheet. Want control? Run something open and accept that it is a generation behind. Every enterprise AI strategy of the past three years has been, under 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. Finishing multi-step tasks, calling tools correctly a thousand turns into a session, failing in ways an agent harness can catch. On the benchmarks that predict whether a system survives a real ticket queue, the best open models now sit beside 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 set up to benefit.

Licences before leaderboards

The licence matters more than the score. MIT means you can fine-tune the model, merge it, distil it, and deploy it commercially. 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 keep the artefact does not. Judging models by leaderboard position alone is reading the sticker price and ignoring the lease.

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. It is the point this series has been circling since the first essay. Your 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 way of working. The base model stays frozen and replaceable. The adapters are yours, trained on data that never left the building.

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 training cost by more than ninety percent. The serving stack is boring, documented, and speaks the same wire format your agent code already uses. Standing it up is a build week, not a moonshot. The hard part, as ever, is not 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 says 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 support queues, the document pipelines, the reconciliations. Plus the unpriced cost of the trap, the vendor you cannot exit and the data you cannot use. Priced that way, the crossover comes 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 with one line of configuration. You own the router, the memory, the tools and the adapters, the connective tissue. The models on either side 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 the fastest proof. Instrument everything from day one. Every trace, every resolution, every correction is future training data, so capture it like it is 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 one motion. The descent commoditises the model. Memory becomes the moat. The layer that carries the memory must be yours. The collapsing cost of building makes all of it practical. The last step is simply to hold the thing that learns.