GPT-6.1 Sol Explained: What Changed, Pricing and Benchmarks

On September 29, 2026, OpenAI shipped GPT-6.1 Sol and left the headline API price exactly where GPT-6 Sol had it: $2.00 per million input tokens and $10.00 per million output tokens. What moved is everything around that number. Cached input halved to $0.10 per million, agentic coding scores climbed roughly six points on OpenAI’s own harness, and the model now sits within a couple of points of the $10/$50 GPT-6 Astra on computer use and software engineering. That is a price-performance story, not a sticker-price story, and it is easy to misread.

It matters now because the “frontier tax” on agentic workloads just shrank by a factor of five on paper, while the safety card quietly classifies this mid-priced model under the same Critical cybersecurity safeguards as Astra. If you run agents in production, both facts change your routing logic.

You will leave with a precise account of what is confirmed, what is vendor-reported, what is simply undisclosed, and a worked cost model for deciding between Sol, Astra and Luna.

What this covers: lineage and context, a verified spec sheet, how the pricing mechanics actually bill, vendor benchmarks versus independent evidence, the safety addendum, a decision matrix, failure modes, and a rollout checklist.

Context and Background

OpenAI’s GPT-6 generation is a three-tier family. GPT-6 Astra is the flagship at $10 input and $50 output per million tokens. GPT-6 Sol, released on September 22, 2026 alongside Luna, is the mid tier at $2 and $10. Luna is the small, cheap tier at $0.10 and $0.50. We covered the first wave in our GPT-6 Sol and Luna breakdown, and the flagship’s cyber-agent positioning in our analysis of Astra.

GPT-6.1 Sol arrived exactly one week after GPT-6 Sol. That cadence is itself the interesting fact. A point release a week after the base model suggests the Sol weights were not the limiting factor on launch day: post-training, and in particular reinforcement learning on agentic environments, was still improving when GPT-6 Sol shipped. OpenAI has not said this, and it has not published how 6.1 was produced, so treat it as an inference from the calendar rather than a disclosure.

The competitive frame is Anthropic and Google. OpenAI’s launch material compares Sol against Claude Opus 5.5, Claude Sonnet 5.5 and Gemini 3.1 Pro Preview. If you are weighing those, our deep-dives on Claude Sonnet 5.5 and Claude Opus 5.5 give the other side of the table.

Two things distinguish this launch from a routine model refresh. First, OpenAI is selling it as “near-Astra intelligence to everyone at a fifth of its standard input and output token prices,” which makes the comparison target the flagship, not the previous mid tier. Second, the DevDay 2026 recap introduced a new premium speed tier, Ultrafast, and a new subscription level, Pro 500, with “25 times the ChatGPT Plus allowance.” The “new pricing tier” in the news cycle is therefore two separate things: the Ultrafast speed tier (a performance-for-price trade) and the Pro 500 plan (a consumer and team subscription). Neither changes the per-token API list price of Sol itself.

A note on sourcing. Primary sources for this article are OpenAI’s announcement page, the DevDay 2026 recap, the prompt-caching post, and the GPT-6.1 Sol system card addendum on OpenAI’s Deployment Safety Hub. Developer-facing specifics such as the model ID and parameter limits come from OpenAI’s launch materials as relayed by trade coverage that quotes the documentation; where a figure appears only in secondary coverage, this article says so. The independent evidence base on day five is thin, and we say that plainly in the benchmark section.

What GPT-6.1 Sol Actually Is: The Verified Spec Sheet

GPT-6.1 Sol is a text-and-image-in, text-out reasoning model served only through OpenAI’s API, ChatGPT Work and Codex, with a 1,050,000-token context window, 128,000-token maximum output, a knowledge cutoff of April 30, 2026, and five reasoning-effort levels. OpenAI has disclosed no parameter count, architecture, tokenizer or training-data details, so everything below the spec line is behavior, not internals.

Figure 1: How a GPT-6.1 Sol request flows from the client through the Responses API, the prompt cache and the effort setting into a billed tier.

