GPT-6.1 Sol: OpenAI's $2-Per-Million-Token Model Changes the AI Automation Cost Equation

OpenAI's GPT-6.1 Sol promises near-flagship intelligence at one-fifth the token price. But the number that matters isn't on the price list — it's cost per completed task. Here's how to think about it.

Key takeaways

• GPT-6.1 Sol (DevDay, Sept 29): $2/M input, $10/M output — one-fifth of Astra's rates — with cached input at just $0.10/M (95% below standard).
• Benchmarks (vendor-reported): matches Astra on DeepSWE v1.1, within 2.1 points on OSWorld 2.0 at ~1/7th the cost per task; beats Opus 5.5 on AutomationBench at ~1/3rd the cost.
• Independent check: Artificial Analysis scores Sol 52 vs Astra 53 — at $0.72 vs $3.26 per index task.
• The real metric is cost per completed task, not cost per token: retries, tool-loop turns, and cache hits decide the invoice.
• Bottom line: route, don't replace — replay flagship traffic through Sol, measure task success end to end, and move every workload where the gap is invisible.

At its DevDay event on September 29, OpenAI introduced GPT-6.1 Sol — positioned as a lower-cost model alongside its higher-capability offering. OpenAI states Sol "nearly matches GPT-6 Astra's intelligence on agentic coding, computer use, and professional work at one-fifth of Astra's standard input and output token prices." (9to5Mac)

The release followed a turbulent week: the planned GPT-6.1 Astra upgrade was cancelled on the eve of the event after failing internal safety testing, per reports. (MadRobot; Android Headlines)

For businesses running AI agents against real workloads, this release could materially change automation cost calculations. Here's the practical read.

What OpenAI actually shipped

The headline numbers are straightforward:

Sol is available through the API and, in ChatGPT, to Plus, Pro, Business, Enterprise, and Edu users inside ChatGPT Work and Codex — but not yet in regular Chat, per DevDay coverage. (MadRobot)

Why the cache price matters more than the sticker price

Agent workloads consume more tokens than chat workloads: repeated tool calls, resubmitted context, intermediate steps. An agent resends its system prompt, tool definitions, and conversation history on every turn of the loop. In a long task, that repeated context can dominate the token bill.

At $0.10 per million cached tokens, the cost of repeated context reuse drops substantially — and context reuse is exactly what agent sessions do constantly. As Sam Altman framed it in the DevDay keynote, it's about giving developers "more room to build and run capable agents that reuse context across requests." (Wccftech)

Benchmarks: OpenAI's claims, honestly labeled

These are OpenAI's own benchmark claims, reported by the tech press. Treat them as the vendor's best case.

• DeepSWE v1.1 (complex software engineering): Sol matches Astra at ~1/5th the cost; beats predecessor GPT-6 Sol by 6.4 points.
• OSWorld 2.0 (agents operating a real computer): within 2.1 points of Astra at ~1/7th the cost per task.
• GDP.pdf (complex PDFs — tables, charts, fine print): scores higher than Anthropic's Opus 5.5 at less than half the cost per task.
• AutomationBench (multi-step business workflows): 2.2 points above Opus 5.5 at medium effort, ~1/3rd the cost.
• Terminal-Bench Science: $5.47/task on Sol vs $23.21 (Opus 5.5) and $23.80 (Astra) — though Astra holds the top score at 68.1%.
• Factuality: share of responses with factual errors on hard prompts fell 11.4% → 7.7% at low effort, within 1.9 points of Astra overall.

(Android Headlines; Wccftech)

One independent check exists: Artificial Analysis scored Sol 52 vs Astra 53 on its Intelligence Index — at $0.72 vs $3.26 per index task. Opus 5.5 still leads the index at 58, but at $5.98 per task. (dev.to)

Why cost-per-task beats benchmark scores

For production workloads, model selection balances capability, reliability, latency, and cost — not the top benchmark number. Agentic workloads consume tokens in long loops: tool calls, retries, self-correction, context replays.

The cost on your invoice is cost per completed task — not cost per token, not a benchmark number. A model that's slightly weaker on paper but several times cheaper, using cached context at a steep discount, wins on any workload where the capability gap doesn't change the outcome.

