Every's Team of 9 Spent a Month with It: So How Good Is GPT-5.6 Sol, Really?
- OpenAI has released its next-generation 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 come two new tiers: mid-tier 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 previous-generation GPT-5.5 on long-horizon biology benchmarks and cybersecurity tests.
- Nine Every editorial staffers spent a month testing it hands-on: Sol ranked last among six models in Every's own blind writing test, with the lowest readability score too — but it scored 56/100 on their homemade code-refactoring benchmark (versus 90/100 for Claude Fable 5). The gap comes mainly from over-engineering simple requirements, not from lacking capability.
- OpenAI also merged the ChatGPT and Codex desktop clients into a single unified app, and added two new reasoning settings — max (extended single-agent thinking) and ultra (multiple agents collaborating on the same task).
OpenAI Just Dropped Three New Model Tiers at Once
OpenAI recently released its next-generation model GPT-5.6 Sol, alongside two new tiers — mid-tier Terra and lightweight Luna — and merged the ChatGPT and Codex desktop clients into a single app.
This release comes in three tiers at once: flagship Sol, mid-tier Terra, lightweight Luna. OpenAI calls Sol its "strongest model yet," claiming it set a new record on Terminal-Bench 2.1, a command-line agent task benchmark, and calling it their strongest generation yet on cybersecurity capability.
OpenAI says the names Sol, Terra, and Luna will stick around as long-term "capability tiers," even as the models within each tier keep getting updated. We'll establish the three tiers here first; specific pricing and reasoning-power settings come later in the pricing section. Terminal-Bench 2.1 tests whether an AI can plan its own steps in a command line, iterate through trial and error, and call on various tools to carry a task through to completion — simulating how a real engineer works at a terminal.
Alongside the release, OpenAI merged the ChatGPT and Codex desktop clients into one app: ChatGPT Work handles most knowledge work, while Codex gets its own tab dedicated to technical work. It's being read as a step toward pulling ChatGPT's 800-million-plus user base into the "let AI just go do multi-step work itself" (agentic) mode.
A Month Without It, and the Team Says It Felt Like the Stone Age
Every is a US-based AI media company and software shop that publishes deep analysis while also building its own AI products; its editorial team has long put frontier models through firsthand hands-on testing, and this "vibe check" series is their signature format. By the time this piece went live, Sol had already been living inside Every's daily workflow for about a month — deeply enough that losing it actually hurt.
Throughout that month, Sol was practically everywhere. It helped Dan Shipper keep his inbox at zero, tracking decisions scattered across meetings and Slack that he would otherwise have missed. It kept pace with Austin Tedesco: from a marketing idea, to an email, to a landing page, to an experiment, all without him having to repeat himself or lose his train of thought. For the author of this piece, Katie Parrott, it made pulling files and finding context lightning-fast, completely changing how she works with models day to day.
In late June, Sol went offline for a round of government review, and the team lost access. Dan says 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 touched on a concept in their earlier Sonnet 5 hands-on piece called "a revolution of ever-rising expectations"; these days without Sol were a perfect illustration of how quickly people adjust to a higher standard of living, and how painful it is when that standard slips back.
Going back to other models, even with Fable still around, felt like regressing to the Stone Age.
Using GPT-5.5 was like shooting a basketball that's twice as heavy as what I'm used to.
Dan has a vivid comparison for it: Sol is a Porsche, Fable is a warp engine. Fable can obviously take you across the whole galaxy, but most of the time you're not headed to space — you just want to drive around town, and Sol is the car that makes that drive feel good.
Nine People, Nine Honest Takes
Every's "Reach Test" has nine staffers with very different roles each give one honest, one-line verdict on Sol, plus a sentiment rating. Taken in at a glance, it makes clear this reliance isn't just for show.
Eight of nine cards lean positive, with one (Arielle) landing on "fine" after a late-stage calculation error. This overall lean also explains why the team is willing to make it their daily driver. What exactly it's good at, and where it stumbles, gets broken down section by section below across coding, writing, and knowledge work.
It Can Carry the Work — It Just Doesn't Know When to Stop
In day-to-day development, Sol is a real step up from GPT-5.5: it can chase a bug all the way down inside an unfamiliar production codebase, carry a large project from start to finish, and keep testing well past the point where other models would have given up. Several engineers on the team have already made it their daily driver. Its limit shows up when a task requires the model to judge for itself "what shouldn't be done."
Every has a benchmark called Senior Engineer: hand the model a real but messy collaborative codebase and have it judge, like a senior engineer would, what the system should be rewritten into — the whole point being to test 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 grasp an entire architecture and carry a full system rewrite through to completion — but it keeps building and doesn't know when to stop. Roughly 12,900 lines of code, spread across four collaborating processes, each individual addition defensible on its own, but together adding up to far more complexity than the task called for. When Dan reviewed the results, he attributed nearly the entire gap between it and 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 over-complicate things.
Where the Goal Is Clear, It Shines
Conversely, when the target is well-defined, Sol's execution holds up strong. The clearest production example comes from Naveen Naidu, who put Sol to work on daily development for his own product, Monologue: GPT-5.5, even set to maximum reasoning, repeatedly failed to root-cause a note-recording bug; Sol traced the failure down 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 produced a working Proof-like app in about a third of the time (though Dan preferred Fable's design). Sol also finished a digital audio workstation that GPT-5.5 had failed to complete.
These results match the team's overall sense: once the desired system is clear, Sol is fast, resourceful, and strong on implementation. When judging "what not to build" is itself the main engineering task, Fable remains the first choice; once the direction is set, handing execution to Sol tends to be the least stressful path.
Last Place in the Blind Test, Yet the Hardest Companion to Give Up
In Every's writing benchmark, Sol ranked dead last of six models: its prose was the hardest to read, and its editorial choices diverged furthest from the published reference version. Yet this same model is the one the whole team overwhelmingly prefers for everyday 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, come back to a usable finished result. The other is "collaboration": stay in the loop the whole time while the model rapidly serves up options and the human calls the direction in real time. Sol's speed, responsiveness, and command of context make it the team's preferred spot for collaborative work. The biggest, vaguest tasks — where just figuring out what needs doing eats up most of the effort — still go to Fable. This "delegation vs. collaboration" split is the answer to why it ranks last in the writing blind test yet gets used the most day to day.
Delegation is like handing an entire project to a direct report to finish independently, then reviewing it when it's done; collaboration is like sitting side by side with a colleague, editing the same document, chiming in to redirect at any moment. Sol is that great collaborator sitting beside you; Fable is the one who can independently carry an entire project on their own.
All four evaluation areas — coding, writing, knowledge work, and agent use — can be placed on this same axis: lean left (independent judgment calls, finish it and then review) and Fable holds steadier; lean right (a human staying nearby, watching and editing) and Sol is the better fit. And most everyday writing happens to fall on that right-hand side.
This hands-on report is itself an example: Sol could trace the stylistic arc of dozens of past Vibe Check pieces, dig up an old Slack conversation buried away that backed up a specific detail, and push out 24 drafts in one focused 6-to-8-hour session, all without the author sitting around waiting for it to slowly think things through. Each draft was a string of editorial calls, gradually pulling the finished piece closer to what it should be. For writing — a task that inherently demands repeated iteration and constant back-and-forth — that's exactly what a strong model should look like, even if nailing an opening in one shot, or landing an ending as precisely as a human would, is still beyond its reach.
Why It Comes in Last in the Blind Test
The writing benchmark is deliberately narrow — it only looks at how the model performs on its own, with no human assistance. There, Sol ranked last: lowest similarity to the published version, and the highest Flesch-Kincaid score, meaning the lowest readability. Flesch-Kincaid (FK) here 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 writes relatively short sentences, breaking an argument up into tight little paragraphs. In its strongest version of an opening for "After Automation," the pacing tracked closer to the published opening than Opus 4.8's did, while Opus used fewer, longer paragraphs to unfold its point. The problem shows up inside the sentences themselves: even when both models produce sentences of similar length, Sol still favors longer, more abstract words.
- the machine takes the task
- it opens a frontier
- the obvious effect is substitution
- the second-order effect is expansion
Opus uses plainer words wrapped in more elaborate syntax; what Sol turns in is a page that skims smoothly but reads more laboriously line by line. Interestingly, obvious AI-tells aren't what puts it last: on checks for formulaic pivots, false contrasts, clichés, and repeated rhetorical patterns, Sol lands in the middle of the pack. Its prose can be clean, but not always so clean that you can skip re-checking it for that machine-generated flatness before publishing.
Give It Context, and Its Level Jumps
The blind test is deliberately "starved" of material, but in real scenarios, people feed the model plenty of it. Once you see how Sol absorbs and uses that context, a much stronger side of it shows up. The author gave the same writing task, the same source material, and the same direction to both Sol and Opus 4.8, having each write a draft opening for the column "Working Overtime." Sol turned in a gripping opening whose overall tone matched the column's established voice much more closely; Opus turned in paragraphs that were dense and hard to read, and didn't match the voice the author had defined in her context files.
Austin found the same when writing marketing copy: without guidance, Sol is "a writer anyone could be" — generic and repetitive. But once fed company background, templates, and a style guide, the landing-page copy, social posts, and marketing emails it produces need barely any editing before Austin will ship them. Feed it material, examples, and rules, and quality climbs; make it decide the argument and the standard from scratch, and the weaknesses seen in the blind test return.
As a Live Writing Partner, It's at Its Strongest
Sol's strongest role is as a real-time writing partner. It revises quickly and tracks editorial direction closely, letting a writer try a new opening, reorder a paragraph, or just toss out a weak draft, without having to re-brief the task from scratch each time. For a workflow like the author's — heavily interview-based, iterative, with lots of direction and feedback plus style docs and reference examples on hand — Sol clearly beats the Claude line: Opus responds slowly, Sonnet 5 is hard to steer, while Sol switches direction fast, fixes mistakes fast when given feedback, and can carry new information forward into later turns without, unlike Sonnet 5, fixating on the most recent instruction and losing sight of the bigger goal. Mike Taylor, who leads technical consulting, has also started handing writing and editing off to Sol, because it "basically never says anything off-putting": it takes corrections, remembers sources and prior decisions, and quickly tries again. Judgment still comes from the human editor — Sol just makes that judgment cheaper to apply across an entire draft.
Same Task, Three Models, Three Different Approaches
Saying abstractly that "Sol takes initiative, asks questions" is less convincing than a real case. Every's head of operations, Arielle Shipper, handed the exact same starting task to GPT-5.5, Claude Fable 5, and Sol at the same time, to see how each one approached it.
Austin's day-to-day work shows the same continuity: he can start from a marketing idea, draft the email, turn the copy into a landing page, and set up an experiment — all without leaving Codex or having to re-explain the audience and the pitch. Senior editor Jack Cheng uses Sol to merge paragraphs and cut jargon while working directly on the actual public page where the copy will appear, so every line can be judged in its final on-screen context. These workflows look a lot more like a real workday than a single one-shot app build: find the source, understand what's needed, ask questions about the decisions that require a human call, then carry the answers through into the finished product.
Three Pricing Tiers, Two Reasoning Settings
On pricing, OpenAI's three tiers map almost one-to-one onto Anthropic's three models, making it easy to comparison-shop across vendors by budget.
| Tier | OpenAI | Input / Output (per million tokens) | Claude Equivalent | Claude Input / Output |
|---|---|---|---|---|
| Flagship | Sol | $5 / $30 | Opus 4.8 | $5 / $25 |
| Mid-tier | 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, but costs $5 more per million output tokens; Terra is pricier than Sonnet 5's introductory promo rate ($2 / $10, ending August 31), but close to the post-increase $3 / $15; Luna matches Haiku 4.5 on input, and costs $1 more on output.
What max and ultra Are
Alongside the three model tiers, Sol also brings two new reasoning settings, letting you spend compute in tiers matched 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 you want it to think through more deeply.
Several Sol agents working together at once on the same task. Good when you want to throw more "horsepower" at one task.
On the product side, Every hasn't used the merged ChatGPT-and-Codex app much yet, but the current feel matches the original Codex: a place worth sticking around in.
When to Use Sol, When to Switch to Fable
Pulling the judgment calls from the four sections above into one checklist you can go straight to. The source piece gives two sets of scenarios, mapping neatly onto the two ends of the "delegation vs. collaboration" axis.
Use SolCollaboration side · Human 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 on hand
- You have a clear deliverable and want the model to take over steps, tools, and follow-through
- You're fixing a hard bug, or building a feature, where you can review its boundaries before the scope grows too large
Switch to Claude Fable 5Delegation side · Hand it off, review the result
- 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 come back to review the finished result
- 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 own usage is trending along this same axis: Dan hands hard engineering work to Fable as the primary agent, and gives well-defined execution to Sol; Mike made Sol his daily driver, saying it "finally edged out Opus," while keeping Fable around for its "sharp peak intelligence" and stronger context handling. When you want a clear result plus an agent that keeps pushing forward while letting you step in anytime, use Sol; when "defining the system itself" is the main job, either set checkpoints early, or hand the architecture to Fable and let Sol handle the 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's Vibe Check
The Model That Ranked Last in a Blind Writing Test, Yet Is the Team's Daily Must-Have
OpenAI released its new flagship GPT-5.6 Sol; Every's nine-person team spent a month with it. One page, with visuals, on where it shines and where it stumbles.
↓ Read this page in one pass · one diagram animates
OpenAI just released its next-generation flagship model, GPT-5.6 Sol, alongside mid-tier Terra and lightweight Luna, and merged the ChatGPT and Codex desktop apps into one. Officially, it's "the strongest yet." But how good a model actually is doesn't come down to official benchmarks alone.
✘ Weak on restraint: let it decide on its own how to write an article or how simple to keep a program, and it falters — dead last of six models in the writing blind test.
Blind test = judges aren't told which model wrote which piece. So "officially the strongest" ≠ "best in daily use" — someone has to actually try it in real scenarios.
Every is a US-based AI media company that also builds its own AI products; its editorial team has long put the newest models through firsthand hands-on tests. This time, nine people used Sol continuously for a month. It went offline midway due to a government review, and Dan said switching back to other models felt "like regressing to the Stone Age" — a clear sign of how deep the reliance ran. Take the same task, before and after switching to Sol, and the difference is immediate:
Task: dig 46 spreadsheet attachments out of one email, align and merge them with an existing sheet, then run an analysis requiring real judgment.
It asked "where's the email," even though the sender had already been named, then turned in an unusable draft.
Found the email on its own, went through all 46 sheets, spotted missing information, and came back with 7 questions (which groupings to count, how to calculate a certain metric), each with a recommended answer attached.
What it delivered was a draft she could directly approve or edit, not another assignment tossed back at her.
But how can a model that codes reliably and takes initiative on tasks still land dead last in the writing blind test? The answer is in one diagram.
Every splits working with AI into two modes: "delegation" means assigning a task, walking away, and coming back to review it; "collaboration" means staying nearby while the model quickly offers options and the human calls the direction in real time. Rankings and daily use each measure a different one of these — and that's the answer to the apparent contradiction.
"Fast" doesn't mean much in the abstract — translate it into time and it lands differently. Engineer Kieran had Sol and Claude Fable 5 each rebuild the team's internal collaborative document editor, Proof, from the exact same prompt:
The 56:90 score, the ~12,900 lines, and the last-place writing result all come from Every's own homemade tests and blind test, with no third-party replication; "strongest yet" and "strongest on cybersecurity" are OpenAI's own claims.
the strongest yet!
in the writing blind test
the Stone Age!
two different ways to use it!
turn it in and leave
last
revise together instantly
6–8 hours
Daily work needs "stay and edit"
That's still a job for Claude Fable 5
