I Traced 8 GPT-6 Claims. Spud Was GPT-5.5; the Real Signal Came in July.

On July 21, OpenAI quietly published the strongest post-GPT-5.6 signal we have seen.

The headlines that followed said:

• "Spud was GPT-6."
• "GPT-6 is about to launch after a White House preview."
• "The new model is a swarm of agents."

The first claim is wrong. The second is unsupported. The third comes from credible reporting, but still isn't an API specification.

I spent the last few days tracing the claims back to OpenAI's model catalog, its GPT-5.6 launch page, its security-incident report, and the reporting around the Washington briefings. Here is what survived.

TL;DR

• NO: Spud was not GPT-6. OpenAI shipped Spud as GPT-5.5 on April 23, 2026.
• YES: a model beyond GPT-5.6 Sol exists. OpenAI acknowledged an unnamed, more capable pre-release model in a July security report.
• NO: GPT-6 has not been announced. There is no official date, price, API ID, context window, benchmark table, or system card.
• Reports about persistent groups of parallel agents are credible enough to watch, but they are not confirmed product documentation.
• I wouldn't migrate anything today. I'd build the evaluation harness and wait for five official artifacts.

The Spud rumor has an answer now

Spud used to be interesting because it was an internal codename with no shipping name. That ambiguity ended on April 23.

Axios reported that OpenAI released GPT-5.5, codenamed Spud. The cleanest way to describe the situation is:

Claim	Verdict	Why
Spud was a real OpenAI codename	Confirmed	It appeared before the product shipped
Spud became GPT-5.5	Confirmed	The launch settled the name
Spud is still a GPT-6 clue	False	It already maps to a released model
Old Spud specs describe GPT-6	Unsupported	OpenAI has published no GPT-6 specs

I keep seeing new rumor pages cite old Spud posts as though April never happened. That's not forecasting. That's stale data wearing a new title.

The real signal arrived in July

The useful evidence is not a codename leak.

In its Hugging Face model-evaluation security incident report, OpenAI said an evaluation involved GPT-5.6 Sol and an even more capable pre-release model.

That sentence confirms three things:

1. A model beyond Sol exists in evaluation.
2. OpenAI considers it more capable in the context being discussed.
3. The model is still pre-release.

It does not confirm:

• that the name is GPT-6;
• that the model will ship unchanged;
• that it launches in August;
• that it has a particular context window;
• that it costs more than Sol;
• that any benchmark score posted online belongs to it.

I think this distinction is the whole story. We have stronger evidence than a leak and much weaker evidence than a launch.

The Washington briefing is a checkpoint, not a countdown

Axios reported that Sam Altman was heading to Washington to preview OpenAI's most powerful AI yet. Bloomberg Law separately reported planned briefings on an upcoming generation of AI models.

That's meaningful. It says the system is far enough along for senior government review.

But I don't translate "government preview" into "public API next week." GPT-5.6 itself went through a limited trusted-partner preview before broad rollout. A review can end in:

• broad release;
• a restricted release;
• additional mitigations;
• a renamed product;
• a delay;
• a model that never ships in its evaluated form.

Evidence	What I think it means	What it cannot tell us
OpenAI confirms a stronger pre-release model	Successor-class work is real	Commercial name
Officials receive a preview	External review is active	Release day
Lawmakers get briefings	Policy coordination is active	API availability
No catalog entry exists	Developers cannot use it publicly	Whether it ships later

The model catalog remains boring, and boring is good. As of July 28, it lists GPT-5.6 models and no GPT-6.

The "swarm of agents" claim needs careful wording

Axios also described OpenAI's next model as using large groups of agents that work together persistently on difficult tasks.

I'm watching this more closely than the name.

If that behavior ships, the developer question isn't "Is the benchmark 4 points higher?" It is "What is the unit of work?"

A single user task could fan out into many internal workers. That creates unanswered questions:

• Are you billed by visible tokens or total worker tokens?
• Do tool calls have separate charges?
• Can you cap worker count?
• Can a task resume after failure?
• Does one request consume minutes of compute?
• Which usage fields expose fan-out?

Until OpenAI publishes those fields, "one prompt" is not a cost estimate.

