Open vs Closed

In the last two weeks of July 2026, the open vs closed debate went from engineering forums to the White House. As someone who has spent years on both sides of this line — building closed-model inference and open-weights model post-training and optimization at Amazon, contributing part-time in open source communities — I want to write down what I saw, and why I believe what I believe.

A side contributor, on the fringes of open source.

The Week Open Weights Went to Washington

Reports surfaced that US officials were weighing a ban on the use of Chinese open-weights models by US companies. What followed was the fastest industry mobilization I have ever watched. Within one week, essentially every major lab and cloud declared a position on open weights.

Fifty signatures in seventy-two hours. The interesting question is not who signed — it is why the coalition spans every layer of the industry at once: chipmakers like NVIDIA and Dell, clouds and closed-model labs like Microsoft — later joined by OpenAI and Google — and open platforms like Hugging Face and IBM. What do they all see in open weights? To answer that, rewind twelve years.

Open Weights vs Open Source

Before going further, one terminology correction the debate keeps stumbling over: almost none of the "open source" models in the headlines are open source in the sense the software world has used the term for twenty-five years. They are open weights. The letter fifty companies signed says "open weights" in its title for a reason, and the distinction is not pedantry — it decides what you can actually do with the model.

In classic open source, you get the source — everything needed to study, reproduce, and modify the artifact. For a model, the "source" is not just the final tensors; it is the training data, the data processing pipeline, the training code, and the recipe that turns compute into a checkpoint. An open-weights release gives you the compiled output — the trained parameters — under a license that lets you run, fine-tune, and redistribute it. You can customize the artifact; you cannot rebuild it from scratch.

Kimi K3 — the release that anchored the week of July 27 — is the perfect example, because Moonshot AI opened up unusually much and the gap is still visible. Here is what is public and what is not:

The software analogy: an open-weights model is a freely redistributable binary — you can run it anywhere, patch it (fine-tune), even ship modified copies — but the source tree (data, pipeline, training code) stays in-house. By the OSI's Open Source AI Definition, which requires data information, training code, and weights all under open terms, K3 does not qualify — and neither do Llama, Gemma, or gpt-oss. The rare models that come close are efforts like AI2's OLMo, which release data, code, and checkpoints together. DeepSeek-R1 sits in between: MIT-licensed weights — a genuinely open-source license — but still no training data or pipeline.

Two honest observations follow. First, the gap is not hypocrisy; it is physics and economics. The training corpus embeds licensing liabilities no lab can fully clear, and the data pipeline is the crown jewel — more than architecture, it is where frontier labs differ. Second, the gap matters less than purists claim for most practical purposes: the customization loop later in this essay — fine-tuning, RL post-training, speculative decoding, quantization — needs the tensors, not the corpus. What you cannot do without the source is reproduce or fully audit the model — which is exactly why the interpretability and evaluation arguments in the trust & safety section run on weights, and why true open-source models remain scientifically precious even when they trail the frontier.

So throughout this essay I say "open weights" when I mean releases like Kimi K3, and reserve "open source" for the ecosystem — vLLM, SGLang, Kubernetes, Kafka — where the term actually applies. The July letter got the terminology right; most of the coverage did not.

Déjà Vu: We Have Seen This Movie Before

In January 2022, Honeypot released Kubernetes: The Documentary. It is the most honest account I know of why a giant open-sources its crown jewels. Around 2013, AWS was, in early Kubernetes engineer Tim Hockin's words, "this behemoth that was on everybody's mind." Kubernetes co-founder Joe Beda put Google's calculus plainly:

Open-sourcing Kubernetes was not charity. It was strategy — the challenger opens to commoditize the leader's advantage. And it worked, for a reason Brewer named precisely: "Kubernetes won in part because it had a vast army of contributors behind it… that rate of change kind of trumps everything else."

The pattern repeats across software history. Apache Kafka is my favorite example: LinkedIn open-sourced it in 2011, Confluent commercialized it, and today Kafka is the de facto event-streaming standard — with Amazon MSK and Confluent Cloud competing to run the same open protocol. The open standard grew the market; the vendors compete on operations, performance, and trust. Nobody was destroyed by openness. Linux vs Windows, Android vs iOS, MySQL vs Oracle, Kubernetes vs proprietary orchestrators — same movie, different decade. Android took the volume, iOS kept the margins — and both are still here.

Look closer and there is a second recurring pattern: the winning commercial product very often stacks on top of an open-source primitive. Confluent is built on Apache Kafka; Databricks on Apache Spark; AWS Lambda, Fargate and App Runner sit on Firecracker, which runs on containerd; Google Cloud Run is built on Knative, which runs on Kubernetes atop containerd. The open layer sets the standard and grows the market — the closed layer sells operations, reliability, and enterprise trust on top. There is no reason to believe AI will be different — artificial intelligence will be built the same way, stack 0 through stack n−1, with agents and Model-as-a-Service somewhere in between. What the lower stacks look like — open weights, closed models, or a mix — there is no definitive answer yet.

