OpenAI Strikes Back at Anthropic: GPT-6.1 Sol Nearly Matches Opus at 1/73 the Price

A Second Punch Within One Week

Anthropics Opus 5.5 landed to widespread acclaim, forcing OpenAI to rush out two models in quick succession — GPT-6 Sol and GPT-6 Luna — in damage-control mode. But according to well-known tech blogger Theo (t3.gg), neither of those initial releases was particularly impressive. The real weapon was what came next: GPT-6.1 Sol, released just one week after GPT-6 Sol.

The pacing itself sends a signal. Theo was blunt: a one-week gap between 6.0 Sol and 6.1 Sol makes it hard to treat this as a routine minor update. GPT-6.1 Sol is noticeably smarter than GPT-6 Sol, generates tokens more slowly (which typically implies a larger model), and all of this points to one conclusion — this isn't a simple snapshot update. Something fundamental changed under the hood.

As an early tester, Theo was explicit that he received no payment from OpenAI. The company could only decide when he could speak, not what he would say. He had just finished filming his Opus 5.5 review at 2 AM before immediately turning around to produce this piece — his goal was to deliver a firsthand take before the narrative solidified.

The Real Weapon Is the Price

The most stunning thing about GPT-6.1 Sol isn't its intelligence — it's the performance-to-cost ratio. On demanding benchmarks like Terminal Bench 4, it achieved what Theo called state-of-the-art results among everything he's tested. But the more jaw-dropping comparison comes from the DeepSWE benchmark: at the Low tier, GPT-6.1 Sol costs just $0.21, and achieves scores comparable to Astra at $1.46 (Low tier) and Opus 5.5 at $14.65 (Max tier).

That works out to roughly 73x cheaper than Opus for equivalent scores. Theo acknowledged that DeepSWE is far from a perfect measure of real-world model capability, but "same score, 73x cheaper" is something everyone should pay attention to.

The pricing details make this even clearer. GPT-6.1 Sol is priced at $2 per million input tokens and $10 per million output tokens — on par with GPT-6 Sol and Astra. The key differentiator is the cache read price: OpenAI has broken with convention by cutting cached read pricing from the usual 10% of the standard rate down to 5% — $0.10 per million tokens — effectively halving the cost of cache reads. Since 96% of requests in real agentic workloads are cache reads, this change dramatically reduces actual usage costs. Theo's assessment: OpenAI is almost certainly compressing its reportedly 95% profit margins.

The DeepSWE benchmark is a test suite designed to evaluate AI models' ability to autonomously complete software engineering tasks — things like independently fixing bugs and refactoring real-world code repositories. It's one of the most practically grounded benchmarks in use today. Its "Low/Max tier" refers to the maximum computational budget (token budget) a model is allowed to use when solving problems. The Low tier imposes strict limits and keeps costs down; the Max tier sets no ceiling and allows repeated attempts, so Max scores are typically higher but far more expensive. Achieving Low-tier scores of $0.21 against a competitor's Max-tier cost of $14.65 means GPT-6.1 Sol hits the competition's unconstrained performance under tight budget constraints — that's the real substance of the price advantage.

Agentic scenarios refer to situations where an AI model autonomously plans and executes multi-step tasks as an "agent," rather than answering a single question. These workflows repeatedly read the same context (such as large codebases or conversation histories), resulting in very high cache hit rates. By cutting cache read pricing from the standard 10% to 5%, OpenAI effectively cuts the overall call cost by nearly half again in real-world workflows where 96% of requests hit the cache — the impact on high-frequency automation is far greater than on conversational use.

Subscription Model Changes and "The End of the Subsidy Era"

Alongside the model release, OpenAI's Thiebaud dropped a long thread of tweets. Two key points: the $200 Pro subscription is back, and the usage calculation method has changed — by Theo's math, the new method effectively cuts the API-equivalent value of the old $200 Pro plan in half.

Theo's interpretation is telling. Previously, the $200 Claude Code subscription could generate $8,000–$9,000 in API-equivalent usage per month; Codex subscriptions could exceed $12,000. So why is OpenAI tightening subsidies at the exact moment Opus 5.5 is "good enough to trigger an internal code red"? The most logical inference: new models are coming, and their profit margins aren't as high. Continuing to subsidize at the same level would mean users' compute costs exceed their subscription fees. He believes this may mark the beginning of the end of the "subsidy era."

No More "Brilliant and Stupid at the Same Time"

The thing that frustrated Theo most about Astra was its "spikiness" — it could outperform Anthropic's best models in one breath, then collapse into the most nonsensical output imaginable without warning, bad enough that he nearly abandoned it entirely. GPT-6.1 Sol shows clear improvement here: its ceiling isn't as spectacular as Astra's (weaker on 3D tasks, slightly below Opus 5.5 in most scenarios), but its consistency is dramatically better.

Theo gave a particularly convincing example: he had GPT-6.1 Sol go through his emails, find investment-related bills he'd forgotten to pay or that were overdue, then open tabs in Chrome for each pending wire transfer with all the details filled in, ready to send with a single click. Not a single error — and it proactively flagged items he would have missed. "I'm actually trusting it with wiring money now," he said — something he'd never dare do with Astra given its spikiness. Other testers Julius and Ben echoed this: Julius called it "incredible," while Ben said it was "incredibly boring" — and for a model release, "boring" is about the highest praise you can give.