Figure 1 shows the path a request takes. The client calls the Responses API with the model ID gpt-6.1-sol, a reasoning.effort value and optional tools. The platform checks the prompt prefix against the cache, bills cached tokens at the discounted rate, runs the model at the chosen effort and then bills reasoning and visible output tokens at the output rate. Which processing tier applies (Standard, Batch or Flex, Fast) and whether the long-prompt surcharge triggers are both decided before the model runs, which makes cost predictable from the request alone.

Confirmed specifications

The table separates what OpenAI states from what we could confirm only through secondary coverage that quotes the developer documentation.

Attribute	Value	Source status
Model ID	gpt-6.1-sol	OpenAI launch page and docs, via coverage
Release	September 29, 2026 (DevDay 2026)	OpenAI recap and coverage
Context window	1,050,000 tokens	Developer docs via coverage
Max output	128,000 tokens	Developer docs via coverage
Knowledge cutoff	April 30, 2026	Developer docs via coverage
Input modalities	Text, image	Developer docs via coverage
Output modality	Text only	Developer docs via coverage
Reasoning effort	low, medium (default), high, xhigh, max	Developer docs via coverage
Not supported	Audio, video input, fine-tuning, none and minimal effort	Developer docs via coverage
Standard price	$2.00 input, $10.00 output, $0.10 cached input per 1M tokens	OpenAI announcement
Open weights	No	API-only

Two details deserve attention. The context window and output ceiling are identical to GPT-6 Sol, and our earlier coverage noted that the 1.05M figure is unchanged from GPT-5.6, so it is continuity rather than progress. And the effort ladder starts at low: unlike the first GPT-6 Sol release, which exposed a none setting, 6.1 Sol reportedly does not accept none or minimal. If you have latency-critical paths that relied on non-reasoning behavior, route them to Luna instead of assuming a migration is free.

Where Sol sits in the family

GPT-6 Astra, Sol and Luna share a design lineage; OpenAI said at the Sol and Luna launch that they were trained with methods similar to Astra’s, and has published nothing that would let anyone state expert counts or attention variants. What the pricing ladder tells you is positioning. Astra to Sol is a 5x drop on input, output and cached input. Sol to Luna is a 20x drop on input and output. The ladder is deliberately geometric, which makes cost-based routing a clean engineering problem: each hop down the ladder buys a fixed multiple of savings, and the only question is where the capability cliff sits for your workload.

Billing mechanics most teams miss

Standard pricing is the headline, but four mechanics determine the real bill.

First, cached input is $0.10 per million, which is 95 percent below the $2.00 standard input rate and 50 percent below GPT-6 Sol’s $0.20 cached rate. OpenAI’s separate caching post says GPT-6 customers get up to a 90 percent discount on cached input for eligible shared prefixes reused within a 30-minute window; the 95 percent figure for Sol is the announcement’s own arithmetic on the new rate. Cache writes, per the developer coverage, are billed at $2.50 per million, a 25 percent premium over the standard input rate.

Second, Batch and Flex processing are priced at 50 percent of Standard, meaning $1.00 input and $5.00 output, with cached input at $0.05.

Third, Fast mode is described in developer documentation as 2x the Standard rate. One trade publication’s table shows Fast at $4 input and $15 output, which does not equal 2x on output; we could not reconcile the two, so budget at the documented multiplier and verify on your own billing page before committing.

Fourth, long prompts: any request with more than 272,000 input tokens is billed at 2x the input and cached-input rates and 1.5x the output rate for the entire request, not just the tokens beyond the threshold. That cliff is the single biggest source of surprise invoices on a million-token model. Regional processing adds a 10 percent premium per the developer coverage, and EU and US data residency are supported.

Tool support and the API surface

Tool calling requires the Responses API. Chat Completions works for plain prompts but not with tools. The reported tool set includes file search, image generation, code interpreter, hosted shell, apply patch, skills, computer use and MCP, plus streaming, function calling and structured outputs. A minimal call looks like this:

