The Open Source AI Economy

Share

I’ve spent the past month going deep on open source. It started as background reading - the open-versus-closed question keeps surfacing in portfolio conversations, in the DeepSeek aftermath, in almost every debate about where value settles in AI - and it turned into a proper research project. I went back to the canonical economics paper, Lerner and Tirole’s The Simple Economics of Open Source, written in 2000 when the whole phenomenon still baffled the profession (Tirole went on to win the Nobel Prize). I read Bill Gurley’s recent essay on open source as corporate strategy, a Nature paper arguing that most “open” AI isn’t open at all, and the company histories in between. This piece is my attempt to pull it all together - and, as always, to explain it as simply as I can.

Here’s the fact that hooked me: the most valuable infrastructure on earth is free. All 500 of the world’s fastest supercomputers run Linux, an operating system you can download, inspect and modify without paying anyone a penny. So do more than 90% of cloud workloads - which means most of the modern economy, your bank, your airline, the app you ordered lunch on, runs on software nobody owns. Android, which powers seven in ten of the world’s smartphones, is built on the same free kernel.By one recent Harvard estimate, if open source vanished tomorrow and every company had to rebuild the free software it currently relies on, the collective bill would run to $8.8 trillion.

None of this was an intentional byproduct of open source. Open source began as something between an academic habit and a political movement - programmers giving their work away, for reasons that baffled economists and amused Microsoft. It went on to beat the best-funded software companies in history at their own game, then became the substrate those same companies build on. Microsoft, whose CEO once called Linux “a cancer,” is today one of the largest contributors to open source in the world.

And it’s no longer just a software story. The same experiment is now running again, at far higher stakes, in AI. The most consequential fight in technology today is whether the intelligence layer of the economy ends up closed and owned - by OpenAI, Anthropic and Google - or open and commoditised, the way Linux commoditised the operating system. Billions of dollars, and a meaningful piece of national sovereignty, hinge on the answer.

So this piece is my way of putting a month of research down on paper. It covers what open source actually is, how it won, the economics that power it - what this looks like for the AI era and the potential implications that follow.

Start from first principles, what actually is open source?

Every piece of software - Excel, WhatsApp, the systems running your bank - is a set of instructions telling a computer what to do. Programmers write those instructions as ordinary, readable text, in languages built for the purpose, and this human-readable version is called source code. Before the software reaches you, the source code is converted into machine code - the stream of ones and zeros a processor actually executes. The difference matters because the two versions serve different audiences: humans can read, understand and change source code; machine code is effectively unreadable, even to professionals.

That leads to the single most important point in this piece: whoever holds the source code controls the software. With the source code, you can see exactly what a program does, verify it, fix it, change it, and build on top of it. Without it, you can do precisely one thing - run the program as supplied, and trust that it does what the vendor says. Every question about open source comes back to this: who gets to see and change the instructions?

For most of the industry’s history, the answer was: nobody but the vendor. When you buy Microsoft Office, you aren’t buying the software - you’re buying permission to use it. The source code stays a trade secret, as closely guarded as a pharmaceutical formula. This is proprietary software, and keeping the instructions secret is the foundation of the business model: it’s what makes the product something that can be sold rather than copied. It built some of the most profitable companies ever created.

Open source is the opposite arrangement: the source code is published. Anyone can read it, run it for any purpose, modify it, and share their modifications with the world. And, crucially, this is a legal arrangement, not an informal one - what makes software open source is its licence, the contract attached to the code granting those freedoms permanently. Note what open source is not about: price. Plenty of software is free to use but completely closed - Instagram costs nothing, and you’ll never see a line of its code. Open source is about access to the instructions. The fact that it usually also costs nothing is just a consequence.

The licences come in two modalities. Copyleft licences — the most famous being the GPL - carry a share-alike condition: build on this code and your version must be open on the same terms. Permissive licences - MIT, Apache - ask essentially nothing: take the code, embed it in a commercial product, sell it, share nothing back. The steady shift from the first modality to the second is a big part of how open source went from movement to diffusion into industry.

