Skip to content
Guide intermediate

GPT-5.6 Sol vs Claude Fable 5 vs Gemini: the model call for agent builders, July 2026

Published July 2, 2026 · by Pondero Reviews

The short version

GPT-5.6 Sol tops the agent benchmarks but is gated to about 20 partners today. Here is what to actually run now, per persona, and the week it is worth switching, with cited pricing and the benchmarks that flip the pick.

Table of Contents

GPT-5.6 Sol vs Claude Fable 5 vs Gemini: the model call for agent builders, July 2026

Sol wins the benchmark you care about and you cannot buy it. That is the whole decision in one line. GPT-5.6 Sol leads TerminalBench 2.1, the eval that actually measures agentic command-line work, but as of July 2 it ships to roughly a small group of trusted partners under a US-government-coordinated limited preview with no public waitlist (per OpenAI). So the pick for anyone building agents this week is not Sol. For a production agent stack today, run Claude Fable 5. If cost is the binding constraint, route the routine turns to Gemini 3.5 Flash. Put Sol's mid tier, Terra, on your evaluation list for the week general access opens, which OpenAI says is "coming weeks."

One correction up front, because it changes the budget pick and most competing pages get it wrong. There is no Gemini 3.5 Pro. Google shipped Gemini 3.5 Flash at I/O on May 19-20, 2026 ($1.50 input / $9 output per million tokens), and left the Pro tier at Gemini 3.1 Pro Preview ($2 / $12 up to 200k tokens) per Google's pricing docs. If a comparison quotes you "Gemini 3.5 Pro at $1.25/$10," it is describing a model that does not exist. The real Gemini call is Flash for volume, 3.1 Pro when you need the deeper tier.

The state of play on July 2

Three things are true at once. Sol is real and it leads the published agent benchmark, TerminalBench 2.1 (per Lushbinary). Sol is also unbuyable for anyone outside the partner list. And the model you can deploy right now, Fable 5, is close enough on agentic work and ahead on the file-edit benchmark that the gap rarely decides a project this month.

OpenAI shipped GPT-5.6 on June 26 as a three-tier family: Sol (flagship), Terra (balanced), Luna (fast and cheap), plus a high-effort Sol Ultra mode (per Lushbinary). Claude Fable 5 has been generally available since June and leads SWE-bench Verified at 95% (per Morph, which tracks the independently confirmed Verified leaderboard). Gemini 3.5 Flash and Gemini 3.1 Pro Preview are both GA and self-serve. The one you can put behind a customer-facing agent today, with a stable rate card and an SLA, is Anthropic's or Google's, not OpenAI's newest.

Pricing, per million tokens

Price is where the three families diverge, and it drifts quickly, so here is the current card with sources.

ModelInput / 1MOutput / 1MStatusSource
GPT-5.6 Sol$5.00$30.00Gated previewOpenAI
GPT-5.6 Terra$2.50$15.00Gated previewOpenAI
GPT-5.6 Luna$1.00$6.00Gated previewOpenAI
Claude Fable 5$10.00$50.00GALushbinary
Gemini 3.1 Pro Preview$2.00$12.00GAGoogle
Gemini 3.5 Flash$1.50$9.00GAGoogle

Sol Ultra is a high-effort mode of Sol, not a separate published rate, so budget it as standard Sol pricing times a real multiple on tokens per request (per Lushbinary). Read the table with output rates in mind, because output is six times the input price on Sol, Terra, and Luna alike, and a long autonomous run bills mostly on the response side.

Two pricing levers matter for anyone doing this at volume. Prompt caching is the first: GPT-5.6 adds explicit breakpoints with a 30-minute minimum cache life; cache writes bill at 1.25x the uncached input rate and cache reads keep the 90% discount (per OpenAI). If your agent re-sends a large system prompt or repo context every turn, caching is the difference between a workable bill and a scary one. Separately, OpenAI is putting Sol on Cerebras at up to 750 tokens per second in July, initially for select customers (per OpenAI). Fast inference changes what an interactive agent feels like, but it does not change the access problem this month.

The benchmark that flips the pick

The order of the leaderboard depends entirely on which benchmark you cite, and the right one depends on what your agent does.