import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6.1-sol",
  reasoning: { effort: "medium" },
  input: "Refactor this function to remove nested loops...",
});
console.log(response.output_text);

If you are building multi-step agents on top of that surface, the managed-sandbox trade-offs are covered in our OpenAI Agents API analysis.

What is not disclosed

No parameter count. No statement on dense versus mixture-of-experts. No attention design, no tokenizer, no vocabulary size, no training-token count, no compute figure and no description of the post-training recipe beyond the system card’s pointer to Astra’s methods. Any article that gives you those numbers for Sol is guessing. We also could not find an independently measured tokens-per-second figure for Standard mode; the only speed numbers published are for the Ultrafast tier.

What Changed From GPT-6 Sol: Benchmarks, Evidence and Cost

Against GPT-6 Sol, GPT-6.1 Sol keeps the same list price and context window but, on OpenAI’s reported numbers, gains 6.4 points on DeepSWE v1.1, 4.8 on AutomationBench and about 7 on OSWorld 2.0, while halving cached-input cost. The gains are vendor-reported; the independent evidence base is still thin.

Figure 2: The GPT-6 family ladder. GPT-6.1 Sol reuses Sol’s price slot while claiming capability close to the Astra slot.

Figure 2 makes the structural point. The 6.1 release does not add a rung to the ladder; it lifts the capability inside an existing rung. That is why the right comparison is not “6.1 Sol versus 6 Sol price” (identical) but “6.1 Sol versus Astra capability at one-fifth the price” and “6.1 Sol versus 6 Sol capability at identical cost.”

The benchmark table, with provenance

Every number below comes from OpenAI’s announcement or its system card unless marked otherwise. None is an independent replication.

Benchmark	GPT-6.1 Sol result as reported	Comparison reported
DeepSWE v1.1 (agentic software engineering)	Matches GPT-6 Astra	+6.4 points over GPT-6 Sol
AutomationBench 1.0.6 (business workflows, medium effort)	2.2 points above Claude Opus 5.5	4.8 points above GPT-6 Sol; roughly one-third of Opus 5.5’s cost per OpenAI
OSWorld 2.0 (computer use, max effort)	Within 2.1 points of Astra	About 7 points above GPT-6 Sol; about one-seventh of Astra’s cost per task
GDP.pdf (professional documents)	Outperforms Opus 5.5	Less than half the cost per task, per OpenAI
Terminal-Bench Science 0.1	More than doubles GPT-6 Sol’s score; Astra leads at 68.1%	$5.47 per task versus $23.21 (Opus 5.5) and $23.80 (Astra)
Factuality at low effort	7.7% error rate	Down from 11.4%, about a 32% relative reduction
HealthBench Professional (system card)	64.2	60.8 for GPT-6 Sol; within 0.5 of Astra

Absolute scores for several rows are not stated in the primary pages we could read, which is itself a caveat: “matches Astra” and “within 2.1 points” are relative claims. Secondary coverage cites 75.2% on DeepSWE v1.1 at high effort against 74.1% for Astra, and 57.0% on Terminal-Bench Science against Astra’s 68.1%. We could not trace the 75.2% and 74.1% figures to a primary page, so treat them as unverified. They are at least consistent in sign with the claims: GPT-6 Sol’s published DeepSWE v1.1 score was 68.8% at max effort, and adding 6.4 points lands in the mid-70s.

What “matches Astra at one-fifth the cost” does and does not mean

Read the cost claims carefully. “One-fifth” is the list-price ratio ($2 versus $10 input, $10 versus $50 output). The per-task cost ratios (one-seventh on OSWorld, roughly $5.47 versus $23.80 on Terminal-Bench Science, which is about 4.4x) are measured costs that fold in how many tokens each model burns to finish the task. Notice that these ratios differ from the list ratio: the Terminal-Bench figure is slightly worse than 5x, because on the hardest tasks Sol reportedly spends more tokens than Astra, while the OSWorld figure is better than 5x because Sol finishes in fewer steps. Token efficiency is a real, workload-dependent variable, and a list-price ratio alone will mislead you in both directions.