I used GPT-5.6 as the only numeric baseline

GPT-6 has no official price. So I refused to make one up.

OpenAI's published GPT-5.6 rates are enough to build budget boundaries:

Model	Input / 1M	Output / 1M	Cache read / 1M
GPT-5.6 Sol	$5.00	$30.00	$0.50
GPT-5.6 Terra	$2.50	$15.00	$0.25
GPT-5.6 Luna	$1.00	$6.00	$0.10
Unnamed pre-release model	Not published	Not published	Not published

Here is the first wallet translation.

For 10 million input tokens and 1 million output tokens per month:

Sol   = 10 × $5.00 + 1 × $30.00 = $80
Terra = 10 × $2.50 + 1 × $15.00 = $40
Luna  = 10 × $1.00 + 1 ×  $6.00 = $16

If a successor costs 25% more than Sol, that same workload would be $100. At a 50% premium, it would be $120.

Those are scenarios. They are not predictions.

The second wallet translation is caching. Suppose a Sol workload uses 50M input and 5M output tokens monthly, with 80% of input served as cache reads:

Uncached input: 10M × $5.00  = $50
Cached input:   40M × $0.50  = $20
Output:          5M × $30.00 = $150
Total:                           $220

Without cache: 50M × $5 + 5M × $30 = $400
Saving: $180/month, or 45%

That $180 matters more to my production plan than an invented release date.

The GPT-6 decision tree I would actually use

I wouldn't feature-detect a rumor. I'd require documentation and then gate traffic by economics.

def canary_next_openai_model(official, evaluation):
    required = {
        "model_catalog_entry",
        "pricing_page",
        "api_schema",
        "usage_fields",
        "system_card",
    }

    if not required.issubset(official):
        return "NO: keep it inside an isolated evaluation."

    if evaluation["cost_per_success"] >= evaluation["sol_cost_per_success"]:
        return "HOLD: the new model did not beat Sol economically."

    if evaluation["p95_latency_ms"] > evaluation["latency_budget_ms"]:
        return "HOLD: quality improved, but your SLA failed."

    if not evaluation["safety_regressions_passed"]:
        return "HOLD: the behavior contract changed."

    return "CANARY: send 1% of eligible traffic with a hard spend cap."

I expect people to disagree about the thresholds. Good. The thresholds should belong to your product, not to a benchmark leaderboard.

What I'd do if I ran an OpenAI production stack today

If I use GPT-5.6 Sol

1. Freeze a private task suite now.
2. Record Sol's cost per successful task, not just cost per token.
3. Capture p50, p95, and p99 latency by region.
4. Track cache-hit share and tool-call count.
5. Keep production routing unchanged.

If I use Terra or Luna for budget reasons

1. Don't assume a frontier successor is a migration target.
2. Compare the new model against your current cheap tier.
3. Require enough quality gain to pay for the price difference.
4. Keep a per-request and per-task spend ceiling.

If I build agent systems

1. Log every tool step and retry.
2. Add a wall-clock timeout.
3. Cap parallel workers when the API allows it.
4. Reject a launch-day integration that hides usage fan-out.
5. Test resumability and partial failure before production.

The bigger picture

The naming game is becoming less useful.

OpenAI just shipped three GPT-5.6 tiers with different economics. The next release could be GPT-6, another GPT-5.x tier, or an agent product with a model hidden underneath. The architecture of the bill may matter more than the number in the name.

I think the real pre-release question is:

Does the new system expose enough controls to make a long-running multi-agent task predictable?

If the answer is no, a stronger model can still be a worse production dependency.

If you want to swap between OpenAI, Anthropic, Google, and other models through one OpenAI-compatible endpoint, that's roughly what TokenMix does. Disclosure: I work on the research side. The full table-heavy, source-cited breakdown is in the original GPT-6 evidence audit.

Bottom line

Spud is GPT-5.5. GPT-6 is not announced. The real development is that OpenAI itself has acknowledged an unnamed pre-release model beyond GPT-5.6 Sol, while credible reporting points to government review and persistent agent behavior.

I am preparing tests, not a migration.

What would you require before enabling a model that can fan one task out across many persistent agents: a worker cap, a task price ceiling, or full token-level usage logs?