Open Weight Models Are Chapter One. The Data Layer Is the Rest of the Book.

Key Takeaways

• Open weight models are stage one of a four-stage sequence: artifact, factory, connective tissue, governance. Software took 30 years. AI is moving faster.
• The objections to open weight models, on support, security, liability, and economics, all hit open source a decade ago. Every one lost to time.
• Weights are not source code. You cannot diff a tensor, so the training recipe carries the transparency.
• As models commoditize, the durable layer becomes the state underneath: memory, context, operational data. It was never a lab’s to open.

On July 24, Jensen Huang made the first post of his life on X. It wasn’t a product launch or a victory lap. It was a policy letter signed by 25 companies, doubling to 50 within a day, asking Washington not to restrict open weight AI models. Microsoft, Meta, IBM, a16z, and Hugging Face. The whole thing rests on a single analogy: open source became the foundation of modern software, so open models deserve the same run.

It’s easy to read this as a policy fight. Washington versus the labs, open versus closed. I read it as something older. I’ve spent 20 years in the layers underneath AI: supercomputing labs, the networking layer that shuttles tensors between GPUs, training platforms, and now the data layer. I recognized the analogy immediately, because I’ve watched it play out at every layer I’ve worked in. It isn’t rhetoric. It’s a pattern, and the pattern has an order.

That order is the argument of this post. The letter defends the first stage. The one that matters most for anyone building on AI right now is the stage nobody is writing letters about.

Where I’m Writing From

I should be honest about my vantage point. I started in performance modeling at EPFL’s Blue Brain Project, moved to market development, and spent the last stretch of my career in product marketing. I’m not the person who built these systems. I’m the person who spent 20 years explaining them to the people deciding whether to bet their work on them. And the objections I heard selling open infrastructure a decade ago were always the same four: who supports this, is it actually secure, who’s liable when it breaks, and the economics can’t possibly hold. Word for word, those are the objections aimed at open weight models today. I heard them in procurement reviews, not code reviews. Every one of them lost. Not to a better argument. To time.

Three weeks ago I joined PingCAP, the company behind TiDB, an open source distributed SQL database, which turned out to be a front row seat for exactly this fight.

The Thing the Letter Gets Right, and the Thing It Leaves Out

The letter treats openness as a position to defend. My experience says it’s something else: a sequence. It doesn’t arrive all at once, and it doesn’t arrive as an ideology. It moves through a technology stack in a predictable order, and software ran that entire sequence over about 30 years. AI is running it in front of us right now, faster, and in places out of order, but unmistakably.

The letter is a defense of stage one. I want to talk about the stages after it, because those are the ones I’ve actually lived.

The Four Stages of Openness

Each stage opens a different thing, and each has to land before the next makes sense. What follows next is my complete breakdown.

Stage One: The Artifact Opens

The thing itself becomes free to download and run. In software this was Linux and MySQL. In AI it’s Llama, Mistral, DeepSeek, Qwen, and now Moonshot’s Kimi K3, a 2.8 trillion parameter model whose full weights landed on July 27, 2026, the largest open weight model anyone has shipped.

I entered computing after this war was over. Every machine I touched at Blue Brain, and later at the Barcelona Supercomputing Center, ran open source. I never saw the argument about whether the artifact should be open, only the aftermath. That’s what a won argument looks like a few years on. Open weights are heading there.

Stage Two: The Factory Opens

Not just the output, but the means of producing it. In software this was GCC, LLVM, and the whole open toolchain. You could rebuild the thing from scratch. In AI it’s happening now: DeepSeek releasing its actual training infrastructure, and labs publishing genuine training recipes in their technical reports instead of vague gestures. I spent time at Determined AI, an open source training platform, so I watched this stage arrive early.

Stage Three: The Connective Tissue Opens

The protocols and interfaces that let independent pieces trust and extend each other. In software this was POSIX and the Kubernetes APIs: boring, invisible, and load-bearing. In AI it’s opening fast. Anthropic open sourced MCP while continuing to ship closed frontier models and declining to sign Huang’s letter, which tells you this is a per-layer decision rather than an identity. SpaceXAI published the Grok Build harness under Apache 2.0 in July, reasoning that publishing the code was the most direct way to earn trust in it. That release followed a privacy incident and rejects outside contributions, so call it source transparency rather than community governance. It still moves in the same direction.

This is the stage I know in my bones. At Mellanox, my work was pushing the RDMA stack directly into the deep learning frameworks: TensorFlow, PyTorch, PaddlePaddle, and Caffe. The goal was that a researcher doing distributed training wouldn’t have to meddle with low-level kernels and libraries. As long as you had a supported NIC and a supported GPU, it worked inside the framework you already used. A proprietary hardware company invested in opening the connective tissue because closed plumbing doesn’t get adopted, and unadopted plumbing is worthless no matter how fast it is. The descendants of that work now move the tensors inside every open model in Huang’s letter.