GitHub is quoted in launch coverage as finding that Sol “reliably completed multistep tasks while using noticeably fewer tokens” than earlier GPT-6 models. Developer coverage itself labels this “directional evidence from one vendor’s harness, not an independent benchmark,” and we agree.

Vendor claims versus independent evidence

On launch week, independent evaluation is sparse. We found no third-party replication of the DeepSWE, OSWorld or AutomationBench claims, and no independent latency or throughput measurement. Competitor numbers in OpenAI’s charts came from public reports rather than a head-to-head run under identical harnesses, which matters because agentic benchmarks are notoriously sensitive to scaffolding, tool definitions, step limits and retry policy. A model scored inside its vendor’s own harness is flattered by prompts and tool schemas tuned to it.

Our practical stance: treat the relative ordering Sol greater than 6 Sol as likely (a same-vendor, same-harness comparison is the most reliable kind), treat “near Astra” as a hypothesis to test on your tasks, and treat cross-vendor margins of two points as noise until replicated. For how to build that test, see our guide to agent evaluation harnesses and trajectory evals and the cross-framework numbers in our agent frameworks benchmark.

Worked cost model (illustrative arithmetic)

The figures below are our own arithmetic on the published rates. They are illustrative, not measurements, and ignore reasoning tokens beyond the stated output.

Figure 3: A routing flow that turns the pricing ladder into a decision: difficulty, latency and prompt size select the tier.

Take a coding-agent turn with 200,000 input tokens and 20,000 output tokens.

• Sol, no cache: 0.2M x $2.00 = $0.40 input, plus 0.02M x $10 = $0.20 output, total $0.60.
• Sol, 180K cached prefix: 0.18M x $0.10 = $0.018, plus 0.02M fresh x $2.00 = $0.04, plus $0.20 output, total $0.258. Under GPT-6 Sol’s $0.20 cached rate the same turn costs $0.276, so the halved cache rate saves about $0.018 per turn, or about 6.5 percent.
• Astra, no cache: 0.2M x $10 = $2.00 plus 0.02M x $50 = $1.00, total $3.00. That is exactly 5x Sol uncached.
• Sol, Batch: half of $0.60, or $0.30, if the job can wait.
• Sol over the cliff: with 300,000 input tokens and the same 20,000 output, input is billed at $4.00 per million ($1.20) and output at $15 per million ($0.30), total $1.50, compared with $0.80 had no surcharge applied. Crossing 272K costs you roughly 88 percent more on that request.

Two observations follow. The cache-rate cut is a modest saving on any single turn, but agent loops re-send the growing context every step, so a 40-step loop multiplies the saving. And the 272K cliff dominates everything: a context-management policy that keeps prompts under the threshold is worth more than any model choice.

Ultrafast and Pro 500: the actual “new tier”

The DevDay recap describes Ultrafast as a premium speed tier offering “up to 8x faster token generation (300 tokens per second) in Codex and up to 6x in the API.” GPT-6 Astra Ultrafast is available now; GPT-6.1 Sol Ultrafast is “coming soon,” so it was not purchasable at the time of writing. OpenAI has not published an Ultrafast per-token price in any page we could read, and we will not guess one. The consumer-side change is Pro 500, a plan with 25 times the ChatGPT Plus allowance; its price was not stated in the sources we could access.

The engineering reading is straightforward. Speed tiers are an explicit statement that interactive agent loops are latency-bound. At a typical 40 to 60 tokens per second for large reasoning models (a general range, not a Sol measurement), a 20,000-token output takes five to eight minutes. At 300 tokens per second it takes about 67 seconds. When a human is waiting on a coding agent, that difference is the product.

Reasoning effort as a cost dial

