GPT-6.1 Sol In-Depth Review: OpenAI Strikes Back at Opus 5.5 with Ultra-Low Pricing

OpenAI's Swift Counterpunch

After Anthropic's release of Opus 5.5 sent shockwaves through the industry, OpenAI responded by launching multiple models within a single week. The first two — GPT-6 Sol and GPT-6 Luna — landed with a muted reception, but the real headliner came shortly after: GPT-6.1 Sol.

According to hands-on testing by a YouTuber with early access, GPT-6.1 Sol went live just one week after GPT-6 Sol — an unusually compressed release cadence that signals something significant. The implication is that this model likely wasn't always called "6.1," but was rather an internal emergency response to Opus 5.5, hastily rebranded and pushed out.

The technical signs back this up: 6.1 is "significantly smarter" than GPT-6 Sol, and its token generation speed is noticeably slower — which typically indicates a larger model. These aren't the hallmarks of a minor patch release; they point to a fundamentally different model under the hood.

The Real Weapon Is the Pricing

The most jaw-dropping aspect of this model isn't its capabilities — it's the pricing strategy. GPT-6.1 Sol is priced at $2 per million input tokens and $10 per million output tokens, one-fifth the cost of Astra.

But the true nuclear option is the cache read pricing. OpenAI had historically kept cache read prices at 10% of standard input pricing (a 90% discount). This time, they dropped it to $0.10 per million tokens — a 95% discount — effectively cutting cache costs in half.

This matters enormously. The reviewer cited Opus's own analysis showing that 96% of real-world agent workloads consist of cache reads. In other words, the cache price is far more important than the headline $2/$10 figures. In practice, when the reviewer asked Opus 5.5 to estimate costs across all his sessions, the old estimate came to $5,700 — recalculated at new prices, it dropped to just $1,550.

The reviewer inferred that OpenAI's historically massive margins (spending $0.50 to charge $10) are being squeezed, possibly marking the beginning of the end of the "subsidy era." There are also reports that the Pro $200 subscription is returning, but with a different usage calculation that nets out to roughly half the API spend value of the old plan.

Cache read is a critical mechanism in LLM API pricing. When the same context — such as a system prompt, a long document, or a codebase — is repeatedly sent to a model, providers can store it in a high-speed cache and serve subsequent requests directly from that cache, dramatically reducing compute overhead. For agent workflows, each step typically carries the full task context and history, meaning the vast majority of tokens in any given API call are repeated cached content. This is why cache read pricing has an outsized impact on real-world agent costs compared to the headline input/output rates. With 96% of tokens being cache reads, raising the discount from 90% to 95% effectively cuts that portion of cost in half — meaning the actual bill reduction can be far larger than the headline price changes suggest.

Benchmarks: Equal Scores at a Fraction of the Cost

On Terminal Bench 4, GPT-6.1 Sol posted one of the highest scores the reviewer had ever seen, surpassing all previous models even at the High and X High tiers.

The cost comparison is even more striking. On the Deep SWE benchmark, 6.1 Sol at the Low tier achieved the same score as Astra at Low ($1.46) and Opus 5.5 at Max ($14.65) — for just $0.21. The reviewer completed the entire benchmark in 4.8 minutes for $0.21, while Opus 5.5 at Max took 50 minutes per task: one-tenth the time, one-seventieth the cost, for the same score.

The reviewer was candid about his growing skepticism of benchmarks, especially after running so many himself. These numbers are impressive, but they don't necessarily reflect real-world day-to-day coding performance.

Terminal Bench and Deep SWE are widely used coding capability benchmarks. Terminal Bench evaluates a model's ability to complete real engineering tasks in a terminal environment — debugging, file operations, command-line interactions. Deep SWE (Software Engineering) focuses on tasks closer to real software development, such as code modification, bug fixing, and repository-level comprehension. These benchmarks are more grounded in engineering practice than traditional math or QA tests, but they're also more susceptible to benchmark contamination or targeted optimization — where a model scores brilliantly on the evaluation but doesn't hold up under everyday development conditions. The reviewer remained appropriately skeptical, relying primarily on real-task performance as his final measure.