Cached-input pricing also reshapes agent architecture. Systems carrying big tool lists and long memories across dozens of turns — previously too expensive at scale — become economical. Which raises a question worth asking: has anyone recently checked whether your highest-cost model is doing anything the cheaper tier couldn't?

What this means for your business

If you run agents in production — coding assistants, document processing, support automation, multi-step back-office workflows — this release hands you a practical exercise:

Route, don't replace. Take a representative sample of current flagship-model traffic and replay it through Sol. Measure task success end to end — not benchmark scores. Move every workload where the gap is invisible to the cheaper model. Keep the flagship for the hard minority and route the volume.

Test before you trust. A cheaper model isn't a drop-in replacement. Evaluate on your own data, monitor for quality regression, set approval thresholds for the swap. Measure latency and failure modes alongside cost — a model needing two retries to match the flagship's first-pass success rate may not be cheaper in practice.

Price your automation per task, not per token. Build cost-per-completed-task into your agent observability now: retries, tool-loop turns, cache hits included. The moment you can see cost per task by workflow, model-routing decisions stop being debates and become arithmetic. Segment usefully: code generation by test pass rate, document extraction by accuracy, customer workflows by completion rate — then route per workload, not per company.

Use the cache deliberately. If your agents resend long system prompts and tool definitions every turn, Sol's $0.10 cached-input rate is where savings compound. Session design — what stays in context versus what gets re-fetched — is now a cost lever, not just an engineering choice.

Put budget controls behind the router. As agent volume grows, inference spend gets harder to predict. The same week Sol launched, Cribl launched StreamAI — an AI gateway routing each prompt to the right model with built-in budget controls. Whether you buy or build, a routing layer with spending controls helps manage agent costs at scale.

One caveat, repeated because it matters: all capability numbers above come from OpenAI's own tests. The third-party index broadly confirms the price-to-performance story. But your workloads are the only benchmark that counts — verify on your own data before committing.

The broader pattern

Sol replaces GPT-6 Sol just a week after that model's release, per the cited reporting. Model releases now behave like software patches rather than generational events.

The takeaway is durable: build pipelines model-agnostic, measure cost per completed task, and let the workhorse models carry the volume. Pricing and model changes will keep shifting automation economics — the teams that benefit most are the ones whose architecture can switch models in an afternoon.

Want to know what your agent workloads actually cost — and which ones could move to a model like Sol today? Start with our free AI audit: we'll map your current AI spend against task-level outcomes and show you where the routing wins are hiding.

FAQ

What is GPT-6.1 Sol?

OpenAI's lower-cost model announced at DevDay (Sept 29, 2026): $2/M input and $10/M output tokens — one-fifth of flagship Astra's rates — with cached input at $0.10/M. OpenAI claims it nearly matches Astra on agentic coding, computer use, and professional work.

How much cheaper is Sol per task, really?

Vendor benchmarks suggest dramatic gaps: ~1/5th the cost of Astra on DeepSWE v1.1 at parity, ~1/7th on OSWorld 2.0 within 2.1 points. Independent check (Artificial Analysis): $0.72 vs $3.26 per index task at scores of 52 vs 53. Your workloads are the only benchmark that counts — replay representative traffic before committing.

Should we switch our agents to Sol?

Route, don't replace: replay a representative sample of flagship traffic through Sol, measure task success end to end, and move workloads where the gap is invisible. Keep the flagship for the hard minority. Watch retries — a cheaper model needing two attempts may not be cheaper in practice.

What's the most important cost lever with Sol?

Cached context at $0.10/M (95% off standard input). Agents resend system prompts and tool definitions every turn — session design that maximizes cache reuse is now a cost lever, not just an engineering choice.

Sources

• 9to5mac.com — OpenAI Makes 20+ Announcements at DevDay
• madrobot.blog — OpenAI DevDay 2026: Everything Announced
• androidheadlines.com — OpenAI Launches GPT-6.1 Sol: Low Cost, Powerful AI
• wccftech.com — OpenAI DevDay 2026 Goes Live: Over 20 Product Launches
• dev.to — OpenAI DevDay 2026: Every Announcement, With Prices and Availability
• globenewswire.com — Cribl Launches StreamAI With Free Inference