The Seed and the Farm: Why the Best Open AI Models Are Being Given Away

The Seed and the Farm: Why the Best Open AI Models Are Being Given Away

In July 2026, four things happened within two weeks. They look like four separate news stories. They are one.

On 16 July, the Beijing lab Moonshot AI unveiled Kimi K3 – 2.8 trillion parameters – and eleven days later the weights were a public download. On Moonshot's own evaluation it scores 93.5 on GPQA Diamond, against 92.6 for Claude Fable 5 and 94.1 for GPT‑5.6. Vendor numbers always deserve scepticism. But the order of magnitude isn't in dispute: the gap between the best closed model and the best freely downloadable one has shrunk to a rounding error.

On 24 July, Nvidia CEO Jensen Huang published the first social media post of his life – an open letter titled “Open Weights and American AI Leadership”. Twenty-five organisations had signed it, among them Microsoft, Meta, IBM, Dell, Mistral, Hugging Face, Mozilla and the Linux Foundation. Not signing: OpenAI, Anthropic and Google.

Two days earlier it had emerged that those same labs were warning Washington about the security risks of cheap, powerful Chinese models.

And on 27 July, ASML shares fell roughly five to seven percent after a state-backed Chinese consortium announced it had begun mass-producing its own lithography machines.

Four headlines, one question: if a model costs hundreds of millions to build, why give it away? And behind it, the question that matters to any company currently wiring AI into its operations: does this change anything about my dependencies?

First, the words: a bakery with three counters

“Open source” and “open weight” get used interchangeably almost everywhere. They do not mean the same thing, and the difference is precisely what Washington is arguing about.

Picture a bakery.

At the first counter you buy a finished pastry. You can enjoy it. You cannot duplicate it, change it, or bake another one – you don't have the recipe. That is a closed model: the provider keeps everything behind an interface and controls the version, the behaviour, the safety rules and the price. You rent access, billed by the token. Every frontier model has been sold this way for one simple reason – they are staggeringly expensive to make, and selling the finished product is how you recoup that.

At the second counter you get the dough. You can take it home, top it, shape it, build it into your own product – without asking anyone's permission. You still don't get the recipe. That is an open-weight model. The “weights” are the trained numerical values that fully determine how a language model behaves; they are the actual output of a training run. Whoever holds them can run the model on their own hardware.

At the third counter, someone is handing out the recipes. All of them. Every variant, every intermediate step. That would be genuine open source: not just the weights but the training data, the training code, the entire path of manufacture – so that anyone could rebuild the model from scratch. It is rare, closer to a research artefact than a product, and at the frontier it simply does not exist.

What the Chinese labs are releasing is the second counter. They are giving away the dough, not the recipe.

The difference in a table:

Who this actually affects – and who it doesn't

The honest answer first: nothing changes for ordinary users. If you use a chat assistant for research, drafting or summarising, none of this touches you. Open weight is not a consumer topic.

Three groups it does affect, directly.

First, companies with data that cannot leave the building. Healthcare, finance, legal – but equally any mid-sized manufacturer with design files, costings or personnel records. With an open-weight model, processing happens entirely inside your own infrastructure. That is not a legal manoeuvre or a contract clause, it is a structural property: the data physically goes nowhere. In the conversations we have with managing directors, this is by far the most important point – more important than any benchmark.

Second, startups and small software businesses. If you are building a product where a language model works on every user click, you pay the model cost out of your margin. In a prototype that's a rounding error. At real volume it decides the business model.

Third – and this surprises most people – the infrastructure layer. Cloud providers and chipmakers. Because a model you download does not run by itself. It needs GPUs, memory, power, networking.

Which brings us to why Nvidia, of all companies, is campaigning so loudly for open models.

Why Nvidia is in favour

Nvidia does not care who has the best model. That isn't a jab, it's the business logic. Whether a company buys a closed model through an API or runs an open one itself, the computation happens on chips – and in both cases they are mostly Nvidia chips. Open models arguably grow the market, because they push compute out of a handful of providers' data centres and into thousands of corporate environments.

Huang's argument in the letter is broader than his own business, though, and it deserves to be taken seriously: open models get safer through wider scrutiny, accelerate innovation, and strengthen national technological sovereignty. He explicitly warned Washington against repeating the mistake the software industry nearly made with open source in the 1980s.

What happened next is the telling part: OpenAI signed the letter after the fact. The coalition grew to roughly 35 companies. Anthropic remained the only major lab outside it – arguing that published weights can never be recalled: you cannot revoke access, you cannot retrofit safety guardrails, you cannot stop misuse. At the same time, nearly 200 startups warned Washington about the opposite risk – that banning Chinese open-weight models would effectively hand the American AI stack to two providers.

That is the real front line: not China versus the US, but concentration versus distribution.

The seed and the farm

Which leaves the question that carries everything. If anyone can download the weights, how does DeepSeek make money?

Think of the weights as seed.

Giving away seed means giving away the instructions for growing the crop. Anyone in the world can plant it. But owning seed and owning a harvest are two completely different things. The seed does not give you the land, the water, the fertiliser, the greenhouse, or the labour it takes every single day.

The same is true of a language model. Owning one is trivial – it's a download. Running one at scale, reliably and cheaply takes GPUs, power, data centres, engineers, and above all the accumulated skill of squeezing maximum compute out of every dollar.

