OpenAI's Three-Size GPT 5.6 Is Not a Model Launch. It's an Infrastructure Land Grab.

The literal facts are thin, so hold them tight. GPT 5.6 comes in three sizes named Sol, Terra, and Luna, sized like the Sun, Earth, and Moon, according to the launch coverage. That is the confirmed part. Everything past it is reading.

Here is the reading. A single frontier model is a commodity input. You send tokens, you get tokens, and the buyer decides what to do with them. A tiered family is different in kind. It presumes the buyer has a portfolio of tasks with different cost tolerances, and it sells you the tolerance curve directly.

That is exactly the shape of agent work. An agent loop is not one expensive call. It is a long chain of cheap steps punctuated by a few decisions that actually need brains. Reading a file: cheap. Deciding whether to delete it: expensive. A three-tier family lets a runtime route each step to the cheapest model that can do it.

So the sizing is not a menu for humans choosing a chatbot. It is a routing substrate for agents. The vendor is quietly assuming you will not pick one size and stick with it. You, or more likely the harness above you, will fan work across all three. That assumption only makes sense if the customer is an agent system, not a person.

Apply the Wardley Mapping lens and the intent gets clearer. A model in genesis is bespoke and expensive to reason about. A model as commodity is interchangeable and priced by the unit. By shipping a graded family, OpenAI is trying to skip the commodity trap: instead of competing on price per token against every other lab, it sells a coordinated tier structure that is worth more assembled than sold in parts. The tiers are the product. The individual model is the component.

The second move is the load-bearing one. Codex, previously a coding-focused surface, is now folded into ChatGPT as a superapp, per the same recap. Treat the specifics as light and the direction as heavy.

Until now there was a mental wall between two things. A chatbot is the thing you talk to. An agent runtime is the thing that takes actions in the world, runs code, edits files, calls tools, loops. Codex lived closer to the second. ChatGPT was the first. Merging them tears down the wall.

That matters because of where value actually accrues. The Harness Hypothesis says the value in AI is not in the model, it is in the harness that connects the model to the world. Codex was a harness. ChatGPT was a demand aggregator with hundreds of millions of users. Put the harness inside the aggregator and you get the single most dangerous combination in this market: the runtime that most people already have open in a tab.

For a daily agent user, the user-facing effect is blunt. The place you already type is now the place work gets executed. You do not adopt an agent runtime as a separate decision. It arrives underneath a product you already use, the same way features arrive in an operating system.

That is the collapse. Not a new app to install. A category boundary quietly deleted, so that asking a question and dispatching an autonomous task become the same gesture, on the same surface, billed through the same relationship.

Why bundle at all? Run it through Aggregation Theory: platforms win by aggregating demand and then commoditizing supply, and the one that owns the user relationship wins. The relevant reporting keeps returning to that frame, with analysts framing the current fight as a battle over verifiable data and platform position across Meta, Grok, and the frontier labs.

Apply it here. ChatGPT owns the demand side: the users, the habit, the default. The models, including OpenAI's own three sizes, are the supply. By pulling Codex into ChatGPT, OpenAI puts the agent runtime on the side of the aggregator, where the user relationship lives, and pushes the model down into interchangeable supply beneath it.

This is also Commoditize Your Complement in plain view. If you own the runtime and the user, you want the model layer, even your own, to feel like a dial rather than a destination. Three sizes reinforce that. They train the buyer to think of capability as a slider inside the product, not as a reason to leave for a competitor's raw API.

The strategic payoff is retention that a model API cannot buy. A raw model has no lock-in. Swap the endpoint, change one line, done. A runtime that holds your tasks, your tool connections, your history, and your billing has switching costs that compound daily.

That is the shift the branding hides. OpenAI is not trying to have the best model this quarter. It is trying to be the surface where your agent work already lives, so that whoever has the best model next quarter finds you already committed. The model is a fight you can lose. The surface is a fight you only have to win once.