So when NVIDIA — whose hardware profits from every token, open or closed — organizes an open-weights letter, and Microsoft, Meta and OpenAI sign, I do not read it as altruism. I read it as the Kubernetes playbook, replayed at the model layer: open the layer where you are not the monopolist, and compete on the layers where you are strong.

NVIDIA Ecosystem

Of the twenty-five original signatories, NVIDIA is the one that needed the letter least. It sells the shovels; every token, open or closed, is billed to an accelerator somewhere. So why spend the political capital — why does Jensen Huang join X after years of staying off it, and make an open-weights letter his first post ever?

Because NVIDIA has never been only a chip vendor. It is one of the most effective ecosystem builders in the industry's history, and it has been running the same play for twenty years: give away everything above the silicon. CUDA has been free since 2006. cuDNN, NCCL, Megatron-LM, TensorRT, Triton Inference Server, NeMo, Dynamo — all released, all designed so that somebody else's software runs best on NVIDIA hardware. It publishes its own open-weight models (Nemotron) and upstreams kernels into vLLM and SGLang. None of that is philanthropy: every open layer above the chip is a demand funnel into the chip. The more of the AI stack that is open and CUDA-shaped, the more often the default answer to "what do we run this on" is NVIDIA.

Now look at where each part of the market actually sits on silicon. The same three layers — model, serving stack, silicon — with three different bottom lines:

The asymmetry is about the shape of demand, not about ideology. Concentrated demand can afford vertical integration: a lab spending tens of billions a year on compute is exactly the customer who can fund a custom accelerator program and negotiate a second GPU source. That is why the closed frontier is the fastest-diversifying part of the market — OpenAI has added AMD capacity and a Broadcom co-designed accelerator; Anthropic trains and serves across Google TPU and AWS Trainium alongside NVIDIA. In the closed world, NVIDIA's share of its largest customers' silicon has one direction to go.

Open weights invert that shape. The demand is fragmented across thousands of enterprises, neoclouds, startups, and universities, and essentially none of them can fund an ASIC program or staff a compiler team. They run whatever the community's serving stack runs best on — and the community's kernels are written for CUDA first. Every Kimi K3, DeepSeek or Qwen release lands as a fresh wave of deployments onto NVIDIA hardware, by default, with nobody negotiating. Open weights convert one negotiated mega-contract into ten thousand unnegotiated ones.

Read that way, NVIDIA's letter is precisely the move Google made in 2014: open the layer where you are not the monopolist, defend the layer where you are. Google gave away the orchestrator to sell the cloud; NVIDIA champions open weights to sell the accelerator. The ecosystem argument and the commercial argument point the same direction — which is exactly why it is credible, and why an ecosystem builder is the natural leader of this coalition rather than a model lab.

A Participant and a Part-Time Contributor

I should be honest about where I sit in open source: on the fringes, not in the inner circle. As a co-creator of AWS App Runner, I had the chance to work deeply with the open source programs the service is built on — containerd, Envoy, OpenTelemetry, Kafka — and that access is where my understanding of these communities comes from (I wrote about that path here). It is also why I call myself a side contributor rather than a maintainer: unlike the people who write upstream code every day and carry those projects, my work at corporate ultimately shipped to users as a managed service. Since 2019 I have contributed where I could across the Linux Foundation and CNCF communities, served as a CNCF Ambassador (until 2027 term), and spent four-plus years on Program Committees for PyTorchCon, CloudNativeCon and the Open Source Summit. I wrote about that decade of community in CNCF Turns 10.

On the closed side: at AWS I built Bedrock's Anthropic inference engine from zero to one and shipped the production releases of Claude 3 Opus, 3.5 Sonnet, and 3.5 Haiku — a chapter I wrote about in My Story with Anthropic. Today I work on the open-weights model business: OpenAI's gpt-oss, Google DeepMind's Gemma, Alibaba's Qwen, and DeepSeek, plus post-training, evaluation, and inference optimization (speculative decoding) for open-weight models.

Both tables, one lesson. In the same year DeepSeek-R1 was released, I wrote down my read in my DeepSeek post — open source is the way — and co-authored the book DeepSeek in Practice. And I noted in LLM Native that the open-source LLM ecosystem — vLLM, SGLang, llm-d, Dynamo, MCP — is already in place. The through-line: open source is not a product strategy, it is an ecosystem. Ecosystems grow markets; they do not zero-sum them.

