GPT-6 Sol High vs XHigh: When Is Extra Reasoning Worth It?

Use high as a practical starting point for complex coding, then keep xhigh only where your own evaluation shows a worthwhile improvement. Extra reasoning is a setting to evaluate, not a guarantee that a patch is correct. This guide is for developers choosing between two settings of gpt-6-sol, not two different models.

Official documentation checked on September 25, 2026 supports both settings. We have not run a head-to-head benchmark. The examples below are calculations and an evaluation procedure, not measured Sol results. All dollar figures refer to the direct OpenAI API, not Ofox or a ChatGPT subscription.

What changes when you select xhigh?

The Sol model page lists none, low, medium, high, xhigh and max; the default is medium. Choosing high is therefore already an explicit change from the default. The reasoning guide recommends evaluating extra effort against its latency and cost, especially for long agent workflows.

Those task suggestions are starting hypotheses. If a prompt lacks the failing test, neither setting can reliably replace missing requirements. First supply the relevant files, expected behavior and a way to reproduce the issue. A higher setting that repeatedly investigates irrelevant files can still be poor value.

Configure a fair comparison

For a reasoning agent that calls tools, use the Responses API. Sol supports function calling in Chat Completions only at none, so changing reasoning_effort to high there is not an equivalent agent configuration. See the tool-calling migration guide before interpreting an adapter error as a model failure.

A minimal request body for the high arm is:

{"model":"gpt-6-sol","reasoning":{"effort":"high"},"input":"Review the supplied patch against the stated acceptance tests."}

The xhigh arm changes only the effort value. This is a request-shape illustration, not an executed API call or a complete repository agent. In a real test, also hold the repository commit, tool definitions, permissions, prompt, maximum retries and output budget fixed. Also fix reasoning.mode: standard and pro are separate execution modes, independent of effort. The example leaves it at the default standard; changing both mode and effort would confound the comparison. Save exact requests after removing secrets, along with request IDs and provider usage records.

Start each arm from the same clean checkout. Do not let the second arm read the first patch or a test answer that the first arm never saw. Alternate the order across several representative tasks. Include unsuccessful tasks and timeouts; silently rerunning only the losing arm would bias the comparison.

Why the same rate card can produce different bills

At Standard processing and no more than 272K input tokens, Sol costs $2 per million ordinary input tokens and $10 per million output tokens. The API rate card does not attach a separate high/xhigh price to those tokens. Extra reasoning can nevertheless consume more billed output, and longer tool loops can add input on later calls.

Consider a hypothetical, uncached request with 50,000 input tokens. If one run bills 5,000 output tokens, its token cost is $0.10 + $0.05 = $0.15. If another bills 15,000 output tokens, it costs $0.10 + $0.15 = $0.25. These are chosen volumes, not a claim that high or xhigh will use either amount.

Cache reads, cache writes, tools and processing modes require separate accounting. Above 272K input tokens, the full request uses twice the input/cache rates and 1.5 times the output rate. Do not mix that threshold change with an effort change. The Sol pricing walkthrough explains those categories.

Decide using accepted work, not answer length

Define acceptance before reading the answers: the original failure is fixed, required tests pass, no unrelated behavior changes, and a reviewer can explain why the patch works. Log reviewer minutes separately. A verbose explanation may increase review effort without improving the code.

For each setting, sum all evaluation costs, including failed attempts, then divide by accepted tasks. If no task passes, the ratio is undefined. Compare both acceptance counts and total cost; one cheap failed run is not a useful delivery. Also measure elapsed time until an accepted patch, rather than only time to the first token.

Keep high for tasks where the outcomes are equivalent and its actual total cost or latency is lower. Use xhigh selectively when a repeatable acceptance improvement is worth the additional resources. If both fail, improve the task definition or retrieval before escalating again. For model-level alternatives, see Sol, Luna and Astra selection.

Save the prompt, commit, test commands and failures with the decision. That makes the choice revisitable when your repository or provider changes, without turning one memorable success into a universal recommendation.