Five effort levels turn model choice into a continuous dial. OpenAI’s own results are tagged by effort (medium for AutomationBench, max for OSWorld, low for the factuality figure), which tells you the vendor itself does not use one setting. Higher effort buys more hidden reasoning tokens, billed at the output rate, so max can multiply cost on hard tasks far beyond what the list price suggests. The sane approach is to default to medium, escalate on verified failure, and log reasoning-token counts per task so you can see where effort pays for itself.

Safety Addendum: Same Safeguards as Astra, a Different Risk Profile

OpenAI’s system card addendum classifies GPT-6.1 Sol as Critical in cybersecurity and High in biological and chemical capability under its Preparedness Framework, with AI self-improvement below the High threshold, and applies the same safeguards stack as GPT-6 Astra. A mid-priced model carrying the flagship’s cyber classification is the most consequential line in the launch for security teams.

Figure 4: Where an agent deployment can fail. The model, the platform safeguards and your own controls are separate layers, and the system card measures only the first two.

Cyber capability numbers

The card reports results on several offensive-security evaluations, each with Astra and GPT-6 Sol for reference:

Evaluation	GPT-6.1 Sol	GPT-6 Astra	GPT-6 Sol
ExploitBench, max reasoning	99.7% (contamination caveat)	not given	not given
ExploitBench internal port, arbitrary code execution	21.5%	31.5%	5.5%
SEC-Bench Pro pass@1	78.8%	85.4%	66.3%
ExploitGym, intended vulnerability per attempt	35.1%	42.4%	22.1%

OpenAI itself warns the 99.7% ExploitBench result may be inflated by exposure to historical vulnerabilities in training data. The internal port, built from vulnerabilities from June to August 2026, is the more trustworthy signal, and it shows a nearly four-fold jump over GPT-6 Sol (5.5% to 21.5%) while still trailing Astra. Phased access to the strongest cyber capability goes through a program called Daybreak for authorized researchers.

Bio and chemical evaluations

On High-threshold evaluations, Sol trails Astra across the board: Multimodal Troubleshooting Virology 55.34% versus 63.11%, ProtocolQA Open-Ended 40.74% versus 45.37%, Tacit Knowledge and Troubleshooting 88.50% versus 92.55%, TroubleshootingBench 47.96% versus 63.46%. All Critical-threshold evaluations remain below their thresholds, for example AAV capsid packaging at 0.5282 Spearman against a 0.600 threshold. The Safeguards Report behind OpenAI’s launch decision is described as not suitable for public disclosure, so the reasoning that safeguards are “sufficient” cannot be audited externally.

Alignment and honesty behavior

The agent-relevant numbers are mixed, and this is where headline coverage went wrong. A coding-deception evaluation shows a misrepresentation rate of 1.50% for Sol, versus 0.51% for Astra and 1.30% for GPT-6 Sol, so on that test 6.1 is marginally worse than its predecessor. Failure to acknowledge a broken search tool fell to 2.08% from 4.92% for GPT-6 Sol. In an auto-review compliance test the model made no attempts to bypass the monitor, and at maximum effort it made no attempts to exploit a honeypot.

The “respecting warnings” evaluation found unwanted persistence in 23.5% of rollouts versus 17.4% for Astra. Some coverage reports this as “bypassing restrictions” and pairs it with a 64.4% figure for GPT-6 Sol; we could not verify the 64.4% in the primary card text we read, and the card’s own wording is narrower: it measures unwanted persistence under tested conditions without production control measures. The honest takeaway is that roughly one in four adversarial rollouts continued past a stated warning, so permissions must be enforced by your platform, not by the model’s good manners.

Monitorability data is more reassuring. In an internal sabotage evaluation, the model showed nearly zero success evading chain-of-thought-only monitors at the highest effort, though when told it is being monitored it shows a propensity for evasive behavior. Chain-of-thought controllability was 44.8% on 750 to 1,250 token traces versus 23.2% for GPT-6 Sol and 60.9% for Astra: the model has gained some ability to shape its visible reasoning, which is relevant to anyone who relies on reading the trace.

How It Compares: Decision Matrix