TerminalBench 2.1 measures agentic, terminal-driven engineering: multi-step, tool-using shell work where the model drives a command line across many turns. On that eval, Sol Ultra hits 91.9% and Sol 88.8%. Terra ties Claude Fable 5 at 84.3%. Gemini 3.1 Pro Preview sits well back at 70.7% (per Lushbinary, citing OpenAI's announcement). If your product is a long-horizon shell agent, that spread is the argument for Sol the day you can get it.

SWE-bench Verified flips it. That benchmark scores resolved GitHub issues, 500 human-validated Python tasks, closer to what a file-editing coding agent does than a shell loop. Fable 5 leads Verified at 95%, independently confirmed on the public leaderboard (per Morph). Two different benchmarks, two different winners, and the one that should govern your choice is the one that matches your agent's actual job.

BenchmarkMeasuresLeaderRunner-up
TerminalBench 2.1Agentic shell / CLI workSol Ultra 91.9%, Sol 88.8%Terra & Fable 5 84.3%
SWE-bench VerifiedGitHub file-edit tasksFable 5 95%Claude family leads

The pick depends on the eval: cite TerminalBench for a shell agent, SWE-bench Verified for a file-edit agent (sources: Lushbinary citing OpenAI, and Morph).

Here is the practical read. The Sol-over-Fable-5 lead on TerminalBench is real but it is roughly four to five points, and Sol is gated. Fable 5 is the file-edit leader and you can deploy it today. For most teams shipping a coding agent this month, the benchmark advantage that would justify waiting for Sol is not the benchmark their agent runs against.

What "limited preview" means if you are not a partner

Plainly: you cannot apply. OpenAI's own FAQ says the preview is "not a broad self-service program," participation is limited to trusted partners with an OpenAI account representative, and there is "no public application or waitlist" (per OpenAI). Access is scoped per organization, and API approval does not automatically include Codex, or the reverse. The gate exists because OpenAI previewed the models with the US government ahead of launch and is releasing in coordination with it, on a phased schedule.

The timeline word is "coming weeks." OpenAI says it plans to make the family generally available in ChatGPT, Codex, and the API in the coming weeks (per OpenAI). For planning: treat Sol as a Q3 dependency, not a July one, and build behind a config switch so promoting a tier is a one-line change, not a code migration.

The decision, by who you are

Three builders, three different binding constraints, three picks.

If you areRun todayWhySwitch when
Solo dev on a budgetGemini 3.5 Flash for routine turns, Fable 5 for the hard tailFlash is a low-cost GA tier at $1.50/$9 (per Google); escalate only the turns that need itTerra opens GA at $2.50/$15 and undercuts Fable 5 while matching it on TerminalBench
Ops team running production agentsClaude Fable 5GA, stable SLA, SWE-bench Verified leader at 95%, close on agentic shell workYou have Sol API access and your agent is shell-heavy enough for the 4-5 point TerminalBench gap to pay
Enterprise with data-privacy needsFable 5 or Gemini on your existing data-processing agreementBoth are GA with enterprise terms; Sol's preview terms are per-partner and not self-serveSol reaches GA with standard enterprise terms you can put through legal

Read the switch column as the real deliverable. The pick today is the easy part. The condition that flips it is where the money is: a solo dev should move to Terra the week it goes GA if the price undercuts Fable 5 at equal agentic quality; an ops team should hold on Fable 5 until Sol access is real and the workload is shell-heavy; an enterprise should wait for Sol's standard terms before routing regulated data through it. None of these is "it depends." Each is a dated trigger.

Routing in practice: Cursor, Copilot, n8n, Make

The model picker is where this decision actually lands, because none of these choices is a one-time API key anymore. It is a per-task routing call inside your IDE or workflow.

In Cursor, model access runs through two usage pools on a paid seat: a Composer-and-Auto pool for first-party models, and a Third-Party API pool for models like Claude and Gemini. Team seats are $32 per seat per month on annual (Standard) and $96 on Premium (per Cursor). The upside is that once Sol reaches general access, you switch from the same Cursor plan you already pay for. The forward risk worth pricing in: SpaceX agreed to acquire Cursor's parent, Anysphere, for $60B in stock, a deal expected to close in Q3 2026 (per TechCrunch). Third-party model access inside Cursor after that close is not something you should assume is permanent.

GitHub Copilot exposes its own model picker, and Copilot Business runs $19 per seat per month (per GitHub docs), the same switching capability at a lower seat price than Cursor Premium. If your team already lives in GitHub, Copilot is the least-friction place to flip models per task, and the native PR review is a real edge for a file-edit agent that leans on Fable 5's SWE-bench strength.

For workflow agents, the routing lives in the node. n8n's AI Agent node lets you set the model per workflow step, and the self-hosted Community Edition is free to run, so n8n is where a cost-sensitive builder can cascade cheap Gemini Flash turns and reserve Fable 5 for the steps that need it. Make's AI Agents module does the same per-action model selection inside a hosted no-code canvas; if you want the routing without running your own infra, Make is the managed version of the same idea.

Here is a minimal cascade you can wire in either tool: cheap tier first, escalate on a confidence or complexity signal.

# Model routing policy (pseudocode for an n8n / Make AI Agent step)
route:
  - when: task.type in [classify, extract, summarize, route]
    model: gemini-3.5-flash        # $1.50 / $9 per 1M, GA
  - when: task.type == code_edit and task.confidence < 0.7
    model: claude-fable-5          # SWE-bench Verified leader, GA
  - when: task.type == shell_agent and task.steps > 8
    model: claude-fable-5          # Sol/Terra go here once GA
  - default:
    model: gemini-3.5-flash

The pattern is the whole point: route the easy majority to the low-cost GA model, escalate the hard tail, and leave a single line where Terra or Sol drops in the week you get access.

The two escalation legs are ordinary API calls today. The Gemini Flash turn against Google's endpoint:

curl -s "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:generateContent" \
  -H "x-goog-api-key: <GOOGLE_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{"contents":[{"parts":[{"text":"Classify this ticket: refund request or bug report?"}]}]}'

The hard-tail turn against Anthropic's Messages API, using Fable 5:

curl -s https://api.anthropic.com/v1/messages \
  -H "x-api-key: <ANTHROPIC_API_KEY>" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"claude-fable-5","max_tokens":1024,"messages":[{"role":"user","content":"Fix the failing test in src/auth.ts and return a unified diff."}]}'