The Open-Weight Model Market

Follow the money, and the picture is genuinely two-sided. Capital is pouring into open-weight infrastructure:

On July 16, Fireworks AI raised a $1.505B Series D at a $17.5B valuation — led by Atreides, Index and TCV with Nvidia participating — crossing $1B ARR serving custom and open models for customers like Uber and Shopify. Founder Lin Qiao previously built PyTorch at Meta. Two weeks earlier, Together AI raised an $800M Series C at $8.3B — up from $3.3B just sixteen months prior — with annual bookings past $1.15B and open-source model usage tripling in twelve months. Its business model: per-token APIs over open models (roughly 30–40% of revenue, per Sacra) plus GPU cluster rentals, serving Cursor, Cognition and Decagon.

For scale, hold the open-weight infrastructure curve against the closed-side flagship. Anthropic, founded in 2021, went from $4.1B (May 2023) through $61.5B to $965B — roughly 235x in three years. Fireworks, founded in 2022, went from $552M to $17.5B in two years — ~32x. Both curves are vertical; the market is not choosing sides, it is pricing both:

Usage tells the same story — straight from OpenRouter's own data. Its State of AI study with a16z, spanning 100+ trillion routed tokens, found open-weight models averaging 26.7% of all token volume over the year and reaching roughly one-third by late 2025 — "the equilibrium is currently reached at roughly 30%," the authors wrote. Then 2026 broke the equilibrium: per OpenRouter's official June analysis of 450 trillion tokens, open weights crossed into the majority of all routed tokens, and DeepSeek alone doubled from 9% to 18% to become the platform's top model author since mid-May.

But spending flows the other way. a16z's survey of 100 Global 2000 CIOs found open source falling from 19% to 11% of enterprise AI spend, with closed models climbing from 81% to 89% — even as open source's share of raw tokens rose. Read together: open weights are winning tokens and workloads; closed models are winning budgets and the last production mile. That is not a contradiction — it is a division of labor. High-volume, cost-sensitive, customizable workloads go open; frontier reasoning and turnkey enterprise features stay closed, for now.

China's Model Companies: The Tigers Go Public

No account of the open-weights market is complete without the companies actually shipping most of the open frontier. In 2026, China's "AI tigers" — DeepSeek, Moonshot AI, MiniMax, Zhipu AI, StepFun — stopped being a funding story and became a public-markets story.

• DeepSeek — the most remarkable case: founder Liang Wenfeng refused outside money entirely until 2026, then raised a $7.4B Series A in June, investing up to 40% of it himself to keep control. A July shareholder filing implies a ~$52B valuation; reports put its next round in talks at ~$70B pre-money.
• Moonshot AI — $2.5B (Feb 2024) → $4.3B (late 2025) → $10B (early 2026) → $20B (May); after Kimi K3, closing a round at just over $30B with a Hong Kong listing planned within six months. Roughly 8x in a year — powered by giving the weights away.
• Zhipu AI — from ~$3B (May 2024) to a HKEX debut on January 8, 2026 at a $7.4B market cap (+13%) — then past $100B market cap by July, raising another $4B, with a Shanghai STAR dual listing planned.
• MiniMax — $2.5B (March 2024) → $4B (mid-2025) → HKEX listing on January 9, 2026, doubling on debut (+109%).
• StepFun — ~$2B (late 2024) → filed for a Hong Kong IPO in June at a proposed valuation of up to $12B.

Put this next to the a16z spend data and the picture sharpens: US enterprises may still route their budgets to closed models, but public markets — Hong Kong first — are now pricing open-weight labs as durable businesses. Giving away the weights did not destroy value. It created the fastest IPO cohort in AI.

Model Customization: Fine-Tuning, RL & Self-Improvement

First, the macro view. A frontier model's lifecycle runs from data through pre-training, mid-training, post-training, evaluation, and release. Who gets to customize each stage is the open-vs-closed debate in a single picture:

Why do enterprises want weights at all? Because the frontier of value has moved from prompting a general model to specializing a model on your own data and your own reward signal. This is exactly the demand Fireworks calls "specialized intelligence" and Together monetizes through fine-tuning APIs — and it is only possible when you own or can touch the weights. The loop looks like this:

Supervised fine-tuning teaches the model your domain; reinforcement learning — RLHF with human preferences, or RLVR with verifiable rewards for code and math — aligns it with your objective; and the newest turn is recursive self-improvement (RSI)-style loops, where the model generates its own training data, grades it against verifiers, and feeds the survivors back into training. Every arrow in that diagram requires access to weights. A closed API gives you, at best, the vendor's hosted fine-tuning of the vendor's model on the vendor's terms. This — not ideology — is the structural market demand behind open weights: the customization loop is where enterprise differentiation now lives, and the loop does not close without the weights.