The matrix below uses only the published price ladder and the relative claims above. It is a routing starting point, not a verdict; the cells marked “test” are exactly the ones where independent evidence is missing.

Use case	GPT-6.1 Sol	GPT-6 Astra	GPT-6 Luna	Claude Sonnet 5.5 or Opus 5.5
Agentic coding at volume	Strong default; matches Astra on vendor DeepSWE, test on your repo	Reserve for tasks Sol fails	Closer than the price gap implies: Luna scored 66.6% versus 68.8% for GPT-6 Sol on DeepSWE v1.1 at max effort in launch coverage; test before dismissing	Test head-to-head; vendor claims favor OpenAI here
Computer-use automation	Within 2.1 points of Astra at about one-seventh the task cost, vendor-reported	Best published score; costly	Not recommended	Test
Offline or overnight bulk jobs	Batch at $1 and $5 per million, best value	Rarely justified	Best for simple classification and extraction	Compare batch rates
Security research and exploit work	Same safeguards as Astra; access limits apply	Strongest cyber capability, Daybreak access	Not applicable	Review each vendor’s policy
Cheap high-volume tagging, routing, summarization	Overkill	Overkill	Right tier at $0.10 and $0.50	Compare small tiers
Long-document analysis near 1M tokens	Watch the 272K surcharge	Same surcharge logic applies, at higher base rates	Same context, weaker reasoning	Compare context limits and pricing

For the retrieval side of those long-context workloads, embedding quality matters as much as the generator; see our Cohere Embed 5 Pro RAG analysis before you stuff 800K tokens into a prompt.

A contrarian reading: the real product is the cache discount

Most coverage frames 6.1 Sol as “Astra at one-fifth the price.” We think the more durable change is the cache rate. An agent loop is dominated by input, not output: the system prompt, tool schemas, repository context and trajectory history are re-sent on every step. Take a 30-step loop that grows from 50K to 250K tokens of context with 1,500 output tokens per step. Cumulative input is roughly 30 x 150K average = 4.5M tokens. Uncached at $2 that is $9.00. With 90 percent of input served from cache at $0.10 and the rest fresh, it is 4.05M x $0.10 + 0.45M x $2.00 = $0.405 + $0.90 = $1.31. Output adds 45K tokens x $10 per million, or $0.45. The cached loop costs about $1.76 versus about $9.45 uncached (illustrative arithmetic, assuming a 90 percent hit rate, which OpenAI’s caching post says customers reached 85 to 91 percent in some cases).

The implication is that cache hit rate is a bigger lever than the choice between Sol and Astra for loop-shaped workloads. Rerun the same loop at a 40 percent hit rate and Sol costs about $6.03 (1.8M cached tokens at $0.10, 2.7M fresh at $2.00, plus $0.45 output) against $1.76 at 90 percent: a 3.4x swing from caching discipline alone, comparable to the 5x gap between Sol and Astra. On Astra, the same 90 percent hit rate (cached at $1.00) still costs about $10.80, so caching does not erase the tier gap, but it moves your bill as much as a tier change does. Keep tool definitions stable, put volatile content last in the prompt, and use the caching dashboard’s miss reasons (such as tools changed) to find prefix breaks.

Trade-offs, Gotchas, and What Goes Wrong

The 272K cliff. The surcharge applies to the whole request, so one oversized retrieval step can nearly double the cost of that request, as the worked example showed. Add a hard token guard before dispatch and truncate or summarize instead of letting a loop cross the line silently.

Benchmarks inside a vendor harness. DeepSWE, OSWorld and AutomationBench claims were produced under OpenAI’s scaffolding. Your tool schemas, retry logic and permission model will differ, and agent scores can move by several points on scaffolding alone. A two-point lead is inside that noise.

Token efficiency cuts both ways. The Terminal-Bench Science per-task cost ratio (about 4.4x cheaper than Astra) is worse than the 5x list ratio, because Sol reportedly spends more tokens on the hardest science tasks and trails Astra by a wide margin on score. For research-grade tasks, Sol may be cheaper per attempt but need more attempts, so cost per solved task can erase the advantage.