There is a security reading of tiered sizing that nobody puts on the launch slide, and it is the one that should interest anyone deploying agents.

Use the Capability vs. Controllability Frontier: more capable models are harder to control, and the frontier forces an explicit trade-off. A three-size family is, functionally, three points on that frontier sold at once. The small size is less capable and easier to bound. The large size is more capable and harder to predict.

Smart agent design exploits exactly this. You do not want your maximum-capability model driving the ten thousand routine steps, because maximum capability is where surprising, hard-to-audit behavior lives. You want the smallest model that clears the bar, and you escalate to the big one only for the calls that need it.

That maps cleanly onto the Autonomy Spectrum: agent deployments run from copilot to full autonomy, and most failures come from deploying at the wrong point. A tiered family lets a runtime deploy different points on that spectrum for different steps. Cheap and constrained for the routine. Powerful and supervised for the consequential.

Here is the trust-boundary catch. When routing across tiers happens inside a vendor's runtime instead of inside your own harness, you lose visibility into which model made which call. The decision to escalate from Luna to Sol is now a trust boundary you did not draw and cannot fully inspect. If the routing logic decides a destructive action only warrants the cheap model, or the expensive one, you are trusting the runtime's judgment, not your own policy.

So the same feature that makes agents cheaper to run also moves a control decision behind the vendor's curtain. That is the trade you accept when you buy infrastructure instead of a model: convenience up front, an opaque boundary you now depend on.

Zoom out to lifecycle. The Molt Cycle describes how this ecosystem moves in stages: rapid growth, security crisis, hardening, enterprise adoption, commoditization, then the next molt. Frontier models are visibly entering the commoditization stage.

The evidence is in the mundane parts of the source pack. Toolmakers keep shipping quiet plumbing fixes around model usage: the AI SDK corrected how it counts cached tokens so that cache hits are reported correctly instead of being billed as fresh input, in a Groq provider update. That is not a capability story. That is a cost-accounting story, the kind of work you only invest in once models are interchangeable enough that per-token economics is the game.

Observability is molting the same direction. Phoenix shipped a client release adding project-list filtering and environment-file handling, routine tooling maintenance. When the interesting releases are about counting, filtering, and configuring rather than raw capability, the layer below has commoditized and value has moved up the stack.

OpenAI's launch is what the top of the stack looks like when this happens. If the model is commoditizing, you do not want to be the model. You want to be the runtime that consumes commodity models and sells the assembled experience. Three sizes plus a bundled superapp is precisely that posture.

The pattern resembles every platform molt before it. The exciting layer becomes a utility. The margin migrates to whoever owns the surface that sits on top of the utility. OpenAI is not fighting the commoditization of models. It is betting on it, and moving its own weight to the layer that survives it.

Strip the theory. Here is the practical shift for a power user who configures agents but does not build frameworks.

First, stop evaluating this as a model. The right question is not is GPT 5.6 smarter. The right question is what does the runtime decide for me, and can I see it. When you adopt a bundled runtime, you inherit its routing, its defaults, and its trust boundaries whether you audit them or not.

Second, watch the lock-in accrue. A raw model API is disposable. A runtime that holds your tasks, connections, and history is not. The moment your agent work lives inside ChatGPT rather than beside it, switching gets expensive in a way that has nothing to do with which lab has the best model next.

Third, treat opaque tier routing as an attack surface, in the plain sense of enumerate what can reach your systems and minimize unnecessary exposure. If the runtime silently chooses which model executes a consequential action, and you cannot inspect that choice, you have a control gap. For low-stakes personal use, fine. For anything touching real systems or the Shadow Agent risk of unsanctioned deployment inside an org, that gap is where the holes in your defenses line up.

The honest caveat: the source detail here is thin. We know the three sizes and the Codex bundling, from the launch recap, and not much of the pricing or routing internals. So hold the specifics loosely and the direction firmly.

The direction is not in doubt. Frontier labs are done selling you a model and are moving to sell you the place your agents live. The naming was astronomy. The strategy was real estate.