Stage Four: Governance Neutralizes

The artifact is open, the factory is open, the interfaces are open, and then stewardship moves to neutral ground. Neutral governance is what turns “interesting project” into “safe institutional default.” In software, the moment Kubernetes went to the CNCF is the moment enterprises stopped piloting and started standardizing. PingCAP donated TiKV to the CNCF in August 2018, and it graduated in September 2020 alongside Kubernetes, Prometheus, and Envoy. That lineage is why, years later, an enterprise architect will put an open project on the approved list without a second meeting.

For the model stack, this stage has barely begun. PyTorch sits under the Linux Foundation and vLLM has moved inside it. Early tremors, nothing more. Which is why the next few years are worth predicting. But first, the one layer where the opening isn’t theoretical, where it is already being forced in production by the hardest workload in AI. The layer that holds state.

What the Agent Builders Are Actually Using

Here’s the tell that convinced me this is a sequence and not wishful thinking: the labs making the open bet on models make the same bet everywhere below it. Kubernetes for orchestration. vLLM for serving. The whole stack built the same way, because every layer faces the same adoption physics I watched at Mellanox. At the state layer, the demands get specific.

Moonshot’s Kimi and Manus are two of the agent platforms the industry watched hardest this year, and both run production on TiDB. What they use it for gives the game away. Agents don’t behave like the applications databases were built for. They spin up databases at a scale and speed no human workflow ever demanded, thousands of them, created and retired on the fly. They need to checkpoint, to branch so one agent can try something without disturbing the others, and to keep long-running task state somewhere durable enough to survive a crash.

That is a genuinely hard problem, and it’s the one these companies came to us to solve. Working alongside them is how TiDB grew to hold vectors and agent memory right alongside operational and analytical data, in one place rather than a stitched-together stack. What Kimi and Manus worked out under real production load is what every company building agents is about to need.

Where the Analogy Breaks, and Where the Work Is

The caveats matter, and they point straight at where the real work still is.

Weights are not source code. You can read a C file and understand it. You cannot diff a tensor and know what changed or why. This is exactly why stage two, the factory, matters more in AI than the open binary ever did in software. In our world the recipe is the real transparency. The weights alone are closer to a free lunch than an open kitchen.

And this is the one that matters most. As any lab’s frontier becomes another lab’s baseline in a quarter, the durable, defensible layer stops being the model and becomes the state it sits on top of. The memory. The context. The operational and analytical data an agent reads, writes, branches, and has to be able to trust. That layer doesn’t commoditize, because it’s yours. Data is the last closed room in every factory, not because anyone is hoarding a corpus, but because the valuable data was never the lab’s to open. It’s the enterprise’s own.

That’s the room a database lives in. Not competing with the open models but underneath them, holding the state they need in one place instead of stitched across a vector store here and a warehouse there. My colleague Terry Purcell has made the case for why that layer has to be open source. That’s the bet TiDB is making, and after 20 years of watching this sequence, it finally looked obvious enough to go make myself.

So this isn’t a story about closed models dying. Huang’s letter is careful on this, and so am I: the world needs both. The claim is that the open layer becomes the foundation everyone else standardizes on top of, and the interesting engineering moves to the state layer underneath.

What I Think Happens Next

By the end of 2027, core infrastructure from the model stack, a serving layer, a training framework, or an agent protocol, lives under a neutral foundation with real multi-company governance. That is the Kubernetes-to-CNCF moment, and it is when enterprise adoption stops being pilots and starts being defaults.

Within 24 months, “open versus closed” stops being a company’s identity and becomes a per-layer, per-release decision. The same lab ships an open protocol, a closed frontier model, and an open serving stack in the same quarter, and nobody finds it contradictory, because by then everyone understands it was always a sequence, not a side.

And the first enterprise reference architecture for agents, the LAMP stack of this era, ships open at every layer, with a consolidated data and state layer at the bottom doing the load-bearing work and possibly a frontier model as the one closed component at the top. The acronym will be new. The shape will be familiar. I have an obvious bias about which distributed SQL database sits in that stack. I’ll only claim that the slot exists and that it’s open.

The question was never whether. The signatories to Huang’s letter are asking, in essence, that the sequence not be interrupted. In three decades it never once has been. It has only ever been led or followed.

Nobody asks whether databases should be open source anymore. Nobody will ask about models either. The interesting question was always the next one: what opens after that, and what you build on the layer underneath once it does.

The interesting work is at the layer underneath, and what it has to do is specific: one interface across vectors and structured rows, reads that stay fresh against each other, and compute that absorbs agent bursts. That’s the context platform pattern. Start there.