TabbitBlog

GPT-6.2 Sol review: When to switch from GPT-6.1 Sol

GPT-6.2 Sol can cut task costs at the same token rates. See what it missed in testing and when to use it in Codex, Work, or the API.

In this article
  1. Key takeaways
  2. Where to use GPT-6.2 Sol
  3. What the task runs show
  4. A fixed-source check in Codex
  5. What happened when Plotly asked the model to find the evidence
  6. How to read the benchmark results
  7. Three places to start with Sol
  8. Routine edits that have a reliable acceptance test
  9. Repeated analysis where the inputs are known
  10. Writing that can be checked against a source packet
  11. Where GPT-6.2 Sol can cost you time
  12. Finding the exception is part of the job
  13. A plausible code answer can skip a necessary fact
  14. An attractive prototype can hide behavior defects
  15. Collect the same sources in Tabbit
  16. Verdict by workload

GPT-6.2 Sol is worth trying first for everyday Codex changes, writing from known sources, and API workflows with clear checks. Keep GPT-6.1 Sol in the comparison if the job is to find a clue you haven't seen yet. Hacker News user ariwilson's coding comparison illustrates why a switch needs a workload check: newer Sol solved two more runs on their set and took longer at the median. Original coding comparison

ariwilson compares GPT-6.2 Sol and GPT-6.1 Sol on coding tasks
The test used 30 tasks with two runs per task and each CLI’s default reasoning effort.

On November 17, 2026, GPT-6.2 Sol ran Plotly's 43-question analytics exam for $1.22, compared with $2.61 for GPT-6.1 Sol. The new model got 40 right. Its predecessor got all 43. All three misses involved finding a hidden pattern. That's the trade-off to measure on your own work. Lower spend on the common case matters, and a missed exception can send a human back through the whole task. Plotly's test report

For work that starts in multiple tabs, you can collect the sources and run GPT-6.2 Sol in Tabbit Browser. The example below keeps the source packet fixed for each model.

Key takeaways

  • Try Sol at medium for jobs with a clear finish line. Give it the tests, the exact fields, or the sources you will use to check its work.

  • In Plotly's run, the newer Sol used fewer tool calls and took a median of 10.5 seconds per question. The older model took 17.6 seconds and found all five hidden patterns. The new one found two.

  • OpenAI kept the Standard API price at $2 per million input tokens and $10 per million output tokens. Cached input costs $0.10 per million. Measure token use and retries before estimating savings.

  • Test repository discovery separately from routine edits. Artificial Analysis saw a three-point Coding Agent Index decline at max in its Codex setup, driven by repository Q&A.

  • Astra is worth a separate trial if a failed run is expensive to review or if the job crosses several services. Use the same acceptance criteria for both models.

Where to use GPT-6.2 Sol

OpenAI released GPT-6.2 Sol on November 17 alongside GPT-6.2 Astra. The API ID is gpt-6.2-sol. It takes text and image input and returns text, with a 1,050,000-token context window, up to 922,000 input tokens and up to 128,000 output tokens. The API rejects none for reasoning effort. The Sol model guide and configuration examples collect model-specific options. OpenAI API specification

Entry pointWhere to startWhat to check
ChatGPT WorkSelect Sol in Work on an eligible planEnterprise and Edu admins must enable access. OpenAI's launch instructions direct users to Work.
Codex app or CLIUse the model picker or /modelWork and Codex draw on shared usage. Ultrafast has separate plan and workspace eligibility.
OpenAI APISet model to gpt-6.2-solStandard rates are $2 input, $0.10 cached input and $10 output per million tokens. Check service tier, cache writes and tool charges.
Tabbit BrowserSelect GPT-6.2 Sol for work based on your tabs and filesKeep source excerpts and links with the answer.

Reasoning effort and speed are separate controls. Raising effort can give a task more reasoning, while Ultrafast is a service option with eligibility rules. If you are comparing runs, record both settings. An apparent model improvement may come from changing how the requests ran. OpenAI lists Plus, Pro, Business, Enterprise and Edu access to Work, with workspace conditions. ChatGPT Work and Codex launch notes

What the task runs show

A fixed-source check in Codex

The editorial team ran gpt-6.2-sol once at medium in Codex CLI. The input was a short, fixed packet with a price card, Plotly results and a note on Work and Codex settings. The model was asked for three sourced bullets. The checks were whether it calculated a request correctly, identified an unreported latency metric, and distinguished High reasoning effort from Ultrafast.