Trust & Safety, Evaluation, Interpretability

The safety debate deserves honesty from both sides. Closed-model providers are right that released weights cannot be recalled, and guardrails on open models can be fine-tuned away. Amodei's position — mandatory pre-release testing for all sufficiently capable models, open and closed — is the most reasonable version of that argument, and I agree with testing over bans.

But openness carries its own safety advantages that the debate under-weights. You cannot audit what you cannot see: interpretability research — the field Amodei himself called urgent in The Urgency of Interpretability — overwhelmingly runs on open weights, because probing activations and circuits requires the tensors, not an API. Independent evaluation works the same way: the community can red-team, benchmark and reproduce results on Qwen or Kimi K3 without a vendor's permission, while closed models are evaluated under NDA-shaped access on the vendor's schedule. Mature deployments need both open and closed, which is one more reason bans are the wrong tool.

And evaluation itself just became a safety surface. In the same two weeks the open-weights letter was circulating, both frontier labs disclosed real incidents from inside their own cyber evaluations:

Price Performance

The economics are now well documented. Per Epoch AI data reported by The New Stack, open-weight models trail closed frontier models by roughly four months in capability — at about one-tenth the token price. CNCF executive director Jonathan Bryce: "Paying ten times more for a four-month capability lead is not an enterprise AI strategy… it's a very expensive form of lock-in."

Independent leaderboards put numbers on the gap. On the Artificial Analysis Intelligence Index (v4.1, July 2026), the best open weights sit points — not tiers — behind the closed frontier, at a fraction of the price:

Read it either way — list price or cost per completed task — the shape is the same: Kimi K3 delivers 95% of Fable 5's index score at about a quarter of the cost per task. Put simply: much of the closed-model premium buys the platform around the model, not more intelligence.

The New Stack's July benchmark made the trade explicit — Claude Fable 5 vs. Kimi K3: same results, one-third the cost, 4x slower. Money vs latency. And a Featherless case study puts self-hosting economics in sharp relief: a team at full utilization burning 100B tokens/month pays ~$1.56M/year on GPT-5.5 — versus a $90K/year fixed private-cloud rate running open-weight GLM 5.2, a 94% reduction.

And the floor keeps dropping. On the day I am finishing this essay — July 31 — DeepSeek put its V4-Flash API into public beta: $0.14 per million input tokens ($0.0028 on cache hits), $0.28 per million output, with a 1M-token context window. Against Fable 5's $10/$50 list price, that is roughly 70x cheaper on input and 180x on output — from the lab that made open weights a frontier phenomenon. One day's news, same curve, bending further.

And the sticker price is only the starting point: with open weights, the optimization headroom belongs to you. This is stage 06 of the lifecycle pipeline above — the stage a closed API never lets you touch. Because you own the serving stack, you can train your own speculator for speculative decoding, quantize to FP8/INT4 where quality allows, and tune kernels for your hardware — quality-lossless (or near-lossless) optimizations that routinely deliver multiples of throughput. On a closed API, that headroom is the vendor's margin; on open weights, it is your cost curve. This is my day job on the open-weights side, and it is where the ten-times gap keeps widening.

The honest caveats: closed frontier models still win on raw capability at the edge, on latency (Kimi K3 was 4x slower in that benchmark), and on turnkey enterprise features — identity integration, connectors, observability — which is much of what enterprises are actually paying for, as the a16z spend data shows. Price performance is not one number; it is a curve, and open weights now dominate the high-volume, cost-sensitive stretch of it.

Open Intelligence

It would be easy to close this essay the way industry essays usually close — with market share, competitive playbooks, who wins. But that framing is too small for what is actually at stake. AI is another industrial revolution, and the hardest problems ahead of us — alignment, interpretability, safety, how humans and increasingly capable AI systems coexist — are not problems any single company, or any single country, can solve alone. They are problems for humanity, and humanity works on shared problems through open ecosystems: open weights that any researcher can probe, open evaluations that anyone can reproduce, open science of the kind that produced the transformer itself.

This is why the events of July matter beyond the headlines. When fifty companies — bitter competitors on every other front — sign the same letter within seventy-two hours, they are acknowledging something deeper than commercial interest: that the path to trustworthy AI runs through openness. Interpretability research runs on open weights. Independent red-teaming runs on open weights. The global cooperation that safety testing will require — the kind even Amodei argues must include every capable lab, in every country — is only possible if the science stays open enough for everyone to participate. Open source enables innovation, research, and the democratization of AI; more than that, it is how we keep each other honest while building the most consequential technology in human history.