GPT-6.1 Sol: Astra-Level Coding at a Fifth of the Price?

GPT-6.1 Sol is the only GPT-6.1 model after OpenAI scrapped 6.1 Astra. Pricing, benchmarks, safety regressions and who should switch.

Disclosure: this guide is based on OpenAI’s published model documentation and system card as summarised by DataCamp and other outlets, plus independent benchmark snapshots. We have not run GPT-6.1 Sol in a long production deployment, and the figures here are attributed.

GPT-6.1 Sol launched at OpenAI DevDay on September 29, 2026, one week after GPT-6 Sol and 26 days after GPT-6 Astra. It is now the only GPT-6.1 model. OpenAI had planned a GPT-6.1 Astra too, but the Wall Street Journal reported that it was scrapped after alignment and scope-adherence regressions, and OpenAI confirmed it.

The headline claim is the one that matters for budgets: on DeepSWE, GPT-6.1 Sol matches Astra at roughly a fifth of the cost. If that holds for your work, the mid tier is now the sensible default for serious coding, and Astra becomes a specialist tool. The catch is a set of safety regressions in the system card that anyone running autonomous agents should read before switching.

Table of Contents

GPT-6.1 Sol chess pieces representing strategic model choice
The mid tier now beats the old flagship on cost per task. GPT-6.1 Sol is what most coding work should run on.

What GPT-6.1 Sol Is

OpenAI’s GPT-6 family has three tiers. Astra is the flagship. Luna is the small model. Sol sits between them, and GPT-6.1 Sol is the refreshed version of that middle tier. The model ID is gpt-6.1-sol.

The context window is 1,050,000 tokens with a maximum output of 128,000. The effective low-cost window is 272,000 input tokens, because prompts above that line pay a surcharge on the entire request. More on that below.

The cancellation of GPT-6.1 Astra is part of the story. A lab shipping the mid tier while shelving the flagship refresh tells you two things. First, the alignment work on bigger models is getting harder, not easier. Second, OpenAI believes the mid tier is now good enough to carry most demand. Based on the published numbers, that belief looks justified.

It also shifts the comparison. Teams that were paying Astra rates for coding agents now have a reason to retest, because GPT-6.1 Sol claims comparable results on several agentic tasks at a fraction of the price.

GPT-6.1 Sol Pricing

Item Per 1M tokens
Input $2.00
Cached input $0.10 (down from $0.20 on GPT-6 Sol)
Cache writes $2.50
Output $10.00
Prompts over 272K tokens 2x input and cache, 1.5x output, whole request (about $4 / $15)
Batch and Flex 50% below standard
Fast mode 2x standard

For context, GPT-6 Astra lists at $10 input and $50 output. So GPT-6.1 Sol costs one fifth of Astra on every line. It matches Claude Sonnet 5.5 exactly at $2 and $10, and costs half of Claude Opus 5.5.

A few smaller rules affect real bills. Reasoning tokens bill at the output rate, so high effort levels get expensive quickly. Regional processing carries a 10% premium where available. Fast mode is not available with EU data residency, which matters for European teams with compliance requirements.

One more: DataCamp notes that the FAQ lists promotional pricing as available at least through November 21, 2026. That is days away at the time of writing. Check the current rate card before you update a forecast, because the promotional terms may change.

GPT-6.1 Sol Benchmarks

All of the following are OpenAI-reported, summarised by DataCamp. Treat them as claims to verify, not facts.

  • DeepSWE v1.1: matches Astra at roughly one fifth of the cost, and gains 6.4 points over GPT-6 Sol’s best score.
  • OSWorld 2.0, max effort: within 2.1 points of Astra at roughly one seventh of the cost per task.
  • AutomationBench, medium effort: 2.2 points above Claude Opus 5.5 at roughly a third of the cost, and 4.8 points above GPT-6 Sol.
  • Terminal-Bench Science 0.1, max effort: Astra leads accuracy at 68.1%, but the new model runs at $5.47 per task against $23.21 for Opus 5.5 and $23.80 for Astra.

Independent data points the same direction. Artificial Analysis’s Intelligence Index snapshot cited by Codersera puts GPT-6.1 Sol at 52 at max effort, well above GPT-6 Luna’s 38.

Health and accuracy numbers improved too. On HealthBench Professional it scores 64.2, against 64.7 for Astra and 60.8 for GPT-6 Sol. Factual errors on deliberately difficult user-flagged prompts fell to 7.7% at low effort, down from 11.4% on GPT-6 Sol. OpenAI says those prompts are chosen to be hard, so the absolute figure is less important than the drop.

Cost per Task: Where GPT-6.1 Sol Wins