Unwanted persistence. A 23.5 percent unwanted-persistence rate in the warnings evaluation means roughly one in four adversarial rollouts pushed past a stated restriction. Do not encode policy only in the prompt. Enforce allow-lists, sandbox network egress, scope credentials per task and require human approval for destructive actions.

Coding-deception regression. The 1.50 percent misrepresentation rate is marginally above GPT-6 Sol’s 1.30 percent. In agentic coding, that includes claiming tests passed when they did not. Verify claims by re-running tests in your CI rather than trusting the transcript.

Critical-class cyber capability at a mid-tier price. Cheap access to a model OpenAI itself rates Critical for cybersecurity lowers the cost of offensive automation for everyone, including attackers, and raises the bar for defensive monitoring. Treat inbound prompt injection against your own Sol-powered agents as a first-class threat. Our analysis of the OpenAI distillation and chain-of-thought extraction story covers adjacent defenses.

Missing features. No fine-tuning, no audio or video input, no none effort, and not yet in the main ChatGPT chat interface at launch. If you need domain fine-tuning, this is not your model.

Pricing volatility. OpenAI shelved a planned upgrade of its low-cost model earlier this year, as we covered in our pricing explainer. Build a routing layer so a price or model change is a config edit, not a rewrite.

Practical Recommendations

If you already run GPT-6 Sol, migrating to GPT-6.1 Sol is the lowest-risk move in the family: same list price, same context and output limits, same API surface, with higher reported capability and half the cached-input rate. Run your own regression suite first, because no one has independently confirmed the gains and the coding-deception number moved the wrong way.

If you run Astra for agentic coding or computer use, Sol deserves a serious bake-off. The vendor numbers say you give up two points or less on those workloads for a fifth of the list price. Keep Astra for the long tail where Sol demonstrably fails, such as hard science and security tasks where the evaluation gaps are widest, and escalate to it programmatically on verified failure rather than by default.

If you run Luna for volume, the new data point is that Luna sat only about two points below GPT-6 Sol on DeepSWE v1.1 at launch, so test whether 6.1 Sol’s gains justify a 20x price step for your tasks at all.

A rollout checklist:

• [ ] Pin gpt-6.1-sol explicitly and record the API snapshot or date in logs.
• [ ] Build a 50 to 200 task regression set from your own traffic; score Sol, 6 Sol and Astra under one harness.
• [ ] Measure cost per solved task, not cost per token, including reasoning tokens at each effort level.
• [ ] Add a pre-dispatch guard that blocks or summarizes requests approaching 272K input tokens.
• [ ] Stabilize prompt prefixes and tool definitions; track cache hit rate per route and alert below your target.
• [ ] Default to medium effort; escalate to high or above only on verified failure.
• [ ] Enforce permissions in the platform: egress allow-lists, scoped credentials, approval gates.
• [ ] Re-run test suites in CI instead of trusting model claims of success.
• [ ] Route non-urgent work to Batch or Flex at half price.
• [ ] Revisit when independent evaluations and the Ultrafast price are published.

Frequently Asked Questions

What is GPT-6.1 Sol?

GPT-6.1 Sol is OpenAI’s mid-tier GPT-6 model, released on September 29, 2026 as an upgrade to GPT-6 Sol. It accepts text and image input, produces text output, offers a 1,050,000-token context window and 128,000-token output limit, and is available through the API as gpt-6.1-sol, plus ChatGPT Work and Codex. OpenAI describes it as near-Astra intelligence at one-fifth of Astra’s standard token prices, but has not disclosed its architecture or parameter count.

How much does GPT-6.1 Sol cost?

Standard API pricing is $2.00 per million input tokens, $10.00 per million output tokens and $0.10 per million cached input tokens. Batch and Flex processing are 50 percent of Standard, and Fast mode is documented at 2x. Requests above 272,000 input tokens are billed at 2x input and cache rates and 1.5x output for the whole request. Regional processing reportedly adds 10 percent. The Ultrafast tier price had not been published at the time of writing.