The final piece is how the software actually gets built. There’s no single company behind an open source project. Contributions come from thousands of programmers scattered across firms and countries, and a small group of maintainers decides what gets accepted into the official version. Naturally, this sounds very messy and counterintuitive. In practice it produced the most reliable software humanity has shipped, for a reason the developer Eric Raymond compressed into one line: given enough eyeballs, all bugs are shallow. An error that survives for years inside a fifty-person team gets found in days when ten thousand people can read the code.

That's open source, defined: the code is published, a licence guarantees the freedoms, and no single company owns the result. On paper, it shouldn't have stood a chance against competitors with billion-dollar R&D budgets and armies of salespeople. Instead it won - and the story of how begins in the 1960s, inside the research arm of a telephone monopoly.

The most important thing to understand about this history is that the sharing came first. For computing's first few decades, giving code away wasn't a movement or an ideology - it was simply how the industry worked. Ownership was the innovation, arriving in the early 1980s, and open source was the reaction to it. That reaction spread through the entire industry - and went on to produce some of the most successful software companies of our time.

The commons (1960s–1983). For computing’s first decades, software wasn’t a product — it shipped bundled with hardware, and the important code came out of research settings: Berkeley, MIT, and above all Bell Labs (‘The Idea Factory’ is an amazing book on Bell Labs btw). Bell Labs was the research arm of AT&T, America’s telephone monopoly, and probably the most productive research institution of the twentieth century — the transistor, the laser, information theory and nine Nobel Prizes all came out of it. In 1969, two of its researchers, Ken Thompson and Dennis Ritchie, built Unix, the operating system whose descendants now run everything from iPhones to the cloud. AT&T, though, was in an unusual position: under a 1956 antitrust settlement, it was barred from selling anything outside telephony. It had built the world's most important software and legally couldn't turn it into a business — so it licensed Unix to universities for a nominal fee, source code included. Academics improved it and shared the improvements back, and when Usenet connected the community in 1979, the sharing accelerated fast - from 3 sites to 400 in three years.

The turn (1976–1983). Bill Gates saw the future earliest, writing in his 1976 Open Letter to Hobbyists: “Who can afford to do professional work for nothing?” Software was becoming a product in its own right - and when AT&T was broken up in 1984, the constraint that kept Unix free went with it. AT&T began enforcing its intellectual property over code it had spent a decade giving away. Sharing, the profession’s standard practice, was now classified as theft.

The formalisation (1983–1991). The response came from Richard Stallman, an MIT programmer who launched the GNU project in 1983 to rebuild everything Unix did, from scratch, as free software - so no company could ever lock it up again. His most important invention wasn't code but a legal document: the General Public License (GPL). Anyone could use, modify and share GPL code, on one condition — anything built with it had to be released on the same terms. That single clause did the work: code published under the GPL stayed open permanently, no matter who picked it up or what they built with it.

By 1991 GNU had built nearly everything except the kernel - the core component that controls the machine, and the hardest piece to write. Then Linus Torvalds, a 21-year-old student in Helsinki, posted one to an internet newsgroup: “just a hobby, won’t be big and professional like gnu.” His kernel - Linux - completed the free operating system, just as the internet reached universities worldwide and gave it thousands of contributors who’d never met.

The commercialisation (1991–2001). Through the 1990s the movement shifted from ideologues to pragmatists - people who cared less about the ethics of sharing than the fact that this model kept shipping better software. Apache, started in 1994 by a 21-year-old collecting patches for an abandoned university project, ran most of the early web; Sendmail routed most of its email. In 1998 the pragmatists rebranded “free software” as “open source” and embraced permissive licences that let companies build proprietary products on open foundations - deliberately making the movement safe for business. Business responded. Red Hat, which sold support around Linux rather than the software itself, went public in 1999 and tripled on day one; VA Linux rose nearly 700%, then the largest first-day gain in Wall Street history; IBM committed $1 billion to Linux. Microsoft, with the most to lose, said what it thought. “Linux is a cancer,” said Steve Ballmer in 2001.