The intellectual property becomes a sunk cost the moment training finishes. Giving it away costs nothing marginal. What gets monetised is the industrial capacity to turn that intellectual property into millions of requests per second – more cheaply than anyone else.

Put bluntly: every lab selling API access is running a manufacturing business. The product is generated text. The unit cost is compute. The margin is the gap between the two. And the whole economics collapses into a single question: who can produce the same output for less?

Please don't read that table as a quality judgement. It shows one thing only: the ends are about ninety times apart. In a prototype that is irrelevant. In a product with real usage volume it is the difference between a contribution margin and a subsidy.

Why the architecture makes the difference

Where does that spread come from? To a large extent, from a design decision made before training began.

Picture a call centre where every incoming call – however simple – is routed to every single person in the room. From the intern to the head of department, everyone looks at the question, thinks about it, and only then does one of them answer. Obviously wasteful. But that is how a so-called dense model works: every request activates the entire model.

The alternative is called mixture of experts: a router that looks at the question first and sends it to the two or three specialists who can answer it. The rest of the floor stays idle – and idle costs nothing. DeepSeek‑V3, for instance, has 671 billion parameters, of which only about 37 billion are active per request. Kimi K3 pushes the same principle to 2.8 trillion total parameters.

The consequence shows up in the cost sheet. Training DeepSeek‑V3 cost, by the lab's own account, roughly $5.6 million in compute – 2.788 million GPU hours. Estimates for GPT‑4 run from $50 million to well over $100 million.

Two caveats, for completeness, that the public discussion routinely drops.

First, the $5.6 million figure is the compute of the final training run – not research, not failed attempts, not hardware, not salaries. It is real and it is impressive, but it is not the price of running a frontier lab.

Second, the popular story that “the Americans build dense, the Chinese build lean” doesn't hold up. Mixture of experts is not a Chinese invention and is used by Western labs too; with GPT‑4 it is widely assumed. And whether any given closed model is dense or a mixture of experts is, for most providers, simply not known – the architecture is not published. Anyone telling you that model X is built dense for safety reasons is telling a plausible story, not a documented fact.

What survives is the durable part: architecture and efficiency decisions determine unit cost, and unit cost determines whether you can afford to give the weights away.

Why there's no real advantage left in staying closed

Back to the seed and the farm. DeepSeek's defensibility never came from the seed. It came from the farm – from being able to run the cheapest production in the world. And if a competitor cannot undercut your unit cost, it doesn't hurt you that they hold the recipe.

The reverse holds too: even a fully closed lab cannot stop its capabilities leaking into the world. Weights can be stolen, and that isn't hypothetical. But it doesn't even require theft. You can query a closed API systematically and use its outputs as training material for your own model – a process called distillation that transfers a large share of the core capability without ever seeing the weights.

Put differently: the weights are a weapon you cannot keep anyway. The moat is elsewhere – in operations, in integration, in data, in trust.

What this means for your company

You don't run an AI lab. But you are making – perhaps without calling it that – an architectural decision you will either be glad about or annoyed by in two years. Five things follow.

• Separate the model from the application. The expensive mistake isn't picking the wrong model, it's building an application married to one. Put a thin layer in between, keep prompts and evaluations in one place, and switching becomes a configuration change rather than a project. The market is currently moving on a monthly cadence – the ability to switch is the only bet you win for sure.
• Work the data case first, not the benchmark. If a class of data cannot leave your infrastructure, that is not a question of model quality but a precondition. Here – and almost only here – a self-hosted open-weight model isn't the cheaper option, it's the only one.
• Running it yourself means running it. The download is free; the farm is not. GPUs, latency, failover, monitoring, updates, someone reachable at night. For many use cases the honest answer is still: buy the API. Do the arithmetic rather than assuming it – and compare total cost of ownership, not model prices.
• At real volume, margin is the argument. As long as you're thinking in prototypes, token prices are noise. The moment a model works on every customer click, it moves out of the IT budget and into the contribution margin. That is when it pays to use the smallest sufficient model per task instead of the strongest everywhere.
• Availability can be political. Export rules, licence terms, model versions switched off overnight: none of these risks appear in the classic vendor assessment, which looks at insolvency, outages and price rises. We've written about the same pattern at greater length via the chip supply chain and Europe's concentration risk.

Notice where the useful target sits: not at self-sufficiency, which is neither reachable nor desirable, but at the ability to switch without stopping. That is a question of architecture – and therefore a decision you get right in a few days or correct expensively in a few years.

Where we stand

At balane we build software for mid-sized companies – we advise, we develop, we automate, and we look at every project through three lenses at once: commercial, psychological and technical.

The commercial lens doesn't ask “which model is best” but “where do unit costs arise, where does dependency arise, and which task justifies which class of model”. The technical lens builds the second door before you need it: a swappable integration, so a forced switch stays a configuration change rather than becoming a crisis. And the psychological lens is the one most often forgotten – because AI rarely fails on technology in a mid-sized company. It fails because nobody trusts the output, because ownership is unclear, or because the colleague who actually understands the process was never asked.

None of this is a call to replace anything in a hurry. It is the opposite: the sober observation that beneath the noise of the headlines lies a very old question – who owns the part of your value chain that you don't control yourself?