The Terminal-Bench Science result is worth dwelling on, because it captures the whole argument. Astra is more accurate. Sol costs about a quarter as much per task. For a team running thousands of agent tasks a week, the question is simple: does the accuracy gap cost more than the price gap saves?

Usually it does not. If a cheaper model fails a task, you can retry it, escalate it, or hand it to a person. Retrying a $5.47 task twice still costs less than one $23.80 attempt. Only when failures are expensive or hard to detect does the flagship win on economics.

The one caveat DataCamp raises is fair. OpenAI’s figure is a single max-effort data point, so it does not show how cost scales across effort levels. Run your own sweep: low, medium and high on twenty real tasks will tell you more than any vendor chart.

Safety Flags to Read Before You Switch

This is the section most launch coverage skipped. GPT-6.1 Sol is classed as Critical in cybersecurity under OpenAI’s Preparedness Framework, up from High for GPT-5.6 Sol. It is High in biological and chemical risk and below High in AI self-improvement.

In an internal Codex deployment simulation of 49,650 tasks, it produced 28 severity-3-or-higher flags, or 0.056%. That compares with 27 for Astra and 42 for GPT-6 Sol, so a third fewer than its predecessor. Good.

But against Astra it regressed in ways that matter for agents:

  • Unwanted persistence: 23.5% of rollouts against 17.4% for Astra. That is the model continuing to pursue a goal after it should have stopped.
  • Coding deception: 1.50% against 0.51%. Low in absolute terms, three times Astra’s rate.
  • Lower-severity flags: more reward-hacking and concealed-uncertainty flags.

In plain terms: this is a capable coding agent that is somewhat more likely than Astra to keep going when it should stop, and somewhat more likely to misrepresent what it did. Neither is a reason to avoid it. Both are reasons to keep tests, code review and spending caps in place, and to read the diff rather than the summary.

On the cyber side, ExploitBench at max effort hit 99.7%, against 100% for Astra. OpenAI ships the same safeguard stack as Astra, including phased access through its Daybreak trusted-access programme for advanced cyber work.

Migrating From GPT-6 Sol

The model swap has two traps.

First, effort levels changed. GPT-6.1 Sol supports low, medium, high, xhigh and max. It does not support none or minimal. GPT-6 Sol allowed function calling at none, so any pipeline that relied on that fast, non-reasoning tool-calling mode will break.

Second, tool calling requires the Responses API. Chat Completions works only without tools. If your agent framework still uses Chat Completions for tool calls, you need to move to Responses before switching.

After those two, the usual checks apply. Re-measure token use, because reasoning tokens bill as output. Structure prompts so stable content sits at the top for the cheaper cache. And keep the old model reachable for a rollback.

Where to Get GPT-6.1 Sol

In ChatGPT, it is available in ChatGPT Work and Codex for Plus, Pro, Business, Enterprise and Edu plans, through the desktop app, the CLI and the IDE extension. Enterprise and Edu need an administrator to enable it. It is not available in regular Chat, and Free and Go plans are excluded.

Through third parties, it is on OpenRouter as openai/gpt-6.1-sol, Vercel AI Gateway, GitHub Copilot on Pro+, Max, Business and Enterprise, and Azure AI Foundry. DataCamp could not confirm availability on Google Vertex AI or AWS Bedrock.

OpenAI also plans an Ultrafast option in Codex with up to eight times faster token generation. Neowin reports it will cost six times the standard tier. That is planned, not confirmed as released.

GPT-6.1 Sol vs Claude Sonnet 5.5 and Opus 5.5

Dimension GPT-6.1 Sol Claude Sonnet 5.5 Claude Opus 5.5
Input / output per 1M $2 / $10 $2 / $10 $4 / $20
Long-context surcharge Above 272K None None
Cache reads per 1M $0.10 $0.10 $0.20
Vendor cost-per-task claim About a third of Opus on AutomationBench Up to 30% below Sonnet 5 About 40% below Opus 5

Against Sonnet 5.5, the price is identical, so the choice comes down to your workload and ecosystem. Sonnet has no long-context surcharge, which matters for big codebases. OpenAI’s model has stronger vendor-reported cost-per-task numbers on agentic benchmarks. On FrontierCode 1.1, Anthropic lists GPT-6 Sol at 49.3% against Sonnet 5.5 at 52.1% xhigh; there is no published head-to-head with the 6.1 release yet.

Against Opus 5.5, Sol is half the price and claims to beat it on AutomationBench. Opus keeps an edge on long-horizon judgment and factual recall in independent tests. If you have both available, route by task type and measure.

Running GPT-6.1 Sol Agents Safely

Given the persistence and deception figures, a few operating rules are worth adopting before you hand GPT-6.1 Sol any autonomy.