The surrender (2001–today). Linux won the server market, then became the default operating system of the cloud. Firefox - rebuilt from Netscape's open-sourced code - broke Internet Explorer's grip on the browser. WordPress, an open source publishing tool, grew to power over 40% of the world's websites. In 2008, MySQL, the open source database, sold to Sun for $1 billion - the first proof that a company giving its product away could command a serious price. Google built Android on the Linux kernel and gave it away to stop Apple owning mobile - open source as a competitive weapon. Docker and Kubernetes, both open source, became the building blocks of modern cloud infrastructure, and a generation of open source companies went public on the back of it: MongoDB, Elastic, GitLab, Confluent. Then the old guard folded, one by one. Apple rebuilt its operating systems on open source foundations. Microsoft's new CEO, Satya Nadella, stood in front of a slide reading "Microsoft ♥ Linux" in 2014, bought GitHub - the home of the world's code - for $7.5 billion in 2018, and today ships Windows with a Linux kernel inside it. And in 2019, IBM paid $34 billion for Red Hat: one of the largest software acquisitions in history, for a company whose product is free to download.

That’s a short history on the arc of open source. In 1976, Bill Gates asked who could afford to do professional work for nothing. Fifty years later, Microsoft paid $7.5 billion for the home of that work, IBM paid $34 billion for a company whose product costs nothing to download, and the software written "for nothing" runs the world's infrastructure. The history shows that it happened. It doesn't explain why — why thousands of the world's best engineers gave their work away, and how giving software away became a route to a multi-billion-dollar business.

On paper, open source shouldn’t function as economics at all. The product has no price. The producers don’t get paid. Anything built can be copied freely by anyone, including competitors. Every incentive that classical economics says a market needs is missing - and yet this arrangement out-built the best-funded software companies in history, and then produced multi-billion-dollar companies of its own. That paradox splits into two questions, and they structure this section. First, the supply side: why would thousands of the world’s best engineers work for free? Second, the business side: what exactly do you sell when your product can be downloaded for nothing? Both have rational answers - and both answers become essential later, because they’re the same two questions now hanging over open source AI.

Take the supply side first. The answer isn’t altruism - the biggest beneficiaries of free code were Fortune 500 companies, and programmers are no more charitable than anyone else. It’s self-interest, in three primary forms.

The first is own use. Most contributors weren’t volunteering in any meaningful sense - they were fixing their own problems. Behlendorf started what became Apache because he needed a working web server for Wired‘s website; the patches he shared were patches he’d written anyway. Sharing them cost nothing and meant others maintained them with him. Multiply that logic across thousands of engineers with the same problem, and you get world-class infrastructure as a side effect of self-interest.

The second is reputation. Code in the open is a public record of how good you are. Lerner and Tirole called this “career concerns”: every accepted contribution to a serious project is a costly, verifiable signal of skill - a CV that can’t be faked, visible to every future employer and investor. Open source contribution became one of the highest-return career investments an engineer could make. The labour was never free; it acted as deferred compensation.

The third arrived later: distribution. This is the one that turned a development model into an industry, and it’s the one I find most interesting as an investor, because distribution is the hardest and most expensive problem in software. Proprietary software is sold top-down - salespeople, procurement, pilots, an eighteen-month enterprise cycle. Open source spreads bottom-up: a developer downloads it, likes it, builds something on it, and by the time a commercial conversation starts, the software is already running inside the company. The sales cycle didn’t get shorter. It got inverted. Adoption first, monetisation second - the cheapest customer acquisition model software has ever produced.

That still leaves the question - what exactly do you charge for? The answer evolved through three generations of business model, each a building block on the last.

Generation one: sell the reliability, not the recipe. Red Hat’s insight was that enterprises don’t actually want free software - they want software that works, is certified, and is supported round the clock 24/7. The code was free; the dependability cost money. That model built Red Hat, the company IBM bought for $34 billion.

Generation two: open core. Give away the base product, charge for the enterprise features — security, admin tools, integrations. It worked until the cloud providers found the flaw: if the core is open, nothing stops AWS taking your code, hosting it as a managed service, and selling it to your customers with none of your development costs. Amazon did precisely this to MongoDB and Elastic - prompting a wave of defensive licence changes and a genuinely hard question about who open source is for. The lesson was Gurley’s law of commoditised stacks: when software becomes free, the value doesn’t disappear - it moves to whoever operates it at scale.

Generation three: the answer to AWS - open source as funnel, cloud service as product. MongoDB’s Atlas, Databricks, Confluent: the open code drives adoption by millions of developers, and the company monetises the hosted, managed version - which it runs better than anyone else because it wrote the software. Open source stopped being the product and became the go-to-market. On this model, some of the most valuable software companies in the world have been built: Databricks was last valued north of $200 billion, and MongoDB trades publicly at a similar order of magnitude to the entire valuation of the proprietary databases it displaced.

