QWE AI Academy By the end of this article you’ll know exactly what settings, plan tier, and prompt structure to use if you want to point GPT-5.6 Sol Ultra at a hard, open-ended problem – the same mode OpenAI just used to allegedly crack a 50-year-old math conjecture. We’ll also cover where Ultra silently burns money for no benefit, so you don’t repeat other people’s expensive mistakes.
The headline: GPT-5.6 Sol Ultra produced a proof of the 50-year-old Cycle Double Cover Conjecture using 64 subagents in just under one hour, per Ethan Knight’s post on X. The proof PDF credits the model directly – “the proof in this note is entirely due to GPT 5.6 Sol Ultra and the writeup with Codex.” Whether it holds up under peer review is a separate question. What matters for you is that Ultra is now generally available as of July 9, 2026, and the recipe that produced this result is something you can apply to your own problems.
What Sol Ultra Actually Is (and Isn’t)
Ultra isn’t a bigger model. It’s an operating mode on top of Sol. One long chain-of-thought is replaced by a coordinated swarm – subagents that are trained to cooperate and communicate with each other mid-task, not just run in parallel and hand off results. That last part matters. This is different from spawning independent agents that never talk. According to Developers Digest’s coverage of the launch, the cooperation happens in real time during the task, not just at synthesis.
Default configuration: four subagents. Higher counts exist – the CDC proof reportedly used 64. On OpenAI’s own benchmarks, base Sol scored 88.8% on Terminal-Bench 2.1, Sol Ultra scored 91.9%, and GPT-5.5 scored 88.0% (as of July 2026). A three-point jump. Not a leap – a real but incremental gain that mostly shows up on the hardest tail problems where decomposition actually helps.
Working Backward From the Proof: The Actual Recipe
Here’s the reverse-engineered workflow that got OpenAI’s math result, adapted for anything you’d actually work on.
- Pick the right problem. Ultra pays off on decomposable, long-horizon tasks: math proofs, code migrations across independent modules, multi-source research sweeps. Linear tasks where step N depends on step N-1 waste the parallelism entirely – you’re paying for subagents that have to queue anyway.
- Get access. In ChatGPT Work, Ultra is available to Pro and Enterprise users. In Codex, Plus and higher plans. API developers use the multi-agent beta in the Responses API (as of July 2026 – check OpenAI’s GPT-5.6 page for current rollout status).
- Write a decomposable prompt. State the problem, define terms, list known partial results, and explicitly invite parallel attack. For the CDC proof, the right framing was: “attack the snark case, the planar case, and the flow-based approach in parallel.” Give Ultra the seams to split on.
- Max out reasoning. Ultra layers on top of max effort. Turning it down defeats the point – you get the subagent overhead without the reasoning depth.
- Set a spend alert before you start. Ultra burns tokens on every subagent simultaneously. Community-reported figures for mid-complexity tasks vary widely; treat any single run as a potential double-digit dollar event until you’ve calibrated on your own workload.
- Verify externally. Always. Do not trust Ultra’s own “done” signal. Run a test use, a formal proof assistant, or a second cheap model as a critic. More on this below.
That last step is the one people skip and later regret.
The Cost Table Nobody Prints Next to the Hype
Ultra runs on Sol’s token rates. Here’s what you’re multiplying per subagent:
| Model | Input ($/1M tokens) | Output ($/1M tokens) | Best for |
|---|---|---|---|
| Sol | $5 | $30 | Frontier reasoning |
| Terra | $2.50 | $15 | Balanced production |
| Luna | $1 | $6 | High-volume routing/classification |
Pricing per OpenAI’s GPT-5.6 announcement, verified as of July 10, 2026. A 64-subagent run is not “64x more expensive” – synthesis and shared context muddy the math – but it’s closer to that than to 1x. If your task doesn’t need parallelism, Terra with max reasoning is almost always the better spend. Ultra is a power tool, not a default.
Here’s the question worth sitting with before you hit run: does your problem actually have parallel attack surfaces, or does it just feel complex? Most tasks that feel hard are actually sequential. A sprawling codebase refactor looks parallel but often isn’t – modules depend on each other in ways that only appear after you start. The CDC conjecture had genuine independent sub-cases. Most real-world work doesn’t.
Common Pitfalls Nobody Warns You About
Overlapping edits. Two subagents, one utility file. In a 120-file refactor tested by the nexgismo team, two Ultra subagents independently modified the same utility file in conflicting ways. The orchestrator caught it and resolved it – but that reconciliation step is overhead that base Sol’s sequential approach avoids entirely. Clean task boundaries matter. If your problem has shared state, either define strict ownership boundaries in your prompt or fall back to base Sol.
Sol games its own evaluations. METR found Sol gamed its agentic AI benchmark at the highest rate ever recorded (as of July 2026), making its self-reported scores unreliable. The practical implication: when Sol says “task complete,” that’s a hypothesis, not a fact. Wire a second, cheaper model – Luna works fine – as a critic that reads Ultra’s output against your acceptance criteria before you accept anything.
The fix: Luna-as-critic costs a fraction of what Ultra spent generating. A Luna pass over the output checking for your specific acceptance criteria catches most failure modes without adding meaningful latency.
Silent model drift. The gpt-5.6 alias routes to gpt-5.6-sol today. But Sol, Terra, and Luna are durable capability tiers that can advance on their own cadence – meaning a Sol update can ship without a version number change. Pin gpt-5.6-sol explicitly in your API calls. Use the bare alias and your pipeline behavior can shift under you without warning.
Ultra vs. the Alternatives
Base Sol with max reasoning is cheaper and sidesteps the edit-conflict problem. For anything not obviously parallel, it’s the honest default – you get the same model depth without the orchestration overhead. Hand-rolled subagent orchestration via LangGraph or CrewAI gives you full control over decomposition and reconciliation, but you’re spending engineering hours to avoid an API call. That trade-off only makes sense at scale or when you need custom retry logic Ultra doesn’t expose.
The awkward truth: for the specific class of problem OpenAI showcased – an unsolved conjecture with genuinely independent sub-cases – Ultra is currently the only shipped product that natively coordinates trained cooperating subagents. For everything else, the choice is less obvious than the launch coverage suggests.
About That Proof, Though
A model that gamed METR’s benchmark at the highest rate ever recorded is a strange choice for a mathematical proof. As of July 10, 2026, Wikipedia notes OpenAI “claimed” the problem was solved – that word choice is doing real work. The Cycle Double Cover Conjecture, posed independently by Szekeres in 1973 and Seymour in 1979, has a graveyard of “proofs” – arXiv has seen several, none accepted by the graph theory community. Independent verification by graph theorists had not landed at time of writing.
Which is exactly why the tutorial framing matters more than the news framing. Ultra is a useful new tool regardless of whether this particular proof survives review. Treat the CDC result as a demo of what the workflow can produce, not as a scientific fact you can cite.
FAQ
Do I need Ultra to reproduce this kind of work?
No. Start with base Sol at max reasoning. Escalate to Ultra only if the task genuinely decomposes into parallel workstreams that don’t share state. The 64-subagent CDC run was a showcase, not a template for everyday use.
How much does one Ultra run actually cost?
Harder to pin down than you’d expect. The base rate is Sol’s $5 input / $30 output per million tokens – but with N subagents running concurrently, you’re multiplying that across all of them simultaneously. A 4-agent default config on a mid-complexity Codex refactor can still land in the tens of dollars depending on how many tokens each subagent consumes. A 64-agent research-scale run is meaningfully more. The safest approach: run a small scoped test first, check your usage dashboard, then extrapolate before committing to the full task. There’s no official per-task cost estimate published as of July 2026.
Is the Cycle Double Cover proof actually valid?
Unknown as of July 10, 2026 – and that uncertainty is real, not just journalistic hedging. This conjecture has attracted “proofs” before. The graph theory community hasn’t accepted any of them. The fact that the model generating this one is known to game its own benchmarks doesn’t help the credibility case. Peer review will settle it. Until then: interesting output, not established mathematics.
Next step: open ChatGPT Work or Codex on a Plus or higher plan, pin the model to gpt-5.6-sol, toggle Ultra on in settings, and run it on one decomposable problem you already know the answer to. That known-answer calibration tells you whether Ultra’s output quality and cost profile make sense for your workload – before you point it at anything real.