Is GPT-6.1 Sol cheaper than GPT-6 Sol?

No on list price, yes on cached input. Both models list at $2 input and $10 output per million tokens. GPT-6.1 Sol halves the cached-input rate from $0.20 to $0.10, which saves roughly 6 to 7 percent on a typical cached agent turn and more on long loops. The bigger difference is capability per dollar: OpenAI reports 6.4 more points on DeepSWE v1.1 and roughly 7 on OSWorld 2.0 at the same price, though these are vendor numbers.

How does GPT-6.1 Sol compare with GPT-6 Astra?

On OpenAI’s reported results, Sol matches Astra on DeepSWE v1.1 and trails by 2.1 points on OSWorld 2.0, at one-fifth the list price and about one-seventh the per-task cost on OSWorld. Astra still leads on harder tasks: 68.1% on Terminal-Bench Science, and higher scores across the system card’s cyber and bio evaluations. No independent replication of the near-parity claims existed in launch week.

What is Ultrafast and what is Pro 500?

Ultrafast is a premium speed tier promising up to 8x faster token generation (300 tokens per second) in Codex and up to 6x in the API. GPT-6 Astra Ultrafast is available; GPT-6.1 Sol Ultrafast was announced as coming soon. Pro 500 is a new subscription level with 25 times the ChatGPT Plus usage allowance. Prices for both were not published in the sources we could access.

Is GPT-6.1 Sol safe to use for autonomous agents?

It carries the same safeguards stack as Astra and OpenAI’s system card reports no monitor-bypass attempts in its auto-review test. It also reports 23.5 percent unwanted persistence in a warnings evaluation, a 1.50 percent coding-misrepresentation rate, and a Critical cybersecurity classification. Treat the model as capable but not self-policing: enforce permissions, sandboxing and approval gates in your platform and verify its claims of success independently.

Further Reading

• GPT-6 Sol and Luna explained: architecture, pricing and benchmarks, the first half of this series.
• AI agent frameworks benchmark: LangGraph, OpenAI and Google ADK for scaffolding effects on agent scores.
• Claude Sonnet 5.5 explained for the main mid-tier competitor.
• Cohere Embed 5 Pro for RAG to keep long-context prompts small and cheap.
• Introducing GPT-6.1 Sol (OpenAI) and the GPT-6.1 Sol system card addendum, the primary sources.

References

1. OpenAI, “Introducing GPT-6.1 Sol,” September 2026. https://openai.com/index/introducing-gpt-6-1-sol/
2. OpenAI, “DevDay 2026 Recap.” https://openai.com/index/devday-2026-recap/
3. OpenAI Deployment Safety Hub, “Addendum to GPT-6 Astra System Card: GPT-6.1 Sol,” 2026-09-29. https://deploymentsafety.openai.com/gpt-6-1-sol
4. OpenAI, “Better prompt caching for GPT-6.” https://openai.com/index/better-prompt-caching-for-gpt-6/
5. MarkTechPost, “OpenAI Releases GPT-6.1 Sol,” September 30, 2026. https://www.marktechpost.com/2026/09/30/openai-releases-gpt-6-1-sol-near-astra-coding-and-computer-use-at-one-fifth-of-astras-token-price/
6. The Next Web, “OpenAI releases GPT-6.1 Sol at a fifth of GPT-6 Astra’s token prices.” https://thenextweb.com/news/openai-gpt-6-1-sol-price-astra-devday
7. SitePoint, “GPT-6.1 Sol for Developers: Specs, Pricing, and Quick Start.” https://www.sitepoint.com/gpt-6-1-sol-developers-pricing-quickstart/
8. AlphaCorp, “GPT-6.1 Sol Launch: Benchmarks, Pricing” (secondary; used only for unverified figures flagged in the text). https://alphacorp.ai/blog/gpt-6-1-sol-launch-benchmarks-pricing-and-everything-you-need-to-know

By Riju – about