There’s one more business model, and it’s the most consequential: not making money on open source, but with it. Google didn’t open-source Android to sell it - it gave the operating system away to stop Apple owning mobile, protecting the search business that actually pays. It open-sourced Kubernetes to neutralise AWS’s grip on the cloud. Meta published its data-centre hardware designs to crush its suppliers’ margins. In each case a company identified something expensive that sat next to its profit pool, and made it free. It's exactly the play now being run in AI.

The scale of what this produced is best captured by three numbers. Around 96% of all commercial codebases now contain open source components. A recent Harvard study estimated that building the world’s core open source software cost roughly $4 billion in engineering effort - but that if it vanished and every firm had to rebuild what it uses in-house, the bill would run to $8.8 trillion, roughly two thousand times more. And firms would spend three and a half times more on software than they currently do. Code written once, by people with rational reasons to share it, now does the work of trillions of dollars of duplicated effort. That is the economic engine of open source.

The same playbook - publish the code, win on distribution, commoditise the layer below - is now being run on artificial intelligence. But there’s a problem: every part of that playbook assumes the thing being shared costs almost nothing to produce. Whereas, a frontier AI model costs hundreds of millions of dollars to train. What “open” even means at that price is the next question.

In AI, “open source” has become the most contested term in the industry. Meta calls Llama open source. Every DeepSeek headline uses the phrase. Mistral built its brand on it. Almost none of it is open source in the sense this article has used the term so far - and the difference comes down to what a model actually is.

Open source software gives you the source code: the instructions, readable line by line, which you can modify and rebuild yourself. A model doesn’t have the same equivalent. What gets released, the weights, is a single enormous file of numbers, billions of learned parameters produced by the training run. Nobody wrote them. Nobody can read them. And they’re only the output. Producing them took three inputs that stay behind closed doors: the training data, the training code and methods, and months of compute costing hundreds of millions of dollars. So download Llama and you get a finished artefact. You can host it on your own hardware, adjust its behaviour, build products on it. What you can’t do is see inside it, or recreate it.

The accurate term ascribed to this is open-weight, not open source, which is the key differential between software and AI. You can’t inspect the model. The training data is undisclosed, so whatever is baked in - bias, copyrighted material, safety gaps - stays invisible, and a trillion opaque numbers can’t be audited by reading them. Linus’s law has nothing to look at. You can’t reproduce it. Without the data and the code there is no way to rebuild the model and verify it, and even with both, the compute bill would be prohibitive. And you can’t fork it in any real sense. Fine-tuning adjusts surface behaviour; nobody can take Llama in a fundamentally new direction the way Berkeley took Unix. Put simply: in open source software, the community could do everything the original author could. In open-weight AI, that’s not the case.

The industry has a word for this: openwashing. Look at Llama’s licence. It restricts what you can build, bans certain uses outright, and requires any company above 700 million monthly users to negotiate commercial terms with Meta. That fails the Open Source Definition on several counts. It also tells you the real logic of the release. Meta is not donating Llama to the commons. It is running the Android playbook: give the platform away, become the standard, let the ecosystem’s work compound your position. Every fine-tune is free product development. Every developer who learns the stack deepens the moat. And note what a weights release never touches - the actual chokepoints in AI. The compute sits with Nvidia, whose CUDA platform has four million developers locked in. The data sits with the platforms. Open weights spread usage. The power stays exactly where it was.

Then there’s the question of who is actually releasing open models, because the answer has inverted. Genuinely open projects exist - AI2’s OLMo publishes the weights, the data, the code and the training logs - but they trail the frontier by and order of magnitude. The serious open-weight frontier is Chinese. In January 2025, DeepSeek, a Hangzhou lab spun out of a hedge fund, released R1: a reasoning model competitive with OpenAI’s best, open weights, trained for a claimed few million dollars. Nvidia fell $589 billion in a day - still the largest single-day loss in market history. Alibaba’s Qwen is now the most downloaded and most fine-tuned model family in the world. Meta, meanwhile, spent 2025 becoming more guarded about releasing its best work. Nobody would have predicted this picture five years ago: American labs defending their models the way 1990s Microsoft defended Windows, and Chinese labs running the 1990s playbook against them.