Spikiness is Theo's term for a model with excessively high variance in performance — it can exceed same-tier models on certain tasks, then produce absurdly wrong answers on seemingly simple ones, with no discernible pattern. For agentic workflows that need to run unattended for extended periods, spikiness is catastrophic: a single unexpected "smart failure" can crash an entire multi-step task chain mid-execution, wasting huge amounts of tokens or requiring a complete restart. This is exactly why "boring" is a highly positive evaluation in model testing contexts — it means the model's behavior is predictable, its failure modes are known, and you can safely hand it automated processes.

Efficiency Edge: Doing More With Fewer Tokens

GPT-6.1 Sol isn't just cheaper per token — it also maintains OpenAI's characteristically high token efficiency. In the T3 code improvement test, it scored 87.4 (vs. Astra's 83.8 and Grok 4.7's 80.7), at a cost of just $2.15, compared to $5 for Opus 5.5 and nearly $9 for Sonnet 5.5.

A striking comparison: GPT-6.1 Sol completed three rounds of work for less than half the cost of Sonnet doing it in a single round. The reason is that it reads an average of roughly 110,000 tokens per request, while Sonnet 5 requires about 360,000. Even better: Theo had Opus 5.5 blindly evaluate this anonymous model, and Opus immediately rated it "Frontier tier," estimating it should be priced around $5 per million input tokens. When told the actual price was $2 input and $0.10 cached read, Opus's response was "very aggressive pricing" — and when it recalculated the actual cost, it found the real spend was only one-quarter of its original estimate.

The dramatic difference in token consumption between models solving the same task comes down to context bloat — some models tend to pack the full conversation history, intermediate reasoning chains, and redundant tool call results into every request, causing input tokens to grow exponentially. GPT-6.1 Sol averaging ~110K tokens per request versus Sonnet 5's ~360K is a 3x+ gap, meaning the former achieves equivalent quality output with far higher "intelligence density" per token. For agentic coding tasks requiring repeated model calls, this gap compounds with each iteration, ultimately manifesting as dual advantages in both cost and speed.

Obvious Weaknesses: Frontend and Long-Running Tasks

GPT-6.1 Sol isn't without hard flaws. In Theo's signature "fish slop" test (a simulated aquarium game), it wrapped the game in excessive bad UI and filler copy — phrases like "take a breather" appeared more than twenty times. The visuals were genuinely impressive (better fish and submarine models), but the gameplay felt noticeably choppier than the Opus and Sonnet versions, with lower frame rates. Theo was blunt: "This model is atrocious at UI and design, completely tasteless — you need to bring your own aesthetic sensibility."

The other critical weakness is long-running, unattended rewrite tasks. Theo's TypeScript-to-Rust migration project had been stuck for months using Astra and Sol, burning hundreds of thousands of dollars in tokens with nothing to show for it. Opus 5.5 then restarted the whole thing from scratch using two Claude subscriptions and finished in a single night. Even more dramatic: a post-mortem audit by GPT-6.1 Sol revealed that 1.3 million of the 1.8 million lines of code weren't being used at all — because Opus had judged everything written by the other agents to be unsalvageable garbage and started fresh in a new crate. GPT-6.1 Sol then had to be brought back in to clean up the leftovers Opus hadn't noticed.

Best Use Case: The "Review and Investigation" Partner

Theo's final verdict is to use them in combination. GPT-6.1 Sol has a "Rottweiler-like" relentlessness in code review, deep audits, and root cause analysis — it uncovers real bugs that both Opus and Fable miss. Opus, meanwhile, is a more pleasant collaborator for actually writing code, with far fewer stalls. He's already configured his Claude Code setup so that Opus 5.5 can call GPT-6.1 Sol for investigation and review work.

His position is clear: this is an excellent model at a remarkable price point, and it could easily become the default coding model for many people — making Sonnet largely irrelevant to him personally. But it hasn't displaced Opus 5.5 from its position as his everyday workhorse, so he won't be canceling any Claude subscriptions; he'll simply be calling Codex more often from within Claude Code.

If your work falls squarely in GPT-6.1 Sol's wheelhouse, you can probably use it end-to-end. If not, keep using Opus — and let Opus call GPT-6.1 Sol when appropriate. That's the highest-value setup available right now.

Claude Code is Anthropic's AI coding assistant product, which supports calling multiple models under a subscription plan and allows users to preset rules in configuration files (such as CLAUDE.md), specifying which model handles which subtask. When Theo describes "having Opus 5.5 call GPT-6.1 Sol within Claude Code," he's leveraging Claude Code's orchestrator mechanism: Opus 5.5 serves as the primary model, decomposing tasks and handling coding, and when deep auditing or root cause analysis is needed, it automatically routes those subtasks to GPT-6.1 Sol accessed through the Codex subscription. This "primary writer + precision auditor" division of labor maximizes the distinct strengths of both models while controlling costs — and represents a typical example of multi-model collaborative workflows in practice today.