Every's 9-Person Team Spent a Month With It: How Good Is GPT-5.6 Sol, Really?
- OpenAI released its next-gen model GPT-5.6 Sol, priced at $5 per million input tokens and $30 per million output tokens — matching Claude Opus 4.8 on input, $5 pricier on output. Alongside it came two new tiers: mid-range Terra ($2.50 / $15) and lightweight Luna ($1 / $6).
- OpenAI says Sol set a new record on Terminal-Bench 2.1 (a command-line agent task benchmark), and also outperforms the prior-gen GPT-5.5 on long-horizon biology benchmarks and cybersecurity tests.
- Nine members of Every's editorial team tested it for a month: Sol ranked last of six models in Every's own writing blind test, with the lowest readability score too. But it scored 56/100 on their homemade code-refactoring benchmark (Claude Fable 5 scored 90/100) — a gap driven mainly by over-engineering simple requirements, not a lack of raw capability.
- OpenAI also merged the ChatGPT and Codex desktop clients into a single unified app, and added two new reasoning settings — max (extended thinking for a single agent) and ultra (multiple agents collaborating on one task).
OpenAI Just Dropped Three Model Tiers at Once
OpenAI recently released its next-gen model GPT-5.6 Sol, alongside two new tiers — mid-range Terra and lightweight Luna — and merged the ChatGPT and Codex desktop clients into a single unified app.
Three tiers in one shot: flagship Sol, mid-range Terra, lightweight Luna. OpenAI calls Sol its "most capable model yet," claiming a new record on the command-line agent benchmark Terminal-Bench 2.1, and its strongest cybersecurity performance to date.
OpenAI says the names Sol, Terra, and Luna will stick around long-term as "capability tiers," even as the models behind each tier keep evolving. This section just sets up the positioning of the three tiers; pricing and reasoning-mode details come later. Terminal-Bench 2.1, for context, tests whether an AI can plan its own steps, iterate through trial and error, and call various tools to complete a task from start to finish in a command line — simulating how a real engineer works in a terminal.
Alongside the launch, OpenAI merged the ChatGPT and Codex desktop clients into a single app: ChatGPT Work handles most knowledge work, while Codex gets its own dedicated tab for technical work. It's seen as a step toward pulling ChatGPT's 800-million-plus users into "letting AI handle multi-step tasks on its own" — agentic mode.
One Month Without It, and the Team Says It Felt Like the Stone Age
Every is a US-based AI media company that also builds AI products — publishing deep analysis while shipping its own tools. Its editorial team regularly puts frontier models through hands-on testing, and this "vibe check" series is their signature format. By the time this review went live, Sol had already been living inside Every's daily workflow for about a month — deeply enough that losing it actually hurt.
During that month, Sol was everywhere. It helped Dan Shipper keep his inbox at zero, tracking decisions scattered across meetings and Slack that he'd otherwise have missed. It kept pace with Austin Tedesco — from a marketing idea, to an email, to a landing page, to an experiment — without him ever having to repeat himself or lose his train of thought. For this piece's author, Katie Parrott, it fetched files and pulled context so fast it completely rewired how she worked with models day to day.
In late June, Sol went offline for a round of government review, and the team lost access. Dan said going back to other models — even with Fable still on hand — felt like regressing to the Stone Age. Austin compared switching to GPT-5.5 to "shooting a basketball that's twice as heavy as usual." Every had earlier floated an idea in its Sonnet 5 review — "a revolution of ever-rising expectations" — and this Sol-less stretch proved exactly that: how fast people adapt to a higher standard of living, and how painful it is to slide back.
Going back to other models, even with Fable still around, felt like regressing to the Stone Age.
Using GPT-5.5 felt like shooting a basketball twice as heavy as the one I'm used to.
Dan has a sharper analogy: Sol is a Porsche, Fable is a warp drive. Fable can obviously carry you across an entire galaxy, but most of the time you're not headed to space — you just want to get around town, and Sol is the car that makes that drive feel good.
Nine People, Nine Honest Takes
Every's "Reach Test" has nine team members, each in a different role, give one honest line on Sol along with a sentiment rating. At a glance, it's clear this reliance isn't just for show.
Eight of the nine cards lean positive; one (Arielle) sits at "fine" after a late-stage calculation error. That overall lean explains why the team is willing to treat it as a daily driver. What it's actually good at, and where it falls short, gets broken down section by section below — coding, writing, and knowledge work.
It Can Carry the Load — It Just Doesn't Know When to Stop
In day-to-day development, Sol is a genuine upgrade over GPT-5.5: it can chase a bug through an unfamiliar production codebase, carry a large project from start to finish, and keep testing well past where other models would give up. Several engineers on the team have already made it their daily driver. Its limit shows up on tasks that require the model to judge, on its own, what it shouldn't do.
Every has a benchmark called Senior Engineer: hand the model a real but messy collaborative codebase and ask it to judge, like a senior engineer would, what the system should be rewritten into — specifically testing whether it knows when to stop and avoid over-engineering. On this benchmark, Sol scored 56; Claude Fable 5 scored 90.
Sol's strength is execution; its weakness is restraint. It can read an entire architecture and carry out a full system rewrite start to finish — it just can't stop building once it's built enough. Roughly 12,900 lines of code, spread across four collaborating processes: each individual addition made sense on its own, but together they produced far more complexity than the task called for. When Dan reviewed the results, he traced nearly the entire gap with Fable to the two scoring categories that reward simplification and penalize unnecessary machinery. Every even argues that 56 understates Sol — the score largely reflects the benchmark penalizing its tendency to overcomplicate things.
Where the Goal Is Clear, It Shines
On the flip side, when the target is well-defined, Sol's execution holds up. The strongest production case came from Naveen Naidu, who used Sol in daily development on his own product, Monologue: GPT-5.5, even at its highest reasoning setting, failed repeatedly to root-cause a note-recording bug; Sol traced the failure through the existing codebase and fixed it. Kieran Klaassen also had Sol and Fable rebuild the team's collaborative document editor, Proof, from a single prompt — Sol delivered a working Proof-like app in roughly a third of the time (though Dan preferred Fable's version on design). Sol also finished a digital audio workstation that GPT-5.5 hadn't been able to complete.
These results line up with the team's overall impression: once the desired system is clear, Sol is fast, resourceful, and genuinely capable at implementation. When "judging what not to build" is the main engineering task, Fable remains the first choice; once direction is set, handing execution to Sol is usually the path of least friction.
Last Place in the Writing Blind Test, Yet the Team's Most Indispensable Partner
In Every's writing benchmark, Sol ranked last of six models — its prose was the hardest to read, and its editorial choices strayed furthest from the published reference version. And yet the whole team overwhelmingly prefers using it for daily writing, over both Sonnet 5 and Opus 4.8. The answer lies in a framework that runs through the entire piece.
Every splits working with AI into two modes. One is "delegation": hand off the task, walk away, and come back to review a finished deliverable. The other is "collaboration": stay in the loop the whole time while the model rapidly serves up options and you make the calls in real time. Sol's speed, responsiveness, and skill with context make it the team's preferred place to be for collaborative work. The biggest, vaguest tasks — where just figuring out what to do eats up most of the effort — still go to Fable. This "delegation vs. collaboration" divide is the answer to why Sol bombs the writing blind test yet gets used the most day to day.
Delegation is like handing an entire project to a direct report and reviewing it when it's done; collaboration is like sitting side by side with a colleague editing the same document, jumping in to redirect at any moment. Sol is the great side-by-side editing partner; Fable is the one who can carry an entire project alone.
All four scenarios tested — coding, writing, knowledge work, and agent tasks — can be plotted on this same axis: lean left (independent judgment calls, one-shot then review) and Fable is more reliable; lean right (someone watching and adjusting in real time) and Sol works better. Most everyday writing, it turns out, sits toward that right side.
This review itself is a case in point: Sol could track the tonal arc of dozens of past Vibe Check pieces, dig up an old Slack conversation buried somewhere that supported a specific detail, and push out 24 drafts in one 6-to-8-hour focused session — without the author ever having to sit and wait for it to slowly work things out. Every draft was a string of editorial calls, each one nudging the piece closer to what it should be. For writing — a task that's inherently iterative and collaborative by nature — that's what a strong model should look like, even if nailing an opening line in one shot, or sticking a landing the way a human would, is still out of reach.
Why It Bombs the Blind Test
The writing benchmark is deliberately narrow — it only measures how the model performs unassisted, with no help from a human. Sol came in last: lowest similarity to the published version, and the highest Flesch-Kincaid score, meaning the lowest readability. Flesch-Kincaid (FK) is a formula that scores text based on sentence length and word difficulty — the higher the score, the harder it is to read.
Shorter Sentences, Bigger Words
Sol tends to write relatively short sentences, breaking an argument into tight little paragraphs. In its strongest opening draft for "After Automation," its rhythm tracked closer to the published opening than Opus 4.8's did, while Opus built out fewer, larger paragraphs. The problem shows up inside the sentence itself: even when both models produce sentences of similar length, Sol favors longer, more abstract words.
- the machine takes the taskthe machine takes the task
- it opens a frontierit opens a frontier
- the obvious effect is substitutionthe obvious effect is substitution
- the second-order effect is expansionthe second-order effect is expansion
Opus uses plainer words inside more complex syntax; Sol delivers text that scans smoothly at a glance but reads more laboriously line by line. Visible AI tells, oddly enough, aren't what drags it to last place: on checks for stock transitions, false contrasts, clichés, and repetitive rhetorical patterns, Sol lands in the middle of the pack. Its prose can be clean — just not always clean enough that you can skip re-checking for that machine-y tone before hitting publish.
Give It Context, and the Quality Jumps
The blind test deliberately withholds material, but in real use, people feed models plenty of it. Once you see how Sol absorbs and uses that context, its stronger side comes out. The author gave Sol and Opus 4.8 the same writing task, the same source material, and the same direction, and had each write a draft opening for the column "Working Overtime." Sol turned in a hook that grabbed attention, and the whole piece tracked closer to the column's established tone and voice; Opus turned in dense, hard-to-read paragraphs that didn't match the voice the author had defined in her context file.
Austin sees the same pattern with marketing copy: with no guidance, Sol is "a writer anyone could be," generic and repetitive; once given company background, templates, and a style guide, the landing-page copy, social posts, and marketing emails it produces need so little editing that Austin will just ship them. Give it material, examples, and rules, and quality climbs; let it decide the argument and the bar on its own, and the weaknesses from the blind test come right back.
As a Live Writing Partner, It's at Its Best
Sol's strongest role is as a real-time writing partner. It revises fast and stays aligned with editorial direction, letting a writer try a new opening, reshuffle a paragraph, or scrap a weak draft entirely without having to re-brief the task each time. For the author's own interview-heavy, iterative writing process — full of directional feedback and backed by a style doc and examples — Sol clearly beats the Claude lineup: Opus responds slowly, Sonnet 5 is hard to steer, while Sol switches direction fast, fixes mistakes fast from feedback, and carries new information forward into later turns instead of fixating on the most recent instruction and losing the bigger goal the way Sonnet 5 does. Head of technical consulting Mike Taylor has also started handing writing and editing to Sol, because it "basically never says anything off-putting" — it takes correction, remembers sources and prior decisions, and quickly tries again. Judgment still comes from a human editor, but Sol makes that judgment cheaper to apply across an entire piece.
Same Task, Three Models, Three Different Approaches
Saying abstractly that "Sol takes initiative and asks questions" isn't as useful as one real example. Every's head of operations, Arielle Shipper, gave GPT-5.5, Claude Fable 5, and Sol the exact same starting task and watched how each one handled it.
Austin's own daily workflow shows the same coherence: he can start from a marketing idea, draft an email, turn the copy into a landing page, and set up an experiment — all without ever leaving Codex or re-explaining the audience and pitch. Senior editor Jack Cheng uses Sol to merge paragraphs and strip out jargon, doing it right on the public page where the copy will actually appear, so every line can be judged in its final context. These workflows look less like a one-shot app and more like an actual workday: find the source, understand the need, ask about the decisions that need a human call, and carry the answers into the finished product.
Three Pricing Tiers, Two Reasoning Modes
On pricing, OpenAI's three tiers line up almost one-to-one against Anthropic's three models, making cross-vendor budget comparisons easy.
| Tier | OpenAI | Input / Output (per million tokens) | Claude Equivalent | Claude Input / Output |
|---|---|---|---|---|
| Flagship | Sol | $5 / $30 | Opus 4.8 | $5 / $25 |
| Mid-range | Terra | $2.50 / $15 | Sonnet 5 | $2 / $10 (until 8/31) → $3 / $15 |
| Lightweight | Luna | $1 / $6 | Haiku 4.5 | $1 / $5 |
Side by side: Sol matches Opus 4.8 on input price and costs $5 more per million output tokens; Terra is pricier than Sonnet 5's introductory promo rate ($2 / $10, expiring August 31) but close to the post-hike rate of $3 / $15; Luna matches Haiku 4.5 on input and costs $1 more on output.
What max and ultra Are
Beyond the three model tiers, Sol also brings two new reasoning settings, letting you scale compute spend to task difficulty instead of running everything at the same setting.
A single Sol agent given more time to think independently and iterate through trial and error. Good for a single task that needs deeper thought.
Multiple Sol agents working together on the same task at once. Good for a task that needs more "horsepower."
On the product side, Every hasn't used the merged ChatGPT-and-Codex app much yet, but the early feel matches what Codex was like at launch: a place worth sticking around in.
When to Reach for Sol, When to Switch to Fable
Pulling together the judgments from the four scenarios above into a checklist you can actually use. The original piece gives two sets of scenarios, mapping neatly onto the two ends of the delegation-vs-collaboration axis.
Use SolCollaboration side · Someone stays in the loop
- You're writing, researching, building, or analyzing something you expect to revise as you go
- The project already has usable material, examples, instructions, or past decisions
- You have a clear deliverable and want the model to handle the steps, tools, and follow-through
- You're fixing a hard bug or building a feature, and you can review its scope before it grows too large
Switch to Claude Fable 5Delegation side · Hand off and review
- The brief is loose, and figuring out what the project actually needs is itself most of the work
- You want to hand off a long task, walk away, and review the finished result later
- Simplification, architecture, and restraint matter more than fast back-and-forth
- You want to see more of the model's reasoning and progress while it works
Every's team usage is drifting toward this same axis: Dan hands hard engineering work to Fable as the lead agent, and well-defined execution to Sol; Mike treats Sol as his daily driver, saying it has "finally displaced Opus," while still keeping Fable around for its "sharp peak intelligence" and stronger use of context. When you want a clear outcome and an agent that keeps pushing forward while you stay free to jump in anytime, use Sol; when "defining the system itself" is the main task, either set checkpoints early and often, or hand the architecture to Fable and let Sol handle execution.
If you want to stay in the loop, the Codex app is a much better place to be. But if you want to take yourself out of the loop, you need Fable. — Mike Taylor, Every "Vibe Check"