None of this has slowed adoption, and the reason is simple: enterprises don’t buy definitions. A capable model you can download, run on your own hardware, tune on your own data and pay nobody for is a valuable asset, whatever you call it. The people debating what “open” ought to mean and the people choosing models are having two different conversations. The buyer’s question is narrower: does it work, and what does it cost?

Roughly two-thirds of newly released foundation models are now open-weight, and Hugging Face - the GitHub of models - hosts well over a million of them, most derived from a handful of open bases. Llama has been downloaded more than a billion times; Alibaba’s Qwen counts hundreds of millions of downloads and over 100,000 derivative models, the largest family of fine-tunes in the world. The capability gap has collapsed too: the best open-weight models trailed the closed frontier by roughly a year in 2024 - DeepSeek cut that to months, and on some benchmarks weeks. And serious capital has followed. Mistral, Europe’s open champion, was last valued around $23 billion. Reflection AI raised $2 billion in late 2025 — explicitly to build an American open-weight frontier lab, the West’s answer to DeepSeek. And a picks-and-shovels layer has formed around serving open models — Together AI ($8.3 billion), Fireworks ($15 billion), Hugging Face itself ($4.5 billion) — the beginnings of the Red Hat generation for AI.

Which raises the obvious question: why do enterprises keep wanting to choose open models, when the most capable closed ones are an API call away?

Here’s the part the openwashing critique misses. Whatever the philosophical shortcomings of open-weight AI, enterprises are adopting it at pace - with clear, pre-defined reasons. Nobody in a procurement meeting cares whether Llama meets the Open Source Definition. They care about cost, control and risk. On all three, the case for open models has strengthened materially over the past two years, and I see the shift directly across our own portfolio too: companies that started on frontier APIs are re-routing a growing share of their workloads onto open-weight models, and only using the frontier for more complex tasks. Five forces are driving it.

The first is trust - and it’s the one Alex Karp spoke about recently. The Palantir CEO’s recent argument, is that enterprises fundamentally do not trust the large model providers. Some of that is data anxiety: your prompts, workflows and proprietary knowledge flowing through someone else’s servers. But the articulated version is competitive. The frontier labs are no longer just model suppliers — they are moving up the stack into applications, selling legal tools, coding agents and enterprise products of their own. As covered in my dissection of the Exponential View report, this is rational for the labs: as raw model pricing commoditises, they must defend margin by owning the application layer. But it puts their customers in an awkward position. The company you’re handing your data and workflows to is also, increasingly, your potential competitor. An open-weight model running on your own infrastructure carries no such conflict.

Alex Karp interview here: Alex Karp CNBC Interview

The second is data sovereignty. An open model can run inside your own cloud environment, or on your own hardware, with nothing leaving the building. For banks, insurers, healthcare systems, defence contractors and governments, this isn’t a preference - it’s frequently a regulatory requirement. It also scales up to the national level: most countries will never build a frontier lab, but any country can download Qwen or Llama and run it on sovereign infrastructure. For the majority of the world, open weights aren’t the alternative to frontier AI. They’re the only form of frontier-adjacent AI that doesn’t arrive with a foreign dependency attached.

The third is cost - and regular readers will recognise this argument. As I laid out in the token efficiency piece, the economics of frontier AI at scale are alarming: agentic workloads consume two to three orders of magnitude more tokens than chat, and the difference between a well-routed workload and an inefficient one is roughly ten times the monthly bill. Open and small models are the core of that routing discipline. A distilled open model can handle routine tasks - classification, extraction, summarisation, tier-one support - at somewhere between one-tenth and one-hundredth of frontier cost, at quality levels the task genuinely doesn’t distinguish. The frontier model earns its premium on the hard 10% of the workload. Paying frontier prices for the routine 90% is simply margin leakage. ‘Intelligence per watt’ is a term that I frequently think about, and I think this term will become the equivalent of ‘NRR’ or ‘GRR’ from the software era.

The fourth is permanence. A closed model is a service that can change underneath you — deprecated versions, altered behaviour, price rises, new terms. Enterprises have already lived through model deprecations that broke production systems. Weights you have downloaded are yours indefinitely: the same model, the same behaviour, for as long as you choose to run it. For any large enterprise, that stability has real value.