The cost example used 40,000 input tokens, including 10,000 cached, plus 4,000 billable output tokens. With cache writes and tools excluded, the correct amount was $0.060 + $0.001 + $0.040 = $0.101. Sol returned that total with the three line items, reported that the earlier model found three more hidden patterns, and said the source gave no p95 latency. It also kept reasoning effort and eligibility for Ultrafast separate. All three answers pointed to their packet labels.

The run measured how well one response followed a short source packet. The figures were provided in the prompt. In a real repository or data warehouse the harder part is often finding the evidence in the first place. This sample has one run and no timed head-to-head or API invoice. Readers who want to test the harder cases can start with the Sol evaluation sources.

What happened when Plotly asked the model to find the evidence

Plotly ran each version once in its Studio Embedded harness. The newer Sol got all 38 questions outside the hidden-pattern category right. Overall it made 158 tool calls, down from 258 for 6.1 Sol, and wrote about 45,000 output tokens, down from about 70,000. On the five hidden-pattern questions it ran about nine database queries per question, compared with about 16 for the earlier model. Plotly's methods and run data

That result makes the price difference easier to interpret. The Standard token rates stayed the same, so the cheaper run came from its usage profile in Plotly's setup. Plotly says repeat runs of other models in the suite varied by as much as three questions. The three misses in this particular run show where to test. A general claim that 6.2 loses exactly three questions would need repeated runs.

How to read the benchmark results

TestGPT-6.2 SolComparisonWhat to take from it
Plotly analytics exam40/43 at $1.22GPT-6.1 Sol 43/43 at $2.61One full run per model. Inspect the questions where savings coincided with misses.
Plotly hidden patterns2/5GPT-6.1 Sol 5/5A small subset within the same exam. Use it to design an exception test.
Cognition FrontierCode 2.0, quoted by OpenAIWithin 0.5 score points of AstraAbout one-fifth of Astra's costBoth at max in the reported run. Tasks are graded against repository-specific criteria.
Artificial Analysis Coding Agent IndexDown 3 pointsGPT-6.1 Sol at maxBoth at max in the Codex harness. Repository Q&A is a major part of the difference.

Those rows measure different things. FrontierCode uses weighted criteria and assigns zero if a solution fails a blocking check. Artificial Analysis reported a 14-point decline on SWE-Atlas-QnA-AA and attributed part of that to omitted facts. A repository question can fail on one missing call site even when an isolated edit passes its tests. Cognition methodology · OpenAI launch benchmarks · Artificial Analysis release results

Three places to start with Sol

Routine edits that have a reliable acceptance test

Give it a bug with a failing test, a small diff to review, or a clear change to an existing feature. In review, require each finding to include the file, the triggering condition and the user-visible effect. A green test and a focused diff are more useful to a migration decision than the length of the final summary. For changes that depend on a real page, use the same browser state and checks in both runs. The Codex browser guide covers that setup.

Hacker News user rednb reports that Sol did more work on UI drafts before calling them finished. The report gives a UI hypothesis to test with your own acceptance checks. Original comment

rednb reports that GPT-6.2 Sol iterates more on interface drafts
The HN user did not publish the project or settings.

Repeated analysis where the inputs are known

A regular report with named columns, a clear date filter and a known output format is a good test of the efficiency Plotly observed. Add a simple checker for row counts, dates, units and the source of each important number. Keep the time spent fixing mistakes in the totals. The cost-per-success guide explains how to account for failed attempts.

Writing that can be checked against a source packet

Start with short release notes, project updates or summaries of a known set of sources. Ask the model to preserve names, numbers and links exactly and to mark anything it couldn't find. The short Codex trial shows what an acceptance rubric can look like. For pages that change, save the source text and capture date before asking for a second model's answer. See the guide to research with verifiable sources.

Where GPT-6.2 Sol can cost you time

Finding the exception is part of the job

A report that misses a high-value outlier can cost more to fix than the model saved. Include known exceptions in a trial, such as a setting defined in two files or a value that changes unit midway through a source. Then compare which exceptions each model surfaces and how much supporting evidence it gives. Keep 6.1 Sol in that test if its current results are reliable. The older GPT-6 Sol review explains why release labels matter when comparing benchmark claims.

A plausible code answer can skip a necessary fact

Include questions whose answers cite multiple files or call sites. For example, ask which clients use a shared helper and which caller changes its default. One missing client changes the answer. Max effort still lost ground in the Artificial Analysis repository Q&A test. An increase in reasoning effort is worth keeping when your own checks show it recovers a meaningful failure. If the job is a cross-service investigation, trial Astra against the same evidence.

An attractive prototype can hide behavior defects

