Things Change. Own Your Weights.

I've learned the same lesson twice now, and I think I'm about to learn it a third time.

The first time was our member list. We ran the Global AI Community on a well-known meetup platform for seven years. It worked, until the platform's choices stopped matching ours. Prices changed, features changed, rules changed, and the most valuable thing a community has lived on someone else's terms. So we left and built our own place. Lesson one: own your data.

The second time was our website. We built it on Umbraco, a content management system I know well and have spoken about for years. In the beginning it sped us up enormously: a solid platform, a community around it, things we didn't have to build ourselves. Then the community grew, our needs became specific, and the same platform that had given us speed started taking it away. Every custom feature became a workaround, every upgrade became a project. So we moved to our own stack. Lesson two: own your platform, once the platform starts owning you.

Notice the pattern. Both tools were the right choice when we chose them. Both stopped being the right choice because things changed, and we only had a way out because we'd kept the ability to leave.

Now the same lesson is arriving one level deeper. Not your data, not your website. Your model.

What "open weights" actually means

Quick definition, because the words get used loosely. An AI model is, at its core, a huge set of numbers called weights, learned during training. An open-weight model is one where the company publishes those numbers. You can download them, run them on your own hardware, fine-tune them for your own needs, and nobody can take them back.

That is not the same as open source. Open source would also mean the training code and the training data, and almost no model gives you those. So "open weights" is the honest term, and it's the one I'll use.

Think of it as getting the finished engine, not the factory.

The pendulum

Here's the story I keep seeing, because I've lived every swing of it.

In 2008 I built my first travel site on a server I controlled. Then the cloud came, and we all moved up: more capability, less control, and that was mostly a good deal. Then AI arrived and we moved up again, to models behind an API (application programming interface, a service you call over the internet). The most capable AI in history, one HTTP request away, and once more we traded control for capability.

Each step was reasonable. But look at where it leaves you. The model that your product depends on can be deprecated, re-priced, or quietly changed, and your only option is to adapt. Your prompts, your evaluations, your tuning, all of it rests on something you don't own. I know this feeling. It's the meetup platform feeling and the Umbraco feeling, with a much more important dependency.

Open weights are the pendulum swinging back. Not all the way, and not for everything. But for the first time, the capability you need and the control you want are available in the same package.

Why this year is different

For a long time, open models were the budget option: fine for experiments, not for the real thing. That stopped being true. The gap between the best open models and the closed frontier has shrunk to a few months, and in some tasks it's gone. Teams are moving real workloads over, not out of idealism but because the same work costs a fraction and runs where they say it runs.

Two honest footnotes. First, the strongest open models of this year come mostly from Chinese labs, with a handful of serious US and European families alongside them: Llama, Mistral, Gemma, Phi, Nemotron, gpt-oss. If you only read Western AI news, this surprises you; if you look at where developers actually route their traffic, it doesn't. Second, "open" no longer means "runs on your laptop." The frontier-scale open models need real hardware or a hosting provider. Open weights give you the right to run it yourself. They don't make it free.

The rooms this is for

Here's the part that matters most to me, and it has nothing to do with enterprise procurement.

I've stood in a lot of rooms this year that will never have a frontier API budget. Students in Mukono. Chapter organizers in countries where a few hundred dollars of model calls is a real decision. Developers with unreliable connectivity, or data they are legally not allowed to send across a border. For all of them, a model they can download, run locally or regionally, and fine-tune in their own language is not a nice-to-have. It's the difference between building and watching.

Every argument I've made in this series about free events and widening the door applies here. Open weights are the model-level version of a free event: the same capability, available to the people who would otherwise be locked out. That alone would make me care about them, even if they were worse. They're not worse anymore.

What I actually do

I'm not a purist about this, and I don't think you should be either. In my own agent newsroom I hire the model for the role, and today that includes closed models where they're the best writer or thinker for the job.

The rule isn't "open only." The rule is: never depend on something you can't leave.

So this is what that looks like in practice. Build so you can swap a model without rebuilding the product. Keep your evaluations and prompts portable. Know at every moment what the open-weight fallback for each role would be, and test it occasionally, the way you'd test a backup. Read the license before you build on an open model, because two models that are both called "open" can carry very different rights. And for the roles where an open model is good enough, which is more roles every month, use it, own it, and stop paying rent.

I work at a company that both ships open-weight models and signed a public letter this summer against restricting them, so I'm not writing this against anyone. I'm writing it because I've been on the wrong side of "things change" twice already, with a member list and with a website. I'd rather not learn it a third time with a model.

The lesson, one level deeper

Own your data, because things change. That was lesson one. Own your platform before it owns you. That was lesson two.

Keep the ability to own your model. That's lesson three, and it's the same lesson. Both earlier times, the tool was right until it wasn't, and the only thing that saved us was that we could still leave. The model your product thinks with is now the dependency that's hardest to walk away from. Keep the keys.