The fifth is the lock-in hedge. Building your operations on a single closed provider recreates the platform dependence every CIO spent two decades learning to avoid. The data here is telling: among developers on OpenRouter, who actively route between models on cost and quality, the combined token share of Google, OpenAI and Anthropic fell from 72% to 33% in a year — open-weight alternatives absorbing everything that doesn’t demand the absolute frontier. That’s the sophisticated edge of the market, and where it leads, enterprise procurement tends to follow.

Three honest caveats for open source AI adoption:

1. The first is capability - and right now it's the biggest. Running open models well is an engineering discipline most companies don't have. A closed API abstracts everything away: one endpoint, no infrastructure, no ML team required. Running Llama or Qwen yourself means standing up inference infrastructure, managing GPUs, fine-tuning, building evaluation and guardrails, monitoring drift — the work of a specialist team that, outside the largest enterprises, mostly doesn't exist. When a company pays OpenAI's premium, a large part of what it's buying isn't the model — it's the absence of all that work. This is a familiar gap, though, and history shows how it closes: enterprises didn't adopt Linux because they hired kernel engineers; they adopted it because Red Hat packaged the complexity away. The same layer is now being built for open source AI.

2. The second is dependence. Open models don't remove it entirely - they still run on Nvidia silicon, usually rented from the same hyperscalers, and even Mistral reaches most of its customers through Microsoft's cloud.

3. The third is the frontier itself. The most capable models in the world remain proprietary, and for genuinely hard tasks there is often no open substitute. Which is why the realistic enterprise end-state isn't open or closed - it's a portfolio: closed frontier models for the work that justifies the premium, open models for the volume, and a maturing tooling layer steadily lowering the bar for the second.

Structurally, this is the same settlement software reached thirty years ago - proprietary at the frontier, open everywhere else, with the open share increasing as capability diffuses. Which sets up the question on most experts minds: Where AI is heading? Is open the direction of travel - and what would it actually take for open to win?

Bill Gurley made the point well in a recent essay: for everyone in the AI economy not named OpenAI, Anthropic or Google, commoditising the model layer is simply rational. Meta open-sourced Llama for the same reason Google open-sourced Android - not generosity, but to stop a rival owning a layer it depends on. Nvidia sells compute whichever model wins, so cheap abundant models mean more inference, not less. Enterprises want intelligence as a cheap input, not a supplier’s profit pool. And most of the world’s governments would rather run sovereign models than rent American ones. That is a very large coalition whose interests all point the same way. When many players face a dominant incumbent, backing an open alternative is the classic collective move - it’s how Linux beat proprietary Unix, and how Kubernetes contained AWS.

The pricing data tells the same story. A frontier lab’s pricing power is real but perishable - it lasts exactly as long as its capability lead. The moment an open-weight model matches a given level of performance, the price of that performance collapses toward the cost of serving it. Last year’s frontier is this year’s commodity. You can watch the repricing happen live on OpenRouter, where developers route between models on price and quality: the closed labs’ share of tokens fell from 72% to 33% in a year. That is what commoditisation from below looks like. Everything beneath the frontier trends open, and the frontier sinks into that zone with every release cycle.

So the incentives all point one direction, and the pricing mechanism is already working. Historically, that combination wins. But before calling it, apply a harder test. Open source software didn’t beat proprietary software because it was cheaper, or because corporations sponsored it. It won because the ecosystem became self-sustaining - it funded itself, governed itself, and improved itself, with no single sponsor able to switch it off. Hold open-weight AI to that standard, and four pieces are missing in the framework:

1. A unit of contribution. Anyone could patch Linux: find a bug, fix it, submit it, and the fix ships to everyone. That granularity is what let ten thousand strangers build an operating system together. There is no equivalent for a model. You cannot patch weights — there is no way to locate “the bug” among a trillion entangled parameters, no way to edit one behaviour without disturbing others, and no way to merge two people’s improvements the way git merges code. Changing what a model does means retraining it, which puts you back at the data and compute you don’t have. The community fine-tunes, distils and merges at enormous scale, but these are downstream adaptations, not upstream improvements. The base model improves only when its owner retrains it. Until contribution mechanics exist at the model layer, “community-developed AI” is a slogan.

