GPT-6.1 Sol: The Field Guide for Claude Users
At DevDay on September 29, 2026 OpenAI shipped GPT-6.1 Sol (gpt-6.1-sol)
one week after GPT-6 Sol, with the pitch "near-Astra intelligence for a fifth of
the price." It went straight to the top of Hacker News.
For a Claude user the interesting fact is not the pitch. It is that GPT-6.1 Sol lands on exactly Claude Sonnet 5.5's rate card — $2 in, $10 out per MTok — while charging half of Sonnet 5.5's cached-input rate. Two models, same headline price, different bills, different shapes of work. This page is the specs, the pricing mechanics most write-ups skip, an honest read of the benchmark table, and the rest of what DevDay shipped for developers.
- Know the exact specs — and the two ceilings that are not the context window
- Price a workload correctly, including the 272K cliff and the cached-input gap with Sonnet 5.5
- Avoid the API-surface trap: tool calling is not available on both endpoints
- Read the launch benchmarks including the row where Claude still wins
- Know what else landed at DevDay for developers: Ultrafast, the Decisions API, Codex Security Cloud, Private Intelligence
Specs
gpt-6.1-sol | |
|---|---|
| Context window | 1,050,000 tokens |
| Max input tokens | 922,000 |
| Max output tokens | 128,000 |
| Knowledge cutoff | April 30, 2026 |
| Reasoning efforts | low, medium (default), high, xhigh, max |
| Input / cached input / output | $2.00 / $0.10 / $10.00 per MTok |
| Cache write | $2.50 per MTok |
| Long context (>272K) | 2× input and cache rates, 1.5× output |
| Fast Mode | 2× standard pricing |
| Batch / Flex | 50% below standard |
| Rate limits | Tier 1: 500 RPM / 500K TPM → Tier 5: 15K RPM / 40M TPM |
The two ceilings that are not the context window
1,050,000 is the window. 922,000 is the input ceiling. The gap is not slack you can spend on a bigger document — it is the room reasoning and output need. If you size a retrieval step against "1M context" you will hit a limit ~12% earlier than the marketing number, and you will hit it at the worst moment, after you have already paid to assemble the prompt.
Then there is the price cliff at 272K. Cross it and input and cached input double, output goes up by half. This is the same cliff GPT-6 Astra has, and it changes the economics of long-context work sharply: a 300K-token prompt does not cost 10% more than a 272K one, it costs roughly twice as much on the input side. If you are near the boundary, compressing to stay under it is worth real engineering effort. Claude prices its 1M window differently — see what AI costs across providers and prompt caching across providers.
The trap: tool calling is not on both APIs
The model page lists Chat Completions (without tool calling) and Responses API (tool calling). Read that twice if you are porting an existing integration.
If your code posts to Chat Completions — the endpoint most third-party libraries, gateways and "OpenAI-compatible" wrappers default to — you do not get function calling on this model. The fix is not a parameter, it is a different endpoint and a different request shape.
Also unsupported: Live, Realtime, Assistants, fine-tuning, embeddings, image generation, video, speech and transcription, moderation, and legacy Completions. The supported tool list is broad — web search, file search, image generation, code interpreter, hosted shell, apply patch, skills, computer use, MCP, tool search — but it is a Responses API list.
- Check your AI gateway before you switch a model string. A router that normalises everything to Chat Completions will silently drop tool calling on gpt-6.1-sol — the request succeeds, the tools just never fire.
Price it against Claude properly
Same headline numbers, different mechanics.
| GPT-6.1 Sol | Claude Sonnet 5.5 | Claude Opus 5.5 | |
|---|---|---|---|
| Input / output per MTok | $2 / $10 | $2 / $10 | $4 / $20 |
| Cached read per MTok | $0.10 | $0.20 | $0.20 |
| Context | 1.05M (922K input) | 1M | 1M |
| Max output | 128K | 128K | 128K |
| Long-context surcharge | Yes, above 272K | No published cliff | No published cliff |
Two consequences that matter more than the headline parity:
On a long agent loop, GPT-6.1 Sol's cache read is the cheaper line. $0.10 against $0.20 is a 2× gap on the item an agentic loop re-pays on every single turn. If your prompt is a large stable prefix plus a small delta — which is what an agent is — that is where the bill actually lives.
Above 272K the direction flips hard. Anthropic publishes no equivalent cliff on the Claude 5.5 models, so a workload that genuinely needs 400K of context is priced on very different curves. Know which side of 272K you live on before you compare anything.
The benchmarks, read honestly
OpenAI's launch numbers, as compiled at launch. These are vendor-run; nobody has reproduced them independently yet.
| Benchmark | GPT-6.1 Sol | GPT-6 Astra | Claude | Cost per task |
|---|---|---|---|---|
| DeepSWE v1.1 (software engineering) | 75.2% (high) | 74.8% (high) | Sonnet 5.5: 71.0% | ~$1.50 vs Astra ~$7.70 |
| OSWorld 2.0 (computer use) | 71.4% (max) | 73.5% (max) | Opus 5: 60.3% (medium) | $1.30 vs Astra $9.30 |
| GDP.pdf (document analysis) | 32.0% | 32.2% | Opus 5.5: 28.8% | — |
| AutomationBench 1.0.6 (business workflows) | 36.0% | — | Sonnet 5.5: 44.7% | $0.30 vs Sonnet ~$1.14 |
| Low-effort factual error rate | 7.7% | — | — | (GPT-6 Sol: 11.4%) |
Three things to take from this table:
1. The cost claim is the strong claim. Beating Astra on DeepSWE by 0.4 points is noise. Doing it at roughly a fifth of the cost per task is not. The interesting comparison in this release is never Sol against Astra on quality — it is Sol against Astra on price for the same quality.
2. AutomationBench is the row OpenAI did not lead with. Claude Sonnet 5.5 scores 44.7% against GPT-6.1 Sol's 36.0% — 8.7 points, on business-workflow automation, at ~4× the cost per task. That is a genuine trade, not a rout in either direction: if a failed workflow costs you more than $0.84, the expensive model is the cheap one. Decide with your own failure cost, not with the leaderboard.
3. Even the best computer-use number is 71.4%. Roughly three in ten tasks fail on the benchmark designed for the capability. Everything in computer-use agents compared about confirmation gates still applies.
The factual-error figure is the quietest interesting number: 7.7% at low effort, down from 11.4% on GPT-6 Sol. Error rate improving specifically at the cheap setting is what makes a workhorse model usable as a default rather than as a fallback.
What else DevDay shipped for developers
Short version, because several of these deserve their own pages.
- A paid speed tier: OpenAI describes up to 8x faster token generation in Codex and 6x in the API. The guide notes it is US data residency and global processing only — no EU or other regional processing endpoints — and strongly recommends WebSockets over HTTP, because per-request network overhead eats the latency win on tool-heavy agent loops. On the consumer side it is exclusive to the new $500/month Pro 500 plan.
- The Agents API (public beta since September 10) can now operate software through its UI, alongside Codex's multi-agent capabilities, tool search and context compaction. The side-by-side with Anthropic's hosted loop is already written up on this site.
- Sub-second classification and routing over predefined options, running on the Luna model. This is a direct answer to the decision-model category — the same shape as Jev and Kev: return a choice with calibrated confidence instead of prose.
- Scans whole GitHub repositories, reviews new commits continuously, deduplicates findings and prepares fixes for review while your laptop is closed. The CLI is open source at github.com/openai/codex-security, with a TypeScript SDK.
- Zero Data Retention with Private Safety Processing — automated safety checks that run without OpenAI personnel accessing the content. Private Inference, combining confidential computing with verifiable controls, is previewed for later in the fall.
The Decisions API is the one to watch if you have been following the decision-model thread on this site: it takes a research direction that was open-weight and DIY and turns it into a hosted endpoint from the largest vendor. See System One decision models: Jev, Kev and the open clones and train your own decision model for what the category actually guarantees — and what "cannot hallucinate" does not mean.
Should you switch?
- The models trade rows. GPT-6.1 Sol wins software engineering and raw cost per task; Sonnet 5.5 wins business-workflow automation by 8.7 points. A default-model change should follow a measurement on your own work, not a launch table.
- DeepSWE at 75.2% for ~$1.50 a task, with cached reads at $0.10, is the combination that makes a long agent loop cheap. If your bill is dominated by cache reads on a big stable prefix, that line alone can move it.
- If your integration or gateway speaks Chat Completions, tool calling does not come with the model switch. Verify you can move to the Responses API first; that is a bigger change than the model string.
- Below the cliff, this is a cheap 1M-context model. Above it, input and cache double. Instrument your actual prompt sizes before assuming the window is flat-priced.
Decide the switch on your own data, not the launch table
I am comparing two models for a production workload.
Model A: gpt-6.1-sol — $2 in / $0.10 cached / $10 out per MTok,
1.05M context but 922K max input, and input + cached rates
DOUBLE above 272K tokens (output x1.5).
Model B: claude-sonnet-5-5 — $2 in / $0.20 cached / $10 out per MTok,
1M context, no published long-context surcharge.
Here is my workload profile:
- average stable prefix (cacheable): <N> tokens
- average per-turn delta: <N> tokens
- average output per turn: <N> tokens
- turns per task: <N>
- tasks per day: <N>
- share of requests whose total input exceeds 272K: <X>%
- cost to me of one wrong answer that ships: $<N>
Compute the monthly bill for each model. Then tell me the accuracy gap
at which the cheaper model stops being cheaper, given my stated cost of
a wrong answer. Show the arithmetic. Do not recommend a model without
showing the break-even point.Quiz
Check yourself
0/4Next
- Claude Sonnet 5.5: the field guide — the model on the identical rate card, and the five 400-traps in its own migration
- OpenAI Dots: the always-on agent — the other half of DevDay 2026, and the permission architecture underneath it
- What AI costs across providers — the durable version of the pricing comparison above
Sources & further reading
- GPT-6.1 Sol model page — specs, pricing, endpoint and tool support, rate limits
- Introducing GPT-6.1 Sol — OpenAI's launch post
- DevDay 2026 announcements and developer resources — OpenAI's own index of every DevDay launch with doc links
- Ultrafast mode guide — model availability, residency limits, WebSocket recommendation
- Computer use in the Agents API — the new tool
- openai/codex-security — the open-source Codex Security CLI and SDKs
- GPT-6.1 Sol benchmarks explained — compiled benchmark tables and cost-per-task figures
- OpenAI expands Codex and its API at DevDay — Decisions API, Ultrafast, security scans
- Simon Willison's DevDay 2026 live blog — contemporaneous notes and pricing figures