A screenshot can show a good-looking first draft and leave you guessing about animation, input and audio. Test the behavior itself. Open it at the intended viewport, exercise each control and check the output against the original request. This applies to code tasks regardless of which model made the page.

In a generated game prototype, thefourthchime reported specific layout and audio misses. Original comment

thefourthchime describes layout and sound defects in a GPT-6.2 Sol prototype
The author scored one generated prototype. The settings were not disclosed.

In a separate drawing test, prmoustache reported that a higher effort still left both legs on the same side of the bike. Original comment

prmoustache compares a GPT-6.2 Sol drawing at different reasoning efforts
The HN user reported incorrect leg placement at High. Exact prompts and runs are unknown.

Collect the same sources in Tabbit

In a read-only Tabbit Browser session, the editorial team opened three public pages: OpenAI's API model page, Plotly's benchmark report, and the ChatGPT Work release notes. The browser check verified the three Standard rates, the two Sol full-run costs and scores, the 10.5-second median, and the separate rules for Ultrafast. The pages supply the values used in the fixed packet for the Codex run. API rate card · Plotly report · Work release notes

Plotly’s 40 of 43 answers and $1.22 cost as viewed in Tabbit
Tabbit displayed the source figures for the comparison.

Use Tabbit's agent integration to collect the pages, then save the source values and URLs using the multi-model research workflow. Keep the packet and question order fixed for each run. A preset packet makes the writing or reasoning comparison easier to interpret. If browsing and discovery are part of your task, test them in a separate round with the same starting pages and tool permissions. The browser check used TabbitDance and the model ran in Codex. You can also run GPT-6.2 Sol directly in Tabbit using the same packet.

Verdict by workload

Your workloadStart withWhat should change your mind
Small code changes, PR review or a report with fixed inputsGPT-6.2 Sol at mediumMore manual fixes or repeated misses under the existing checks.
Finding patterns, evidence or callers that aren't named in the requestCompare GPT-6.1 Sol and GPT-6.2 Sol on the same held-out casesChoose the one that recovers the important exceptions at an acceptable review cost.
Cross-service debugging with expensive retriesTrial GPT-6.2 Astra beside SolGive the extra budget to the model that delivers more accepted work on the difficult cases.
High-volume integrationPilot GPT-6.2 Sol on representative trafficMeasure end-to-end time, billed usage, retries and cost per accepted result before migrating.

Start with your usual routine task, one case with a known exception and a representative difficult job. Use the current model as the baseline. Move the routine workload to 6.2 Sol when the pilot keeps the same acceptance standard and cuts cost or review time. If your evidence sits across several tabs, use Tabbit to keep those inputs fixed. For an older flagship baseline, see the GPT-6 Astra review.

Tabbit Browser

FAQ

Is GPT-6.2 Sol better than GPT-6.1 Sol?

Try GPT-6.2 Sol first on routine work with clear checks. Its full run on Plotly's analytics exam cost less than half as much, and GPT-6.1 Sol found all five hidden patterns where GPT-6.2 Sol found two. Use both models on your hardest existing jobs before replacing the older version.

Is GPT-6.2 Sol good for coding in Codex?

It is a reasonable starting point for scoped changes, PR review and tasks with reliable tests. Compare it with your current model on repository questions that require tracing behavior across files. Artificial Analysis reported a lower repository Q&A score at max effort than GPT-6.1 Sol in its Codex setup.

How much does GPT-6.2 Sol cost?

OpenAI's Standard API charges per million tokens: $2 for uncached input, $0.10 for cached input and $10 for output. Cache writes and separately billed tools can add costs. ChatGPT Work and Codex share subscription usage, which is separate from those API prices.

Can I use GPT-6.2 Sol in regular ChatGPT?

OpenAI launched GPT-6.2 Sol in ChatGPT Work, Codex and the API on November 17, 2026. Within ChatGPT, the launch documentation directs eligible users to Work. Enterprise and Edu admins need to enable model access.

Should I pick GPT-6.2 Sol or GPT-6.2 Astra?

Start with Sol for work you can check quickly. Trial Astra for cross-service debugging or tasks where manual review and retries are expensive. Compare accepted results and total cost using the same inputs and criteria.

What reasoning effort should I use for GPT-6.2 Sol?

Start at medium for bounded tasks and try high for misses you can reproduce. Save max for a measured improvement on a specific workload. Ultrafast is a separate speed setting with its own eligibility.

Take the next step

Let Tabbit work alongside you.

Research across tabs, automate repetitive browser work, and keep every piece of context within reach.