GPT-5.6 system card,
explained.

Every rung below scales a model — parameters, compute, context. This rung scales the allocation. A query arrives and the system decides which of several difficulty tiers should handle it, and for the hardest work it runs several agents in parallel on the same problem and uses a verifier to choose among their answers. What the user calls "the model" is a policy over models.

The interesting content is the arithmetic of how many agents to run, because it explains a design choice that otherwise looks arbitrary. If each attempt succeeds independently with some probability, the chance that at least one succeeds rises with the number of attempts — but it rises with diminishing increments, since each new agent only helps in the shrinking set of cases where every previous one failed. Meanwhile cost rises linearly. The two curves cross early, which is why the answer is a small number (the card's four is plausible) rather than forty, and no amount of budget moves it far.

There is a second and sharper reason the number stays small, and it is worth more than the first. Running many attempts is only useful if you can tell which one is right, so the whole scheme is bounded by the verifier's accuracy — and as the attempt count grows, the chance that some wrong answer looks better to the verifier than the right one grows with it. Past a point, adding agents makes the selection problem harder faster than it makes the generation problem easier. This is the same result the process-supervision rung reports from the other end: a coarse judge gets worse as its choice set grows.

Not every request deserves the biggest brain. The card describes a router that sorts queries by estimated difficulty across tiers — reported as Sol / Terra / Luna — sending easy work to a cheap, fast tier and escalating only the hard cases to a heavier one. Since most real traffic is easy, the average cost tracks the small tier while peak capability stays available for the rare hard query.

That economic logic — cheap by default, expensive on demand — is the model-routing cascade, and its cost math is worked out in full in the model-routing handbook (expected cost, break-even escalation rate). What the system card adds on top is what happens at the hardest tier, where one pass isn't enough.

For the hardest tasks, the card describes an ultra mode that spends test-time compute in parallel: run several independent agents (reported as four) on the same problem, then let a verifier pick the best result. On verifiable work — code that must pass tests, math with a checkable answer — this is a clean win, because a wrong try is cheap to discard and a right try is easy to confirm.

If one agent solves it with probability p, then "at least one of N solves it" is 1 − (1 − p)^^N — and a verifier turns that possibility into the answer you keep.

The solve-rate formula rises with N, so why not run forty agents? Because what matters is the marginal gain of each added agent — and it shrinks fast. Subtract consecutive terms and the value of the N-th agent is a clean geometric decay:

At p = 0.6: the 1st agent buys +0.60, the 2nd +0.24, the 3rd +0.10, the 4th +0.04 — while each agent costs the same. Cost is linear in N; benefit decays geometrically.

So there's a knee. The first few agents convert a coin-flip task into a near-certainty; past that, you're paying full price for crumbs. "Four" is illustrative here: the arithmetic shows the marginal gain falling quickly, but where it drops below what the extra compute is worth depends on p and on your cost per try, so it does not single out four by itself. The runnable below lets you move p and watch the knee move with it.

A system card is also a safety document. Alongside capability numbers, a frontier lab reports a Preparedness-style assessment — dangerous-capability evaluations gating release. Tiered routing and ultra mode complicate that case: the same machinery that spends more compute to crack a hard benchmark can spend it to amplify misuse, and the strongest configuration (top tier, full ultra mode) is what the safety argument must actually cover — not the cheap default most users see.

That's the honest tension in these cards. The knee that makes ultra mode economical also makes the most capable setting a deliberate, bounded choice — which is exactly the setting the risk evaluations have to be measured against.

This card marks a shift in how frontier models ship: not as a single artifact but as a compute-allocation policy — route by difficulty, escalate by need, parallelize the hardest cases. The scaling premise behind "more compute → more accuracy" is the log-linear test-time-compute curve OpenAI published in its "Learning to Reason with LLMs" post (see also the o1 system card); the cost discipline is the model-routing and cost-engineering playbook. What this breakdown adds is the piece that sets the dial: the marginal value of the N-th parallel agent.

The takeaway generalizes well past any one lab. Any time you're tempted to throw more parallel samples at a verifiable task — best-of-N decoding, multi-agent voting, retry loops — compute Δ(N) = (1−p)^^N−1·p and stop where it dips below your cost per try. Usually that's a small number.

This page is an explainer without a cited primary source: its own source note says the model names and figures are illustrative, so the tier names Sol, Terra and Luna and the count of four parallel agents should be read that way. The structure it describes is real and documented in OpenAI's published system cards. The steps below separate what is documented from what the page assumes.

1. Route each request. A router estimates how demanding a request is and picks a model to serve it. OpenAI's GPT-5 system card (August 2025) describes this design: a fast model that answers most questions, a deeper reasoning model for harder problems, and a real-time router that decides based on conversation type, complexity, tool needs and explicit intent, such as a user asking it to think hard.
2. Serve cheaply by default. Most traffic is easy, so most requests stay on the fast model and average cost tracks it. The GPT-5 card adds that mini versions of each model take over once usage limits are reached.
3. Learn the routing from use. The same card says the router is trained continuously on real signals: when users switch models, preference rates for responses, and measured correctness.
4. Spend more on the hardest work, in parallel. For the hardest tasks, several attempts run on the same problem at once. The GPT-5 card describes a setting of its reasoning model that uses parallel test-time compute, called gpt-5-thinking-pro. The page's ultra mode with four agents is its illustrative version of the same idea.
5. Select with a verifier. A checker picks among the attempts. Where answers can be executed or checked, as with unit tests or a numeric answer, selection is reliable; where they cannot, the verifier is another model whose judgment can be wrong.
6. Evaluate the strongest configuration. A system card pairs capability results with safety evaluations. OpenAI's cards report Preparedness Framework assessments that rate tracked risk categories and gate release on safeguards; the GPT-5 card, for instance, treats its reasoning model as High capability in the biological and chemical domain as a precaution and activates the associated safeguards.

Where the independence assumption breaks

The page's arithmetic assumes every attempt is a fresh, independent draw with the same success probability p. Real attempts on one problem are not like that: they come from the same model, share its blind spots, and face the same difficulty. If a model cannot solve a problem at all, a hundred attempts fail together; if it always can, the second attempt adds nothing. What decides the value of extra attempts is the spread of per-problem success rates, not their average, and that spread is exactly what a single p hides. The equation below makes the correction exact.

The standard way to measure this respects the spread. The unbiased pass@k estimator introduced with OpenAI's Codex paper samples n attempts per task, counts the c that pass, and computes 1 − C(n − c, k) / C(n, k) for each task before averaging, so an impossible task contributes zero however many attempts are drawn, and an easy one saturates early.

• pi — the chance that one attempt solves task i; attempts are independent only once the task is fixed.
• p̄ — the average success rate, the single number the page's formula uses.
• Ei — the average over tasks. The inequality is Jensen's, because (1 − p)^^N is convex in p.
• Δ(N) — the coverage the N-th attempt adds, with a perfect verifier.

Equality holds only when every task is equally hard. At the other extreme, when each task is either always or never solved, pass@N equals p̄ for every N and extra attempts buy nothing. In between, coverage at small N is lower than the page's formula promises, while the gain from late attempts decays more slowly than geometrically, because the tasks still unsolved are the hard ones with a small chance per try. The limit is the share of tasks the model can solve at all, which no number of parallel agents raises.

This page reports no measurement of its own: its source note says it is not based on a published system card, and its tier names and agent count are illustrative. Two things can still be checked. The first is what a published card contains. OpenAI's GPT-5 system card (August 2025) describes the routed system above, then reports safety evaluations covering disallowed content, sycophancy, jailbreaks, instruction hierarchy, prompt injection, hallucination, deception, health, multilingual performance and bias, plus external red teaming. Its Preparedness Framework assessment covers three tracked categories, biological and chemical, cybersecurity, and AI self-improvement, with outside evaluations from groups including METR and Apollo Research. Its verdict was to treat the reasoning model as High capability in biology and chemistry as a precaution, activating safeguards, while saying it lacked definitive evidence that the model reached that threshold.

The second is the arithmetic. With an average per-attempt success rate of 0.6 and a perfect verifier, coverage depends on how that 0.6 is spread across tasks:

The negative result is in the middle column. Correlation lowers coverage at every N, but it also changes what an attempt is worth: the fourth adds about 0.038 under independence and about 0.052 in the mixed case, and the eighth about 0.001 against 0.012. When the unsolved tasks are the hard ones, late attempts keep paying, so where to stop depends on the spread of difficulty and the cost of a try, not on a universal knee at four. And a verifier that sometimes accepts wrong answers turns every extra attempt into one more chance to return one.

This is a system card: a vendor's description of a deployed system, with evaluations it selected. There is no reproducible method here, and the specific tier names and agent counts are product facts rather than findings. What is durable is the structure — difficulty-conditioned routing plus verifier-selected parallel attempts — and the arithmetic above, which follows from independence and diminishing returns rather than from anything proprietary.

The consequence that deserves more attention than it gets is evaluation. When a product routes queries to different models by estimated difficulty, "the model scored X" stops being well defined: two identical prompts may be served by different tiers, a benchmark may be routed differently from ordinary traffic, and a measured improvement may come from a better router rather than a better model. That is not a criticism of routing, which is obviously the right engineering — it is a warning that the unit of comparison has changed, and most published comparisons have not caught up.

What to watch: whether the gains come from the router or the underlying models, which requires per-tier numbers nobody currently publishes; and whether verifier quality becomes the reported bottleneck it logically is. Read this rung next to the open-weights model that exposes the same dial to the user — the two are the same idea with opposite defaults about who decides, and which one is preferable is a question about trust rather than about accuracy.

Work each one out before you open it — a number, a prediction or a reason, not a definition. Producing the answer is what makes it stick. Your progress is kept on this device.

Four papers that are reports, not methods: they state capability and withhold recipe. Read for the evaluation design and the omissions, not the architecture.

1. 1PaLM2022
2. 2GPT-4 Technical Report2023
3. 3Gemini 1.52024
4. 4GPT-5.6 System Card2026

All 110 papers, in 19 ladders →