2. Neutral governance. Linux belongs to no one; the Linux Foundation exists specifically so that no single company can capture it. Open-weight AI has nothing comparable — efforts exist, from the AI Alliance to the OSI’s attempt at an open-source-AI definition, but none of them governs anything at the frontier. Llama is open at Meta’s discretion, DeepSeek and Qwen at the pleasure of labs operating under Beijing’s oversight. Released weights can’t be un-released — but the next version can simply stop coming, and in Meta’s case, through 2025, it largely did. An ecosystem whose upstream depends on one sponsor’s continued strategic interest is not open the way Linux is open. It is conditionally open, and conditions change.

3. A funding engine. This is the deepest gap. Open source software never needed a central pot of capital - its contributors were salaried by hundreds of different employers, each funding a sliver of the work for its own reasons, and no single defection mattered. Open-weight AI inverts that structure entirely. A frontier training run is one indivisible, nine-figure bill that a single sponsor must choose to pay - and pay again every cycle, because models age as the frontier moves. Today those bills are paid by companies doing it for strategic reasons - Meta, the Chinese labs, a handful of academic projects, however that money lacks permanence. Meta showed how quickly it can retract: the moment openness stopped serving its interests, the releases slowed. More durable funding models are emerging - a Red Hat-style business layer that monetises serving and tooling around open models, and state money being provided on sovereignty grounds - but both are early, and neither yet covers the cost of a frontier run.

4. A feedback loop. Open source software got better simply by being used. Every user was a potential bug-reporter or bug-fixer; problems found in the field flowed back to the project, and the next release was better for everyone. Usage compounded into quality. A model has no such loop, because weights are frozen at release - a model learns nothing from being run, however many millions of people use it. The valuable insight that usage generates - which prompts fail, where the model breaks, what users actually need - is collected by whoever operates the deployment, not by the model's maker. And even a community that wanted to send those learnings back has no way to do it: improving the shared weights means a full retraining run, which only the owner can perform. So where open source software compounded with adoption, an open model just sits there - a static file, ageing as the frontier moves, until its sponsor chooses to ship another. This is what I mean when referring to a feedback loop.

Put the framework together and my verdict comes in two halves. Below the frontier, open wins. The coalition is too large, the economics too compelling, and the commoditisation ratchet turns only one way: every capability eventually diffuses into open weights, and an increasing share of the world's AI workloads will run there. But open-weight AI does not yet win the way open source software won - permanently, structurally, immune to any single sponsor's decisions. The four gaps above, in my view, are the missing pieces of that framework. The question is not “will open models catch up?” - they will, capability by capability. The real question is who builds the missing institutions: the contribution mechanics, the neutral foundation, the funding engine, the feedback loop.

I'll end with a prediction. Open models become the default for every task that doesn't demand frontier capability - and inside most businesses, that is the overwhelming majority of tasks. The closed labs keep the hardest work, and earn a genuine premium on it. But once a company is running a dozen models - open and closed, large and small - the scarce capability is no longer access to any single model. It's the control plane above them: the routing layer that decides, task by task, which model fires - on cost, on quality, on latency, on data sensitivity. Model choice stops being a procurement decision made once a year and becomes an engineering decision made thousands of times a second. The companies that build that discipline early will run structurally cheaper than competitors who didn't; the vendors that sell it will occupy one of the most defensible positions in the stack - because the router sees every workload, learns what each model is good for, and accumulates the switching costs. In a world where models commoditise, the layer that orchestrates them doesn't.

Underneath that discipline sits a metric I keep coming back to: intelligence per watt. Every software era eventually converged on a small set of numbers that defined operational quality - SaaS had NRR and GRR, metrics that barely existed in 2010 and were deciding valuations by 2020. I think intelligence per watt becomes AI's equivalent: how much useful output a company extracts per unit of energy and compute it spends. Read the whole open source story through that lens and it clicks into place - a frontier model maximises raw intelligence, but an open or small model, matched to the right task, routinely wins on intelligence per watt. The control plane is simply the machine that optimises the metric across every workload. Companies will report it, boards will track it, and investors will price it, the same way they learned to price retention.