When Terra opens GA, the swap is a single field: "model":"gpt-5.6-terra" against OpenAI's API, with the model string read from OpenAI's published docs rather than guessed, since preview identifiers can change (per OpenAI). Before you flip any leg, sanity-check the daily bill with the output-heavy math that drives it:

# Blended daily cost for a 2M-token/day agent, 70% input / 30% output.
def daily_cost(in_rate, out_rate, mtok=2, in_share=0.7):
    return mtok * (in_share * in_rate + (1 - in_share) * out_rate)

print("Fable 5:", daily_cost(10.00, 50.00))   # -> 44.0
print("Terra:  ", daily_cost(2.50, 15.00))    # -> 12.5
print("Flash:  ", daily_cost(1.50, 9.00))     # -> 7.5

In that example the model choice moves the bill from $7.50 to $44 a day, roughly 6x , which is why the cascade sends only the turns that need it to the expensive tier.

The verdict

For a production agent this month, Claude Fable 5 is the pick. It is GA, it leads SWE-bench Verified at 95% (per Morph), and it is within about five points of Sol on TerminalBench (per Lushbinary), close enough that the gated model's edge does not justify blocking your roadmap on access you cannot request. For a solo dev where cost is the binding constraint, run Gemini 3.5 Flash at $1.50/$9 for the routine turns and escalate the hard tail to Fable 5. Put GPT-5.6 Terra on your calendar, not your stack: the week general access opens, re-run your own eval, and if Terra holds its 84.3% TerminalBench parity with Fable 5 at $2.50/$15 input, the budget pick flips to Terra. Reserve Sol and Sol Ultra for the compute-heavy, shell-driven agentic workloads where the extra points on TerminalBench are worth $5/$30, and only once you can actually buy them.