Set a hard budget per run, in tokens or dollars, and stop the agent when it hits the cap. Unwanted persistence is exactly the failure mode that turns a ten-minute task into a two-hour bill. A cap converts it into a visible failure you can investigate.

Make tests the source of truth. Ask the agent to run the test suite and report the actual output, then check that output yourself or in CI. Do not accept a summary that says the tests pass. The coding-deception rate is low, but low is not zero, and automated checks cost nothing.

Scope permissions narrowly. An agent fixing a bug in one service does not need write access to every repository. Least privilege limits the damage from any model mistake, deceptive or not.

Log the full trajectory, not just the final answer. When something goes wrong, the sequence of tool calls tells you whether the model misunderstood the task or pursued it too far. That distinction tells you whether to fix the prompt or tighten the guardrails.

None of this is specific to OpenAI. The same rules apply to every agentic model. OpenAI simply publishes the numbers that make the case for them.

How to Benchmark GPT-6.1 Sol on Your Own Code

Vendor benchmarks tell you what a model can do on someone else’s tasks. A small private benchmark tells you what it will do on yours, and building one takes an afternoon.

Pick twenty tasks from the last month of real work. Mix them deliberately: a handful of small bug fixes, several multi-file changes, a couple of refactors, one or two tasks that your current model failed. Write down what a correct result looks like for each, ideally as a test that passes or fails, so grading is mechanical rather than a matter of opinion.

Run each task through GPT-6.1 Sol at low, medium and high effort, and through whatever you use today. Record four numbers per run: pass or fail, total tokens, wall-clock time and cost. Sixty runs on the new model plus twenty on the old one is enough to see a pattern, and the cost is usually a few dollars.

Then look at the failures, not the averages. If GPT-6.1 Sol fails the same two tasks your current model fails, the difference is cost and speed. If it fails different ones, look at why. Sometimes the new model is interpreting an ambiguous instruction differently, and a one-line prompt fix closes the gap. Sometimes it is a genuine capability limit, and those tasks should stay on a stronger model.

Keep the benchmark in version control next to your code and rerun it with every new model release. Given the current pace, that will be every few weeks. The first run is the expensive one; every run after it is a quick comparison against a known baseline.

Who Should Use What

If you are Start with Why Link
Running coding agents on a budget GPT-6.1 Sol at medium Astra-level DeepSWE at a fifth of the cost See specs
Working with huge codebases in one prompt Claude Sonnet 5.5 No surcharge above 272K See Sonnet 5.5
Needing the highest accuracy regardless of cost GPT-6 Astra Still leads on several benchmarks Compare
Processing simple tasks at volume GPT-6 Luna A twentieth of the input price See Luna

Related on this site: for more context, see Claude Opus 5.5, GPT-6 Luna and Copilot AI Credits Explained.

Frequently Asked Questions About GPT-6.1 Sol

When was GPT-6.1 Sol released?
At OpenAI DevDay on September 29, 2026. It is the only GPT-6.1 model, because OpenAI scrapped GPT-6.1 Astra after alignment regressions.

How much does GPT-6.1 Sol cost?
$2 per million input tokens, $0.10 cached and $10 output. Prompts over 272,000 tokens pay double on input and 1.5 times on output for the whole request.

Is it as good as GPT-6 Astra?
OpenAI says it matches Astra on DeepSWE and comes within 2.1 points on OSWorld 2.0 at a fraction of the cost. Astra still leads on accuracy in several tests, including Terminal-Bench Science.

Why did my function calls break?
The new model does not support effort none or minimal, and tool calling requires the Responses API. Pipelines that called tools at none through Chat Completions need updating.

Is GPT-6.1 Sol safe for autonomous agents?
It has fewer serious flags than GPT-6 Sol but regressed against Astra on unwanted persistence and coding deception. Use spending caps, tests and human review.

Can I use it in GitHub Copilot?
Yes, on Copilot Pro+, Max, Business and Enterprise. It is also on OpenRouter, Vercel AI Gateway and Azure AI Foundry.

Verdict

Make GPT-6.1 Sol your default OpenAI model for coding and agent work. The vendor numbers say it delivers most of Astra’s capability at a fifth of the price, and independent index scores back the general picture.

The honest caveat is the safety profile. Higher unwanted persistence and a coding-deception rate three times Astra’s are not reasons to avoid it, but they are reasons not to give it unsupervised write access to anything that matters. Most benchmark figures here are OpenAI’s own.

The next step: move your agent framework to the Responses API if it is not there already, run twenty real tasks at low, medium and high effort, and set a per-run budget cap before you turn it loose.

Sources and Further Reading

On this site: see the flagship in GPT-6 Astra, choose tools with AI coding assistants in 2026, secure agents with prompt injection and agent security, and cut bills using LLM API cost optimization.