Source: full-scope review not established · Advice: under review Details
Buying-guide review: October 22, 2026. Original task observations: October 19. Launch benchmarks and earlier observations retain their dates.
Start with GPT-6.1 Sol for repeatable work you can check. Trial Claude Opus 5.5 when Sol misses important requirements, needs repeated corrections or leaves enough review work to justify the extra cost.
Our small procurement comparison found correct calculations from both models, alongside a difference in the recorded output formatting. It does not establish a general winner for coding, research or document work.
Already getting reliable results from Opus? Keep that workflow while testing Sol against the same acceptance checks. Include failed attempts, review time and migration work when comparing costs.
Music, footage and AI tools for videoWhat Kingy checked
Eight procurement responses reviewed; production workflows remain untested.
On October 19, 2026, we supplied three synthetic procurement tasks to each model and repeated the quote-comparison task once. We retained four answers per model.
Sol used Codex CLI; Opus used the Claude web app. Both were set to Medium effort, but their client instructions and context differed. This was not a controlled API comparison.
| Check on the retained answers | Sol 6.1 | Opus 5.5 |
|---|---|---|
| Calculations and substantive task requirements | All four passed | All four passed |
| Raw JSON-only formatting | Four passed | One passed; three contained Markdown fences |
| Model correction prompts | None | None |
| API dollar cost and human correction time | Not measured | Not measured |
The formatting result applies to these retained client outputs. It does not establish API structured-output reliability or a general success rate. Correct calculations and compliance with the required output format are separate checks.
Inspect the full task records
On October 19, 2026, Kingy ran three fixed synthetic procurement cases and one repeated quote case per model. Sol used Codex CLI 0.163.0-alpha.10.2 at Medium; Opus used the Claude web app’s Opus 5.5 selector at Medium. We retained four answers per model. The same user prompts were supplied, but client instructions and context differed. Claude did not expose its backend snapshot or token usage.
Show the exact quote-comparison input
You are checking synthetic supplier quotes for a four-seat team buying 12 months of service. Use only these rows. Q1: A costs USD18 per seat per month, paid monthly, plus a one-time USD40 setup fee. Q2: B costs USD16 per seat per month, billed for all 12 months upfront, plus a one-time USD100 setup fee. Q3: C costs EUR15 per seat per month, no setup fee; no EUR/USD exchange rate is supplied. Ignore tax for every quote. Total first-year budget is USD900; upfront cash is not separately constrained. Return only a JSON object with eligible_totals_usd (object keyed A and B), recommendation (supplier letter), excluded (object keyed by supplier with the missing information), and source_rows (object mapping A/B/C to the source row IDs). Calculate first-year totals, recommend the cheapest qualifying USD quote, and do not invent currency conversion.
The reference arithmetic is A: 4 × 12 × $18 + $40 = $904; B: 4 × 12 × $16 + $100 = $868. B qualifies under $900; A misses by $4. C totals €720, but the missing exchange rate prevents a USD comparison. Neither model should invent that rate.
| Recorded check | Sol 6.1, Codex CLI | Opus 5.5, Claude app |
|---|---|---|
| Quote arithmetic, original and repeated case | A $904; B $868; choose B; missing exchange rate identified in both answers. | Same correct totals, recommendation and missing-rate treatment in both answers. |
| Nine-option annual-seat allocation | All nine rows correct; choose 3 annual seats, $492 upfront and $972 first-year total. | Same correct rows and recommendation. |
| Upgrade claim with no timing evidence | Correct $300 premium and 5-hour/300-minute break-even; no guaranteed ROI invented. | Same supported calculation and uncertainty. |
| Raw JSON-only instruction | All four retained outputs passed the raw-format check. | Three outputs had Markdown fences and failed strict raw-JSON parsing; the upgrade answer passed. |
| Model correction prompts | None. The second quote run repeated the input; it was not a repair. | None. The second quote run repeated the input; it was not a repair. |
| Human correction time | Not measured. | Not measured. Removing fences is a possible integration repair, not a timed observation. |
| Actual dollar cost per accepted task | Not measured; included subscription access was used. | Not measured; included subscription access was used. |
Show actual Opus 5.5 Medium first quote output, unchanged
```json
{
"eligible_totals_usd": {
"A": 904,
"B": 868
},
"recommendation": "B",
"excluded": {
"C": "EUR/USD exchange rate not supplied; EUR 720 first-year total (15 x 4 seats x 12 months) cannot be converted to USD"
},
"source_rows": {
"A": "Q1",
"B": "Q2",
"C": "Q3"
}
}
```
Show actual gpt-6.1-sol first quote output, unchanged
{
"eligible_totals_usd": {
"A": 904,
"B": 868
},
"recommendation": "B",
"excluded": {
"C": "Missing EUR/USD exchange rate."
},
"source_rows": {
"A": "Q1",
"B": "Q2",
"C": "Q3"
}
}
The arithmetic tie gives no evidence that Opus’s higher price bought a better answer on these cases. Sol is therefore a reasonable first trial for this narrow, checkable workflow. The format difference is an observation about the retained client outputs; it does not establish API structured-output reliability or a general model success rate.
Our checker evaluated fenced JSON separately from raw-format compliance, so the correct numbers did not hide the formatting failure. A grader wording issue on Sol’s upgrade answer was corrected without changing the answer; the original and corrected review remain in the retained evidence. No matched latency measurement or human preference study was performed.
Download the exact prompts, eight retained answers and validation results (JSON). The cases are synthetic inputs; the answers are actual recorded model outputs.
Choose by task; switch when these checks fail
Checked, repeated work
Difficult work with costly errors
Large documents and long conversations
A workflow that already works
These are editorial starting rules, not measured universal rankings. A practical escalation policy is one first attempt and one targeted correction, followed by the other model or human review if the acceptance check still fails. Set that limit before the trial and include every attempt in its cost.
For a lower-priced Anthropic alternative, see Sonnet 5.5 versus Opus 5.5. This guide stays focused on the exact Sol 6.1/Opus 5.5 pair.
What your workload could cost
Sol’s price advantage depends on the request
Sol’s Standard fresh-input and output rates are half Opus’s below the long-context threshold. Above 272,000 input tokens, Sol’s higher rates apply to the whole request: fresh input and cache reads then match Opus’s rates, while output remains cheaper.
Price the complete request before assuming a 50% saving.
Calculated equal-token examples—not measured costs from our procurement checks. These examples use the current rates rechecked October 22, 2026. All amounts are USD at standard API rates.
| Input assumptions | Output assumptions | Sol estimate | Opus estimate | Caveat |
|---|---|---|---|---|
| Short request: 10,000 fresh input tokens | 2,000 billable output tokens | $0.04 | $0.08 | Ordinary input pricing; no cache write. |
| Cached request: 100,000 cache-read + 10,000 fresh input tokens | 10,000 billable output tokens | $0.13 | $0.26 | Assumes a cache hit; initial write excluded. |
| Long request: 400,000 fresh input tokens | 20,000 billable output tokens | $1.90 | $2.00 | Sol’s higher rates apply to the whole request above 272,000 input tokens. |
Open the matching 100-request Sol versus Opus budget. The setup uses 10,000 fresh input tokens, 2,000 output tokens, no additional reasoning/cache/tool charges and 100 calls: calculated totals are $4 for Sol and $8 for Opus. These are hypothetical equal-token requests, not the cost of the procurement runs above. Change the reasoning, cache and acceptance assumptions to match your own logs.
The examples assume identical billable token counts, including reasoning output, and exclude tools, retries, infrastructure and review. Providers can tokenize the same text differently; equal token counts do not imply equal output quality or first-pass success. See the full formulas and cache-write example, OpenAI rates, Sol’s long-context rule and Claude rates.
At an assumed review-time value of $60/hour, the $0.04 saving on one short request pays for only 2.4 seconds of extra review. Across 100 requests, $4 pays for four minutes. The $0.10 difference on the long request pays for six seconds. These are calculated break-even thresholds using an illustrative labor rate; no reviewer timing was measured in our task observations.
Full API rates, caching, formulas and fallback charges
API pricing: Sol is half price until long context changes the bill
The following are per-million-token rates for direct, standard API processing. A cache write is a separate billing category from an ordinary input token or a later cache read.
| Billable category | Sol: input ≤272K | Sol: input >272K | Opus: full context |
|---|---|---|---|
| Fresh input | $2.00 | $4.00 | $4.00 |
| Cache read | $0.10 | $0.20 | $0.20 |
| Cache write | $2.50 for 30 minutes; $5.00 for 12 hours | $5.00 for 30 minutes; $10.00 for 12 hours | $5.00 for 5 minutes; $8.00 for 1 hour |
| Output, including billable reasoning | $10.00 | $15.00 | $20.00 |
OpenAI’s price schedule applies the long-context rates to the entire request once input exceeds 272K tokens. Anthropic includes Opus’s full 1M context at standard rates. Above Sol’s threshold, fresh input and cache reads cost the same as Opus, while Sol output remains 25% cheaper.
The threshold can create a sharp change in a growing agent conversation. With 272K fresh input tokens and 20K output tokens, Sol costs $0.744. At 273K fresh input and the same output, it costs $1.392. That is an 87% increase for a 1K-token increase in input. Opus’s corresponding cost moves from $1.488 to $1.492. These are calculations from the rate schedules, with other charges excluded.
This makes compaction, retrieval, and the size of tool responses economically relevant. An agent that keeps appending full documents may cross a pricing threshold even when the final answer stays short. Record the actual billable input on each request rather than estimating from the length of the user’s original prompt.
Caching helps both models, with different retention rules
Cache-pricing correction, October 20, 2026: OpenAI documents a 1,024-visible-token minimum for GPT-6.1 Sol and two minimum lifetimes in the Responses API: 30 minutes by default, or 12 hours using prompt_cache_options.ttl: "12h". A 12-hour write costs twice a 30-minute write; read prices are unchanged. Upgrading valid 30-minute coverage to 12 hours bills a new 12-hour write without credit for the earlier write. A 30-minute read refreshes coverage to at least 30 minutes after the read, preserving any later existing expiry; it does not restart a 12-hour clock. Minimum lifetime is not a deletion deadline or a promise of faster responses.
Opus 5.5 supports caching from 512 tokens, with a five-minute default lifetime or an optional, higher-priced one-hour lifetime. A cache hit refreshes that lifetime. The clock starts when the request that writes or reads the entry begins; response generation uses part of the window. A four-minute response therefore leaves roughly one minute for the next matching request to begin under the five-minute option. These are different retention contracts, so the two write prices should not be treated as identical products.
Keep stable instructions, tool definitions, and reused source material in a consistent prefix. Changing that prefix or waiting beyond retention can turn an expected cache hit into a new write. The input discount can be large, but a workflow dominated by output or repeated new tool results may save much less overall. Confirm cache-read and cache-write usage fields before projecting savings across thousands of tasks.
Batch, faster processing, and tool fees
Sol’s Batch and Flex rates are 50% below Standard; Fast costs twice Standard and Ultrafast six times Standard. Short-context Sol Ultrafast is $12 input, $0.60 cache read, $15 for a 30-minute cache write or $30 for a 12-hour write, and $60 output per million tokens; the long-context band is higher. Opus Batch input/output is 50% lower and its Fast input/output is $8/$40. Regional-processing premiums, tools and storage are separate. OpenAI rates; Claude rates.
Both providers list web search at $10 per 1,000 searches or calls, in addition to relevant token charges. Ten searches therefore add $0.10 before result-token costs. Storage, hosted execution, and external services can add other charges. A short $0.04 model request with several searches is not a $0.04 completed research job.
Cost per task: transparent examples you can reproduce
For a request with mutually exclusive token categories, calculate:
Token cost = (fresh input × input rate + cache writes × write rate + cache reads × read rate + billable output × output rate) / 1,000,000
Use the correct rate schedule for each request. The examples assume identical billable token counts, standard processing, no extra tools or runtime, and no retries. Ordinary-input rows assume no cache write. Sol’s implicit caching can instead bill an eligible fresh prefix at the write rate; its caching guide explains explicit-only control. Equal text does not necessarily produce equal token counts across providers. Billable output includes reasoning, even when the user sees only a much shorter answer. See OpenAI’s reasoning guide and Claude’s thinking and cost guide.
Sol also supports a separate reasoning.mode: "pro" in the Responses API. OpenAI’s reasoning guide distinguishes this from reasoning.effort: standard is the default mode, and effort controls reasoning within either mode. Pro mode performs more model work, bills the aggregated tokens at the selected model’s standard rates, and can increase token usage, cost and latency. It is an API execution setting, distinct from the ChatGPT Pro subscription. The benchmark snapshots here do not establish a matched Pro-mode comparison or quantify its quality benefit.
| Hypothetical usage | Sol | Opus | Sol saving |
|---|---|---|---|
| 10K fresh input + 2K output | $0.04 | $0.08 | 50% |
| 100K fresh input + 20K output | $0.40 | $0.80 | 50% |
| 100K cache read + 10K fresh input + 10K output; initial write excluded | $0.13 | $0.26 | 50% |
| 20 requests: first writes a 100K prefix; next 19 read it; each has 5K output; no other input | $1.44 | $2.88 | 50% |
| 400K fresh input + 20K output | $1.90 | $2.00 | 5% |
| 900K fresh input + 10K output | $3.75 | $3.80 | 1.3% |
The 20-request example assumes every later request hits the cache, uses Sol’s default 30-minute and Opus’s five-minute cache-write prices, and includes 100K total output tokens. Sol’s bill is $0.25 for the write, $0.19 for nineteen reads, and $1.00 for output. Opus’s is $0.50 + $0.38 + $2.00. An expired cache, extra instructions, or another tool result changes the bill.
This calculation assumes every subsequent request reuses the same cached prefix and begins while that entry remains valid. Response-generation time counts toward the cache lifetime. A missed or expired entry can require another write and increase the total cost.
The two long-context rows explain why a 50% token-price headline can mislead a document-heavy buyer. With large fresh inputs and little output, the models’ inference costs approach each other. With shorter prompts or substantial output, Sol has more room to save money.
Cost per accepted task is the production metric
Cost per accepted task = total cost of all attempts, retries, tools, fallbacks, and infrastructure / tasks meeting the acceptance criteria
Include review and repair separately, or convert that labor into money using an explicit rate. A cheaper model that rarely produces a usable result can cost more than a pricier model that passes consistently.
For an intentionally simplified example, imagine model A costs $0.40 per independent attempt and passes 40% of the time, while model B costs $0.80 and passes 90%. Repeating until success gives expected inference costs of $1.00 and about $0.89, respectively. These are invented inputs to illustrate the arithmetic; they are not Sol or Opus results. Real retries can share the same failure mode, have different costs, or never recover, so use measured task outcomes when budgeting.
At exactly half the attempt cost, the cheaper model needs more than half the expensive model’s success rate to win on that simplified metric. Once tool fees, human repairs, or long-context pricing change the cost ratio, recalculate the break-even point. Avoid dividing a composite intelligence score or partial-credit score into a dollar figure and calling it cost per successful task.
Refusal and fallback charges
A refused Opus request can still cost money. Anthropic’s September 24, 2026 release notes resumed billing for refusals before output in the bio, frontier_llm, and reasoning_extraction categories. Its current billing guide says other pre-output categories, including cyber, are unbilled. A refusal after output begins bills the input and output already generated.
A billable refused attempt and its fallback are charged separately at each model’s rates. Eligible fallback credit reduces the extra prompt-cache cost of switching models. For server-side fallback, account for every attempt in usage.iterations, applying the refusal billing rules above; the top-level usage counts describe only the attempt that produced the returned message. Include billed refusals and fallback usage in cost per accepted task.
What benchmarks add
The table preserves Artificial Analysis’s October 22, 2026 snapshot under Intelligence Index v4.3.2, checked against the pages for GPT-6.1 Sol and Claude Opus 5.5. Sol used Max effort; Opus used Max with default safeguard fallback. The v5.0 update follows the historical table.
| Artificial Analysis metric | Sol, Max | Opus, Max with default fallback |
|---|---|---|
| Intelligence Index v4.3.2 | 52 | 58 |
| Weighted mean cost per index task | $0.72 | $5.98 |
| Total output tokens across index evaluation | 67 million | 260 million |
| Reported output generation speed — checked October 22, 2026 | 54.8 tokens/second | 95.9 tokens/second |
Speed snapshot clarification, October 22, 2026: An earlier capture that day reported 54.2 tokens/second for Sol and 95.1 for Opus. The refreshed figures are 54.8 and 95.9 respectively. Artificial Analysis’s displayed speed figures can change; this difference alone does not establish that either model became faster. Output generation speed measures throughput, not time to first token or total task completion time. These figures do not establish which model finishes your workflow sooner. Kingy has not run a new matched API speed test, and the October 19 test dates remain unchanged.
In that v4.3.2 snapshot, Opus led by six index points and Sol’s reported weighted task cost was about 88% lower. The index is a composite score, not a percentage of real-world tasks completed. The output totals belong to that evaluation run; they do not predict token use on your next coding request.
Artificial Analysis v5.0.1, checked November 4, 2026: Sol Max now reports 55 at $1.27 per weighted index task; Opus Max with default fallback reports 59 at $10.04. Opus’s displayed lead is four points. Medium-effort figures below remain the dated October 28 snapshot. The evaluator says v5.0.1 regrades CritPt v2 with grading improvements from its authors. A changed grade does not establish that a model improved. Keep earlier v5.0 snapshots under their original dates; compare models within one version and effort setting. Try the supplied task with your own acceptance checks before choosing. No new Kingy model test was run. First model’s current evaluator page; second model’s current evaluator page; methodology and version history.
Artificial Analysis v5.0, checked October 28, 2026: Sol Max reports 55 at $1.27 per weighted index task and 64M output tokens; Opus Max with default fallback reports 58 at $10.04 and 220M. Opus’s displayed lead is three index points; Sol’s displayed weighted task cost is about 87.4% lower.
Version boundary: AA v5.0 changes the evaluations and their weights. Compare models within the same version; changes from v4.3.2 do not establish model improvement or regression. Weighted costs also incorporate typical cache-hit measurements. These sources do not isolate the contribution of each change. No new Kingy model test was performed.
Medium-effort comparison, checked October 28, 2026: Under AA v5.0, Sol reports 46 at $0.36 per weighted index task, versus Opus with default fallback at 48 and $2.45. Sol’s displayed cost is about 85.3% lower, with a two-point index gap. A deployment using Medium should start with Medium evidence. The October 22 v4.3.2 snapshot remains historical: Sol 48/$0.21 and Opus 51/$1.34, a three-point gap and about 84% lower displayed Sol cost. Comparing those snapshots does not establish a model improvement or regression.
The v5.0 methodology for the retained snapshot combines nine evaluations, with equal 25% weights for Knowledge Work, Coding, Science and General capability. It is primarily text-based and English-language. Image-capable models also receive images in some tasks, including HLE-Diamond image questions and GDP.pdf page images. Dedicated visual reasoning, speech and multilingual evaluations are reported separately. Cost reporting uses provider-reported token usage where available and incorporates measured typical cache-hit rates. It should not be read as a quote for a particular deployment.
This evidence favors Opus for the broader capability mix and Sol for inference economy. It also gives an actual counterexample to a blanket claim that Sol must generate tokens faster: Opus’s reported output rate is higher in this snapshot. End-to-end task time still depends on reasoning duration, token volume, tool execution, and retries. A faster stream can take longer to finish if the model produces more output.
Vals: October 22, 2026 snapshot and the fallback qualification
On October 22, 2026, the Vals Index displayed Sol at 63.94% ±1.07 and Opus at 70.18% ±1.00. The model pages reported Sol at $3.614 per test and 44m24s, versus Opus at $28.12 and 84m31s. In that snapshot, Opus led by 6.24 percentage points; Sol’s reported cost was about 87.1% lower. These figures describe this evaluator’s task mix, not your production completion rate.
The October 22 Opus page reported 4.28% fallback and 1.01% refusal rates. The index’s explanatory text gave Opus 64.16% when fallback-served tasks count as failures, much closer to Sol’s 63.94% in that snapshot. Use the default result when assessing that fallback-enabled system; use the failure-counted view when that fallback is unavailable or unacceptable. Do not treat either as the isolated model’s guaranteed success rate.
The October 22 index table reported 5.49B input/103.20M output tokens for Sol and 31.96B/499.75M for Opus. Different task trajectories, retries and fallback behavior contribute to those totals. They are not equal-token invoices. That captured page did not prominently establish the older v2.1 label, so we identify this snapshot by its retrieval date instead of silently carrying that version label forward.
Individual components still matter. The October 22 model pages showed Sol/Opus SRE Bench at 50.76%/33.59%, while Code Migration v1.1 was 77.32%/81.01%. Their scores, agents and acceptance rules differ. Vals describes its error bars as standard errors, not 95% confidence intervals; its task latency is also different from output tokens per second.
Launch benchmarks: the advantage changes with effort and task
Selected OpenAI launch-chart results follow. Costs are per attempted task; Opus includes fallbacks. Competitor results come from public reports, so these are not controlled Kingy.ai tests.
| Evaluation / effort | Sol score / cost | Opus score / cost |
|---|---|---|
| GDP.pdf, Medium | 30.0% / $0.34 | 25.6% / $0.80 |
| GDP.pdf, High | 32.0% / $0.35 | 28.8% / $0.83 |
| AutomationBench 1.0.6, Medium | 31.7% / $0.19 | 29.5% / $0.65 |
| AutomationBench 1.0.6, Max | 36.1% / $0.30 | 42.5% / $1.44 |
| Terminal-Bench Science 0.1, Max | 57.0% / $5.47 | 63.3% / $23.21 |
Sol leads the selected PDF rows and Medium automation point; Opus leads Max automation and science. Sol costs less in every listed configuration. Equal effort labels do not imply equal compute budgets.
These are point estimates. The charts do not establish that every score difference is statistically significant. A benchmark’s success rate also need not transfer to your task set.
GDP.pdf methodology clarification: Artificial Analysis documents 100 tasks attempted five times, with complete OCR-extracted text and adapted page images where supported. Its judge is GPT-5.6 Luna Medium. AA identifies Surge’s setup as raw PDF input through the provider and a Gemini 3.5 Flash judge; these scores should be kept separate. AA’s headline score requires every criterion to pass, with missing attempts and terminal input failures scored zero. Its costs cover contestant calls, excluding judging, PDF preparation and OCR. Its estimated task time uses output-token counts and generation speed, so it is not measured end-to-end completion latency. These details clarify how to interpret the independent index; they do not change the vendor results above or establish cost per accepted task in your workflow.
GDP.pdf tests answers grounded in complex professional PDFs. AutomationBench tests multi-step business workflows. Terminal-Bench Science tests scientific workflows through terminal tools, including analysis and simulation. Those are different abilities. A model can be economical at extracting facts from a document and still need more help with an open-ended agent task.
Coding and computer-use scores need extra care
The checked DeepSWE v1.1 leaderboard does not provide a matched Sol 6.1 versus Opus 5.5 pair. Anthropic’s Opus launch table reports 66.4% on Terminal-Bench 4.0 at Xhigh and 54.4% on FrontierCode v1.1 Main at Max, with production safeguards enabled. Neither score can be ranked against a DeepSWE result.
OpenAI reports OSWorld 2.0’s offline set from the August 8 release with partial reward. Anthropic reports OSWorld 2.1 partial-credit results. Different versions and subsets prevent a clean computer-use head-to-head. A partial reward also measures something different from a task whose final state either passes or fails. For workflows such as editing a spreadsheet and sending the resulting file, define which final actions must all succeed before giving credit.
Across benchmarks, keep the evaluator, dataset version, agent harness, tool access, effort, token limit, and fallback policy attached to each number. A coding agent with a strong search tool, useful repository instructions, and a verifier is a system. Its score does not isolate the underlying model’s contribution.
Reliability, safeguards, and fallback behavior
OpenAI’s system-card addendum documents Sol’s safety and alignment evaluations. It treats the model as Critical for cybersecurity capability and High for biological/chemical capability under OpenAI’s framework, and applies Astra’s safeguard stack. These are capability classifications under that provider’s framework, not a comparison showing which model is safer for an ordinary company workflow.
Anthropic’s Opus system card is the corresponding source for its safeguards and evaluations. When a benchmark includes a fallback, the measured system may involve a different model on some tasks. Keep that policy explicit, particularly for security work. A fallback-assisted result answers a different deployment question from a result that counts every safeguard intervention as a failed attempt.
Neither provider’s safety tests establish that an autonomous agent can run without checks in your environment. Evaluate ordinary permission handling, prompt injection through files or webpages, source accuracy, and whether the agent reports failed tools honestly. Judge the completed artifact and the actions taken, not merely the fluency of the final response.
Specifications, access and migration
| Specification | GPT-6.1 Sol | Claude Opus 5.5 |
|---|---|---|
| Direct API model ID | gpt-6.1-sol |
claude-opus-5-5 |
| API context window | 1,050,000 tokens | 1,000,000 tokens |
| Normal maximum output | 128,000 tokens | 128,000 tokens |
| Published knowledge cutoff | April 30, 2026 | June 2026 |
| Native input / output | Text and images / text | Text and images / text |
| Reasoning effort | Low, Medium, High, Xhigh, Max | Low, Medium, High, Xhigh, Max |
| API default effort | Medium | Medium; adaptive thinking always on |
Sources: OpenAI’s Sol model specification, Anthropic’s Opus specification, and Claude effort documentation. Opus additionally supports up to 300,000 output tokens through its Message Batches API with the output-300k-2026-03-24 beta header. That exception does not apply to an ordinary interactive request.
Sol’s extra 50,000 context tokens amount to 5% more advertised capacity. Capacity alone cannot establish how well either model retrieves evidence from a large file, notices conflicting details, or completes a workflow. A long-document evaluation matters more for those questions. Likewise, a later knowledge cutoff gives no guarantee that a particular fact is correct. Current prices, product changes, and events still need retrieval and checking.
These are API specifications. A consumer app can impose different limits or compress earlier conversation history. A tool that generates an image also adds a separate capability to the workflow; text-and-image input does not mean the base model natively generates images, speech, or video. The cited model documentation does not disclose enough architecture, parameter-count, or training-compute information to make a substantiated comparison on those measures.
Availability and subscriptions: compare the product you will use
The current model guide lists Sol 6.1 for Work/Codex on eligible paid plans, with Enterprise/Edu administrator enablement; it is not an ordinary Chat model. Work/Codex Ultrafast supports Sol 6.1 on Pro $500 and eligible Enterprise/Edu plans. Its API Ultrafast access is separate and supports US/EU residency. Opus availability remains product- and platform-specific. Current Work/Codex model guide; speed eligibility; API model page.
Check Sol API service-tier permissions
For Sol API integrations, check organization and project service-tier settings before switching. A request can fail because its selected or automatically resolved tier is disallowed, even when the model supports that tier. Projects cannot enable tiers blocked by the organization. These API permissions are separate from Work/Codex subscription eligibility.
ChatGPT Plus is $20 per month. The current Pro tier documentation lists $100, $200, and $500 monthly plans. Claude Pro is $20 monthly or $200 billed annually; Claude Max is $100 monthly; Ultra is $200 monthly. Anthropic says existing Max 20x subscribers move automatically to Ultra without a price change. Max provides five times Pro’s usage per five-hour window and per week; Ultra provides ten times Pro’s weekly usage, with no five-hour limit for verified accounts. Unverified Ultra accounts retain a temporary limit. Current Ultra terms. App allowances and metered API usage are distinct. There is now an important credit benefit for eligible Claude subscribers: Max includes $100 and Ultra $200 in monthly Claude Platform credits, after linking an eligible Console organization. New subscribers must wait seven days; unused credits expire each cycle. The credits cover eligible Claude Platform usage, not interactive Claude Code or extra Claude-app usage. Pro is not eligible. If you already have unused included credits, compare incremental cash spending as well as metered API cost; the calculator does not subtract your personal credit balance. Do not buy a subscription solely to save a few dollars on this example.
Eligible paid ChatGPT Pro and Business subscribers can activate a separate OpenAI API-credit benefit. The subscription must be at least seven days old; the claimant must own the subscription or Business workspace and the receiving API organization, use the same email for both accounts, and link the organization. Pro’s $100, $200 and $500 tiers grant $100, $200 and $500 respectively; Business grants depend on paid seats. The first grant is prorated, and unused credits expire at the end of the applicable billing cycle. The benefit does not cover Codex authenticated with API keys or increase ChatGPT or signed-in Codex limits. Compare available credits separately from metered API cost and included subscription allowance.
Among Pro plans, Sol Ultrafast requires Pro $500. It consumes included allowance at 8× Standard, then eligible purchased credits at 6×; these are consumption rates, not measured speedups.
Pro 200 correction, checked October 30, 2026: OpenAI canceled the Work/Codex allowance reduction. Higher-allowance subscribers keep it; lower Work/Codex allowances doubled to match. New subscriptions get the same allowance, and existing plans update without waiting for renewal. Pro 200 remains US$200/month without Ultrafast. Check current terms before budgeting.
Work/Codex distinction, checked October 30, 2026: Sol defaults to a 500,000-token context window in Codex and ChatGPT Work. Sol usage drawn from the subscription has no long-context surcharge. These product limits are separate from API specifications and API prices. This does not establish an exemption for purchased-credit usage or mean that context consumes no included allowance.
A subscription’s cost per task can be measured after you know how many acceptable tasks it completed in a billing month. It cannot be inferred reliably by dividing the price by an assumed message allowance. Long coding sessions, short chats, and tool-heavy research do different amounts of work. Count completed jobs and record whether usage limits prevented finishing them.
Migration work also belongs in the cost comparison. Sol’s documentation directs tool-using applications to Responses; Chat Completions is supported without tool calling. Opus’s migration guide documents always-on thinking, errors for forced tool use, model/conversation-bound thinking blocks, and changes to supported computer-use tooling. Test streaming progress, structured output, tool invocation, context handling, and failure recovery before replacing a production model ID.
OpenAI’s September 29 API changelog also confirms Sol’s beta multi-agent support in Responses. The model can coordinate subagents in parallel. Its multi-agent documentation warns that adding subagents can increase token usage. For a delegated workflow, compare total spend and completion time for the entire run; a lower per-token price alone does not establish that parallel delegation saves money or time.
October 21 API change to check before switching
Anthropic’s API version 2026-10-21 migration guide adds a separate integration concern. New major SDK versions select that API version by default. Requests now reject sampling parameters (temperature, top_p, top_k), document blocks directly in assistant messages, and non-empty citation arrays on text blocks in user messages. The SDKs also have language-specific breaking changes. Test and release the SDK upgrade with the relevant code fixes; changing only the model identifier is insufficient.
The October 20 release notes also document organization controls that can disable web fetch or restrict domains. A failed research task can therefore reflect account policy or a tool error. Record those conditions rather than attributing every failure to model capability.
Run your own comparison
Choose representative tasks, including difficult and failure-prone jobs. Fix the acceptance criteria before either model runs. For procurement, specify currency, tax, budget and payment timing, then independently recompute every total.
- Keep the same starting input, available tools and acceptance checks. Start both at Medium when that is the setting you intend to use; equal effort labels do not guarantee equal compute budgets.
- Record the exact model, client, date, effort, processing tier, token limits and fallback policy. Preserve provider updates when aliases change.
- Check calculations, citations, code behavior, required file outputs and output format separately. Reject invented exchange rates, missing suppliers and incorrect budget eligibility. Use blinded human review where judgment is needed.
- Keep every attempt, final artifact and failure. Log fresh input, cache writes, cache reads, output and tool charges. Include the failed attempt and replacement when escalating.
- Measure total elapsed time and human review and repair time. Keep subscription access, reported token usage and actual API charges distinct.
- Compare accepted-task rate, total cost per accepted task and completion-time distribution at your quality bar. Keep the cheaper route only when it meets the same checks. A small procurement exercise cannot establish broader coding, science or document-analysis superiority.
Sources, method and update history
November 1, 2026, source correction: Updated current Max/Ultra plan names, price and usage distinctions and the API-credit boundary. Historical observations, model identities, costs and test dates are unchanged. No new product or model test was run.
October 30, 2026, source clarification: Reconciled subscription advice and distinguished Work/Codex context from API specifications and prices. Historical task records, costs and evaluator snapshots retain their original dates. No model or subscription test was run.
October 28, 2026, evaluator version update: Added the newly observed Artificial Analysis v5.0 results and separated the earlier v4.3.2 figures from current comparisons. Preserved the original Kingy task records, Vals evidence and dated throughput snapshots. No new model test was run.
Cache-timing clarification, October 22, 2026: Clarified when Claude cache lifetime begins and the timing assumption behind the repeated-request calculation. Reviewed the specific Go SDK documentation-example change; no cache-price or minimum-token correction was identified. Broader source review remained due at that update. Original task dates and numeric examples are unchanged.
OpenAI launched Sol 6.1 on September 29; Opus 5.5 launched September 22. This guide covers these exact versions. Current specifications, API rates, cache rules, product access and evaluator pages were reviewed October 22. All prices are USD. We also include actual October 19 answers to fixed synthetic procurement tasks, with the input, output and failures preserved. Those observations used different clients and are not a controlled API cost or latency benchmark.
Editorial method: API specifications and rate schedules were checked against first-party documentation. Vendor charts and the independent Artificial Analysis and Vals snapshots are labeled separately. Calculated examples expose their assumptions and exclude unmeasured quality claims. The October 19 observations used included subscriptions; no new paid inference was run for this update. Those client-level observations do not establish matched API speed, cost or general success rates. Launch-day evaluations can be revised; compare future updates within the same benchmark version and configuration.
For related context, see Kingy.ai’s Sonnet 5.5 versus Opus 5.5 comparison and Astra versus Opus 5.5 comparison. This article specifically covers the new GPT-6.1 Sol, whose prices and results should be kept distinct from GPT-6 Sol.
Earlier Vals observations retained for context
The October 17 review recorded Sol at 61.15% ±1.01, $3.237/test and 43m10s; Opus at 66.97% ±0.89, $32.14/test and 79m00s, with 2.15% fallback and 0.79% refusal. The September 30 capture recorded 91/2,281 fallback-assisted tasks and conflicting failure-counted displays of 59.16% and 65.05%. These are historical source observations. They are not current results or evidence of a measured improvement between identical test runs.
Evidence labels and reading order updated October 22, 2026: Distinguished the eight retained procurement responses from an untested production workflow, separated substantive correctness from raw-JSON compliance, highlighted the long-context pricing caveat and grouped the existing reference sections. Consolidated the comparison checklist. No new model run or source-price review was performed for this edit; original evidence dates are preserved.
October 22, 2026: Completed the current source review, replaced the opening with explicit choose/switch rules, added actual October 19 procurement inputs and outputs with their limitations, refreshed Artificial Analysis throughput and Vals figures, added Anthropic’s October 21 API migration implications, and linked a matching calculator setup. Historical test dates remain unchanged. No new model performance run or traffic uplift is claimed.
October 18, 2026: Moved the model-choice guidance and three calculated workload examples ahead of the specifications, added the workload calculator and a Sonnet comparison link, and rechecked the rates used by the three examples. Benchmark results and measurement dates are unchanged; no new model test was run.
October 17, 2026: Rechecked current API specifications/rates and updated Sol Ultrafast, product availability and the current Vals summaries. Replaced superseded Opus token totals and fallback rates while preserving the dated discrepancy. No new Kingy inference or benchmark result is claimed.
September 29, 2026, 2:44 pm PDT: Clarified the Enterprise and Edu admin enablement requirement and added Sol’s beta Responses multi-agent support with its token-use caveat. Sources: OpenAI launch resources, the September 29 API changelog, and multi-agent guidance.
September 29, 2026, 6:41 pm PDT: Added refusal and fallback billing rules, cache-credit limits, and per-attempt usage accounting to the cost-per-accepted-task section. The refusal policy is dated September 24, 2026; this entry records when it was added here. Sources: Anthropic release notes, refusal and fallback billing, and fallback credit.
September 29, 2026, 10:45 pm PDT: Added Vals’s newly observed Sol 6.1 results: current v2.1 index scores, standard errors, cost per test, completion latency, aggregate token use, Opus fallback accounting and contrasting component results. Distinguished the source’s September 29 index update and September 22 historical Opus note from this publication time. Sources: Vals Index v2.1, Sol model results, Opus model results and methodology.
September 30, 2026, 4:42 pm PDT: Added the newly verified AA GDP.pdf document-input and judge differences from Surge, scoring rules, excluded costs and estimated-timing caveat. The methodology page gives no publication date for this clarification; this timestamp records its addition here. Prices and reported scores are unchanged. Source: Artificial Analysis methodology.
September 30, 2026, 6:45 pm PDT: Updated Opus’s Vals fallback/refusal accounting from 44/12 tasks to 91/18 tasks, preserving the earlier observation. Flagged the disagreement between the model-page failure-counted score (59.16%) and index prose (65.05%). Default scores, reported costs and API rates are unchanged. The index source is dated September 30; this timestamp records our publication. Sources: Vals Index v2.1 and Opus model results.
September 30, 2026, 8:43 pm PDT: Added Sol’s API Pro reasoning-mode distinction and aggregated-token billing caveat. Rates and benchmark results are unchanged; no Pro-mode performance improvement is inferred. The guide supplies no publication date for this detail, so this entry records our addition time. Source: OpenAI reasoning guide.
The Kingy Brief
Get the free AI price sheet.
25 AI plans and models on one page, from official pricing pages, updated every month. Free when you join The Kingy Brief: AI changes, original tests and one practical thing to try, Fridays at 09:00 Vancouver time.
Free · Unsubscribe anytime
Signup help and newsletter schedule
After submitting, look out for the welcome email from The Kingy Brief. If the form asks you to confirm, open the confirmation email too. Check Spam or Promotions if you cannot find it.
Fridays at 09:00 Vancouver time: source-checked AI changes, original tests and one practical thing to try. We skip a week when there is not enough verified material. Free. Unsubscribe anytime.