Real-World Performance: Goodbye to "Smart and Stupid at the Same Time"

The most frustrating thing about GPT-6 Astra wasn't that it wasn't smart enough — it was that it was "smart and stupid at the same time." It would suddenly make embarrassingly basic mistakes without warning. This "spikiness" was severe enough that the reviewer nearly gave up on it entirely.

GPT-6.1 Sol shows clear improvement here. The reviewer felt confident enough to let it go through all his emails, track down missing invoices, open browser tabs in Chrome for each investment, and fill in wire transfer details — "not a single error," and it proactively flagged things he would have missed. His words: "I actually trust this model to wire transfer money." Fellow testers Julius called it "incredible," while Ben described it as "boring as hell" — which, for this kind of model release, is the highest possible praise.

On code review, 6.1 Sol embodies the classic OpenAI "Rottweiler" instinct — it clamps down on problems and digs out every flaw. In an Orchestrator V2 audit, it performed nearly identically to Astra at $297 versus $584. On the T3 code improvement task, it scored 87.4, beating Astra (83.8) and Grok 4.7 (80.7), at just $2.15 — well below Sonnet's ~$9 or Opus's $5.

Clear Weaknesses: Frontend and Long-Running Tasks

The "Fish Slop" game generation test exposed serious problems. While the 3D graphics fidelity was impressive (better fish, submarine, and propeller models), 6.1 Sol surrounded the game with "absolutely garbage UI," littered with unnecessary copy — over twenty lines of things like "Take a break" and "Your little world can wait."

The reviewer was blunt: this model is terrible at frontend and design, with zero aesthetic sense. If you want decent frontend work, spend your money elsewhere.

Gameplay feel was also noticeably worse than the Opus and Sonnet versions — choppy movement, lower frame rate. That said, it performed impressively in Blender modeling — given a screenshot, it built a solid 3D model via CLI.

The other major weakness is long, unattended rewrite tasks. The reviewer's TypeScript-to-Rust migration project had burned months of effort and hundreds of thousands of tokens with Astra and Sol and gone nowhere; Opus 5.5 completed a full rewrite overnight using two subscriptions and approximately $1,000. 6.1 Sol on this kind of task "stubbornly follows procedural rules, even when completely stuck, without asking for help."

The TypeScript-to-Rust migration the reviewer describes represents a special class of AI programming challenge: large-scale unattended rewriting. Unlike step-by-step interactive coding, these tasks require a model to autonomously plan, execute, and flexibly adapt when it hits obstacles — potentially for hours on end. This demands a high degree of metacognition: the model must recognize when it's stuck in a loop and know when to stop and ask for help. 6.1 Sol's tendency to "stubbornly follow procedural rules" in these situations reveals a fundamental trade-off in current models between autonomy and adaptability: models with high rule-compliance tend to be stable and predictable, but struggle to think outside the box when faced with non-standard situations.

Best Use Case: Tag-Teaming with Opus

The reviewer's conclusion: 6.1 Sol can serve as a default coding model, but he still prefers Opus 5.5 as his daily driver.

The optimal workflow he landed on is to use both in tandem: Opus 5.5 for the actual coding (better collaborative partner, less likely to get stuck), and 6.1 Sol for review, deep-diving into details, root cause analysis, and codebase investigation. A telling example: after Opus rewrote the TS-to-Rust migration, 6.1 Sol's review found that 1.3 million of 1.8 million lines of code were completely unused — Opus had judged other agents' code as garbage, rewritten everything from scratch, but never cleaned up the old code. 6.1 Sol was then dispatched to clean up the mess.

As for Sonnet, the reviewer is clear: 6.1 Sol will effectively take its place. He'll update his Claude configuration to have Opus call 6.1 Sol at the right moments for reviewing work and investigating codebases.

This is "a remarkable release" that delivers strong capabilities at highly competitive pricing. But it hasn't displaced Opus 5.5 as the daily driver, and the reviewer has no plans to cancel any Claude subscriptions. The deeper implication: this aggressive pricing move may genuinely mark the beginning of the end of the AI model subsidy era.