A side note while I'm here: this is a space I'm actively looking at - so if you're a founder building in open source AI, whether that's the control plane and routing layer, the serving and tooling stack around open models, or something I haven't thought of yet, I'd genuinely like to see it. Send it across or get in touch.

This piece has reached a clear verdict: below the frontier, open wins. So let's assume the verdict is correct and ask, from first principles, what else must be true.

First, the AI economy gets bigger, not smaller. The instinct is to read commoditisation as contraction: cheaper models, less revenue. Jevons paradox says the opposite, and it’s already the best-documented dynamic in AI: token demand is elastic enough that every fall in price drives a more-than-proportional rise in usage. Open models winning means the price of intelligence falling faster and further - which means consumption doesn’t grow, it skyrockets. Satya Nadella made exactly this point the weekend DeepSeek landed: “Jevons paradox strikes again… we will see its use skyrocket, turning it into a commodity we just can’t get enough of.” Open source doesn’t shrink the pie. It’s the mechanism that makes the pie expand exponentially.

Second, the margin moves down the stack - to infrastructure. This is Gavin Baker’s argument - one of the smartest investors in AI, and someone I follow religiously. The mega bull case for AI infrastructure, he wrote this week, is precisely a market-share shift away from frontier labs running 90%-plus inference margins toward cheaper models, open or closed. The margin dollars don’t evaporate; they get redistributed to whoever runs tokens at the lowest cost - the chipmakers, the memory suppliers feeding inference (regular readers know the Micron story), the hyperscalers, and behind all of it, energy. It also explains behaviour that otherwise looks odd: Nvidia championing open models isn’t charity - lower margin percentage at the model layer means more margin dollars at the infrastructure layer. And note the hyperscalers are hedged both ways: Azure was serving DeepSeek within days. When you sell the picks, you don’t care who finds the gold.

Third, the margin moves up the stack - to applications. The other half of the redistribution, and the one I’ve spent most of this year writing about. When intelligence becomes a cheap, abundant input, the durable value forms wherever it’s converted into outcomes customers pay for - the vertical applications, the workflow owners, and the control plane that routes each task to the cheapest adequate model. Baker frames the winning metric as intelligence per dollar; I’ve been calling it intelligence per watt; Burry calls the same shift “bigger models to cheaper, smarter systems.” Different units, same claim: efficiency in converting intelligence to outcomes becomes the defining operating metric of the era - AI’s ‘NRR’ equivalent.

Fourth, open winning is good for everyone except the model providers. Consumers get collapsing prices. Enterprises get cost, control and freedom from suppliers they don’t fully trust. Nations get sovereignty. Infrastructure gets volume; applications get margin. The single structural loser is the pure-play closed lab, whose 90% inference margin is exactly the arbitrage the whole system is organised to close. The labs can read this chart as well as anyone - which explains their behaviour too. The rush into applications, agents and enterprise products isn’t diversification; it’s the model layer hedging its own commoditisation, whilst trying to create vendor lock-in. Days after DeepSeek, even Sam Altman admitted OpenAI had been “on the wrong side of history” on open source.

One caveat on all of this: open-weight AI today is still a strategy, not a commons. The four gaps - contribution, governance, funding, feedback - will decide whether this future becomes self-sustaining, or remains dependent on the continued goodwill of a handful of open-weight sponsors. Two themes are worth tracking from here. The first is who builds those missing institutions - I'd expect some of the defining companies of the decade to emerge exactly there. The second is policy: the open ecosystem's centre of gravity sits in China, and restriction doesn't stop open models - it just changes whose open models the world runs on, and my hope is that it’s the Western world that triumphs.

As for me, I'm genuinely indifferent to who wins. If the closed labs hold the frontier, competition compresses the price of intelligence from above; if open weights keep absorbing capability from below, it collapses faster still. Either way intelligence gets cheaper, and for an investor at the application layer, that's the only fact that matters. Open source winning isn't a threat to the companies I back - it's a tailwind: deflation in the core input cost, intelligence per watt as the exponential.

Fifty years ago, an antitrust decree accidentally created a commons, and the commons ended up running the world. The pattern is repeating with the most valuable technology of our lifetimes - and this time everyone can see it coming. Software wanted to be free, and became infrastructure. Intelligence is next. Open source is something I’ll continue watching closely.