Open models still concentrate infrastructure

Together AI announced an $800 million Series C this week, alongside commitments for more than 500 megawatts of compute capacity to serve open models. The pitch includes running open models at 6 to 20 times lower cost than closed alternatives, with customer Decagon cited at a sixfold reduction — vendor-reported numbers whose baselines I can't inspect, so treat the multiples as marketing with a direction. The direction, though, is real: open-model serving is now a business that raises hyperscaler-shaped money and signs power contracts measured in megawatts.

Which is exactly the detail that should recalibrate the most common strategic argument for open weights. The argument goes: choose open models, escape vendor concentration. Half right — and the wrong half is expensive.

Weight portability and serving portability are different properties. Open weights genuinely kill software lock-in: the checkpoint is downloadable, the architecture documented, no API contract holds your prompts hostage. If your provider misbehaves, the model can leave. But your workload doesn't run on a checkpoint. It runs on capacity — and industrial inference is capital, power contracts, hardware allocation in a supply-constrained market, kernel and compiler engineering to hit competitive latency, scheduling at fleet scale, and the operational muscle to keep p95 flat during everyone's simultaneous launch week. That list is precisely what $800 million and 500 megawatts buy, and precisely what almost nobody else can afford to replicate.

So open weights don't eliminate concentration. They relocate it — from the model layer, where licenses used to bind you, down to the serving layer, where physics and finance do. The number of parties that can serve a frontier-class open model at enterprise latency, throughput, and regional coverage is small, capital-hungry, and consolidating. Your freedom to leave is bounded not by the license but by whether a second provider can absorb your workload at your SLA — this quarter, in your region, at a price that doesn't erase the reason you left.

At work, the version I keep meeting: a platform team proudly presents an open-weights strategy as their vendor-risk mitigation, and when I ask the operational question — if your serving provider doubled prices at renewal, where would this workload run next month? — the answer is a silence with a GPU shortage inside it. Self-hosting turns out to need hardware they can't get and kernel engineering they don't have; the alternative providers turn out to lack capacity in their region or fall over at their throughput. The checkpoint was portable. The workload was not. That gap is the entire negotiation, and their provider knows it to the basis point.

The procurement fix is to test serving portability the way you'd test a backup: by doing it, before you need it. My rule for open-model contracts now: the exit is real only if it has been rehearsed. Run a representative slice of the workload — real prompt mix, real latency bar — on a second serving provider for one week per year. Record what broke, what it cost, and how long the migration took. That rehearsal converts "we could leave" from a slide bullet into a negotiating position, and its cost is trivial next to a renewal negotiated without it.

Steal the checklist version: before signing any open-model serving deal, write down your required latency, throughput, and regions; name the two alternative providers that can meet them today; and put a migration-rehearsal clause and a data-egress cost cap in the contract. If you cannot name two alternatives, you have not chosen an open strategy — you have chosen a closed one with extra steps and better vibes.

Open weights free the model, not the workload — the lock-in moved down the stack, and the only exit that counts is the one you have rehearsed.