GPT-5.6 Sol

Why this oneWhat it is actually for

Reach for gpt-5.6-sol when a wrong answer costs more than the tokens do: a security review, a migration plan, a long agent run across a large codebase. It is the tier the bare gpt-5.6 alias routes to, and it is where OpenAI puts its heaviest controls — reasoning.mode set to pro, max reasoning effort, Programmatic Tool Calling, and the multi-agent beta. The request body is identical to Terra's and Luna's, so the only reason to be on Sol is a measured quality gap on your own tasks. If Terra matches Sol on your evals, run Terra: half Sol's rate on input, cached input and cache writes, and three fifths of it on output. Sol earns its price only where more model work per request changes the outcome.

What it isArchitecture, lineage, training

GPT-5.6 is a closed-weight reasoning family that OpenAI made generally available on 9 July 2026 in three tiers — gpt-5.6-sol, gpt-5.6-terra and gpt-5.6-luna. Sol is the flagship, and the bare alias gpt-5.6 routes to it. OpenAI's model page classifies it as a "Frontier model for complex professional work" with the highest reasoning setting in the family.

OpenAI discloses no architecture. There is no parameter count, no statement of dense versus mixture-of-experts, no expert or layer counts, and no description of the training data beyond a knowledge cutoff of 16 February 2026. Nothing in the model page, the "Using GPT-5.6" guide or the migration guide says whether Terra and Luna are distilled from Sol or trained separately. The honest reading is that these are three separately priced products with identical documented interfaces, because that is all the vendor states.

What OpenAI does document is behaviour. Sol emits reasoning tokens that are billed as output tokens and are never returned verbatim, and it reasons adaptively — fewer tokens on simple prompts, more on hard ones. GPT-5.6 adds persisted reasoning, so reasoning items from earlier turns can be rendered back into the next context; the family defaults to all_turns. It adds a pro execution mode that performs more model work before returning a single final answer, billed at the same token rates. OpenAI's stated headline improvements over GPT-5.5 are token efficiency at frontier quality, better inference of user intent, and better frontend design judgment.

One behaviour that belongs to the model rather than the platform: OpenAI runs real-time cyber and biology misuse classifiers over generations. They can pause a stream mid-generation for several seconds or refuse, and OpenAI says they sometimes intervene on legitimate dual-use work such as vulnerability research and patch development.

At a glanceSee it

How a Sol request is shaped and priced, from cache lookup through hidden reasoning to final output.

CapacityContext, output and what fits

The parametersEvery knob, and what moving it does

Three knobs carry almost all the weight. reasoning.effort is the real cost and quality dial — the difference between low and max is far larger than anything sampling would give you. text.verbosity is the output-token dial, independent of effort: you can think hard and answer briefly. reasoning.mode set to pro is the escape hatch for the few requests where reliability beats latency. Tune those three against your own evals before touching anything else, and log cached_tokens and cache_write_tokens while you do it.

SamplingShaping the output distribution

Sol is a reasoning model, and OpenAI's documentation for it has essentially stopped discussing sampling. temperature and top_p are still listed as body parameters of POST /v1/responses — 0 to 2 and 0 to 1 respectively, with the standing advice to alter one but not both — yet neither the GPT-5.6 model page, the "Using GPT-5.6" guide, the migration guide nor the reasoning guide mentions them once. Whether Sol honours, ignores or rejects them could not be confirmed from a primary source as of 2026-07-25. What OpenAI does say is that the model reasons adaptively across effort levels, spending fewer tokens on simple tasks. The sensible starting point is therefore to send neither: reasoning.effort at medium, text.verbosity at low or medium, and nothing else. If you need shape or determinism, note there is no seed on this endpoint — pin the output with a strict JSON Schema instead of chasing it with sampling settings.

ReasoningThinking, effort and budgets

Yes, and it is the model's main axis. reasoning.effort takes none, low, medium, high, xhigh and max, defaulting to medium; max is new in this family and OpenAI tells existing xhigh users to benchmark both. The budget is controllable only through that ladder plus max_output_tokens, which counts reasoning and visible tokens together — there is no explicit token budget for thinking. Reasoning tokens are billed as output tokens and are not visible via the API; you see the count under output_tokens_details.reasoning_tokens, and you can request a summary with reasoning.summary. Independently, reasoning.mode set to pro makes the model do more work before answering, at standard token rates. Across turns, GPT-5.6 defaults reasoning.context to all_turns; with store: false or zero data retention you must replay the encrypted reasoning items the API returns.

ToolsFunction calling and server tools

Function calling is fully supported, with parallel calls on by default and parallel_tool_calls: false guaranteeing zero or one call per turn. Structured output comes from text.format with a strict JSON Schema, which requires additionalProperties: false and every property listed in required; optional fields are expressed as a nullable type union. Beyond JSON-schema functions there are custom tools that take freeform text with optional Lark or Regex grammars. OpenAI's hosted tools — web search, file search, code interpreter, hosted shell, apply patch, image generation, computer use, skills and remote MCP — are all listed as supported, along with tool_search for deferring bulky tool definitions and Programmatic Tool Calling for bounded, tool-heavy stages. The failure modes people actually hit: a safety refusal arrives as a refusal item that ignores your schema; omitting strict lets Responses silently fall back to best-effort, flagged as strict: false; dropping reasoning items between a tool call and its output degrades the next turn; and none of the hosted tools exist on Amazon Bedrock.

CostPrice, caching, batching, what drives the bill

List price from OpenAI's pricing page, per million tokens. These are promotional rates: OpenAI says Sol's "promotional pricing is available at least through November 21, 2026" and does not say what it becomes afterwards, so that is a date to re-read the pricing page on, not a forecast. GPT-5.6 bills in two context bands — OpenAI's model page states that prompts with more than 272,000 input tokens are priced at 2x input and 1.5x output for the full request:

What actually drives the bill: reasoning tokens are billed as output, so effort is a price setting, not a quality setting. The context band is the other step change — crossing 272,000 input tokens reprices the whole request at 2x input and 1.5x output, so one oversized turn is not a marginal cost, it is a repricing event; on a 1,050,000-token window that is a lever you can pull by accident. Cache reads are 90% off, but GPT-5.6 introduced a charge for cache writes at 1.25 times the uncached input rate — a change from earlier families, and a reason to log cache_write_tokens next to cached_tokens rather than assuming caching is free. Batch is a flat 50% off with a 24-hour completion window; service_tier: flex bills at batch rates in exchange for slower and occasionally unavailable service; fast mode, renamed from priority on 2026-07-30, is 2x standard on every cell and is now published for the long-context band as well as the short one. Pro mode carries no premium rate — the reasoning guide says pro-mode work "bills those tokens at the selected model's standard token rates" — it simply produces more of them. For counting, OpenAI does not state anything either way about publishing a tokenizer for this family, so treat that as unknown; what it does document is the input-token endpoint, POST /v1/responses/input_tokens, which it recommends over a local tiktoken estimate because local tokenizers cannot account for images, files, tools and schemas.

Where it runsSurfaces and availability

StrengthsWhat it is good at

• 1,050,000-token context with a 128,000-token output ceiling on the same model ID, per OpenAI's model page — long-document and long-agent work without a separate long-context variant.
• One model ID spans the whole effort range from none to max plus pro mode, so quality and latency are request-level decisions rather than deployment-level ones.
• Explicit prompt caching: up to four breakpoints written per request, matching across the latest 80 breakpoints, and a 30-minute minimum TTL — meaningful control for agent loops with a stable prefix.
• The broadest hosted-tool surface OpenAI offers — web search, file search, code interpreter, hosted shell, apply patch, computer use, skills and remote MCP — plus Programmatic Tool Calling and the multi-agent beta.
• Available on both Amazon Bedrock and Microsoft Foundry, so procurement can sit in AWS or Azure without changing the request shape.

LimitsWhere it falls down

• Nothing about the architecture is disclosed — no parameter count, no dense or MoE statement, no training description. You cannot reason about its behaviour from first principles, only measure it.
• Fine-tuning is not supported on this model, so the only adaptation levers are prompting, tools and retrieval.
• Cache writes now cost 1.25 times the uncached input rate. A workload with high prefix churn and few reads can end up paying more than it did with implicit-only caching on an older family.
• Real-time cyber and biology classifiers can pause a stream mid-generation or refuse, and OpenAI acknowledges they sometimes intervene on legitimate dual-use security work.
• On Amazon Bedrock the usable context drops to 272,000 tokens and every hosted tool, pro mode and Programmatic Tool Calling disappear — so "same model" does not mean same capability.

Against its neighboursHow it compares

The comparison that matters first is inside the family. Sol and gpt-5.6-terra take the same request body, the same 1,050,000-token window, the same 128,000-token output ceiling and the same effort ladder; Terra is half Sol's price on input, cached input and cache writes and three fifths of it on output, so there is no longer one clean ratio between the tiers. OpenAI's own classification is the only stated difference — Sol is rated "Highest" reasoning, Terra "Higher", Luna "High" — with no published benchmark separating them on the vendor's model pages. So the migration guide's advice is the right procedure: hold effort constant, swap the model ID, and let your evals decide. Against Anthropic's Claude Opus 5 or Google's Gemini 3.1 Pro the honest answer is that this page carries no verified numbers for those models; compare on their own pages and on your task, not on a leaderboard.

Getting startedThe smallest call that works

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-sol",
    "input": "Review this migration plan for failure modes that cause data loss.",
    "reasoning": { "effort": "medium" },
    "text": { "verbosity": "low" }
  }'

Change reasoning.effort first — try one level down before one level up, since OpenAI claims GPT-5.6 holds quality with fewer tokens. Then set max_output_tokens with room for hidden reasoning, and add prompt_cache_key once your prefix is stable. Only reach for reasoning.mode of pro when an eval shows standard mode failing.

SourcesWhere every claim above came from

• GPT-5.6 Sol Model | OpenAI API
• Models | OpenAI API
• Pricing | OpenAI API
• Create a model response | OpenAI API Reference
• Using GPT-5.6 | OpenAI API
• Reasoning models | OpenAI API
• API deployment checklist | OpenAI API
• Prompt caching | OpenAI API
• Function calling | OpenAI API
• Structured model outputs | OpenAI API
• Batch API | OpenAI API
• Flex processing | OpenAI API
• Priority processing | OpenAI API
• OpenAI models in Amazon Bedrock | OpenAI API
• Upgrading to GPT-5.6 Sol | OpenAI API
• Foundry Models sold by Azure | Microsoft Learn
• Could not confirm: OpenAI's launch posts at openai.com/index/gpt-5-6/ and the openai.com/api/pricing page both returned HTTP 403 and were not read — every price here comes from developers.openai.com/api/docs/pricing instead. No architecture detail is published anywhere, so parameter count, dense-versus-MoE and any relationship between Sol, Terra and Luna are unknown. Whether temperature and top_p take effect on this model is not stated. The two vendors disagree on training recency: OpenAI says a 16 February 2026 knowledge cutoff, Microsoft Foundry's table says training data to June 2026. The site row this page was built from listed fine-tuning as available "via API" and context as "~1M"; OpenAI's model page says fine-tuning is not supported and the window is 1,050,000, and the vendor page wins.

RelatedGo deeper