Introduction
Give GPT 6.2 Sol the code, failing test or draft you are working on, and state how the change will be checked. OpenAI positions this model for routine work that still has to be correct.
| Field | Value |
|---|---|
| Input | Text |
| Output | Text |
| Input context | 1,050,000 tokens |
Key features & highlights
Give each change a review boundary
Use the conversation to name the affected module, the behavior that must change and the interfaces to preserve. Request a proposed patch with a stated acceptance check so the reviewer can assess the change against the original problem.
Adjust the effort behind a reply
Sol exposes low, medium, high, xhigh and max reasoning, with medium selected by default. Pair that choice with a reply cap rather than treating effort as an answer-length instruction. Evaluate the returned work against the same task before changing your application configuration.
Make tool decisions inspectable
Provide up to 128 tool definitions and control whether the model may request several calls during a turn. Set tool selection according to the current workflow, then let your application inspect the requests and execute the permitted steps. Definitions describe available actions; the surrounding application manages their execution.
Ask for a format your workflow can use
The response format object lets you request plain text or a JSON object. Describe the expected contents in the conversation so a release-note draft, extracted record or review summary has a clear destination. Check its substance alongside its structure before the next application step.
Request parameters
| Parameter | Required | Description |
|---|---|---|
messages | Yes | Send Sol the code, error output or draft with the result you expect; user messages may also include images. at least 1 items · at most 256 items |
max_tokens | No | Caps Sol's reasoning plus reply: minimum 16, default 4,096, maximum 128,000. Raise it for long patches. |
reasoning_effort | No | Sol runs low, medium, high, xhigh or max; stay on the medium default for bug fixes and feature work. |
tools | No | List up to 128 functions Sol can ask your application to run, each with a JSON schema for its arguments. at most 128 items |
parallel_tool_calls | No | Keep this on so Sol can batch independent lookups; switch it off when each call depends on the last. Default: |
tool_choice | No | Control Sol's next step with auto, none, required or the name of one function. |
response_format | No | Ask Sol for plain text, a JSON object or output matching your JSON schema, then validate what returns. |
Pricing
Input $2 / Output $10 per 1 million tokens; Prompts over 272K tokens: Input $4 / Output $15
Use cases
A repair scoped to a module
Use messages to provide the relevant implementation, observed error and expected behavior. Ask for a patch and an explanation of its boundary, then check the proposed change in the project before applying it.
Release notes from engineering records
Supply reviewed change notes and ask for a customer-facing draft with unresolved items kept separate. The requested reply format can make the draft easier to pass into an editorial workflow.
An order-support decision step
Define the lookup functions available to an agent and describe the decisions that need human review. Control tool selection and review requested arguments before your application performs an action.
A document turned into structured fields
Send the source passage in the conversation and request a JSON object using the format control. Tell the model how to mark missing information, then validate the returned fields against the source.
A review of accumulated project decisions
Arrange earlier decisions and the current question in chronological messages. Ask for a concise account of agreed constraints and open questions while observing both the message-count and input-token limits.
Prompt guide & pro tips
Define the deliverable
Put the code, document or operational question into messages with the result you need. Name the acceptance check and any project conventions the answer must respect.
Choose effort and reply budget
Begin with medium reasoning and a reply cap suited to the deliverable. Change one setting at a time when comparing whether the response meets your criteria.
Describe format and available tools
Use the format control when another application will consume the answer. If tools are needed, supply their definitions and decide whether their requests can be handled independently.
Inspect the returned work
Review a proposed patch against the supplied code, compare a draft with its source notes and validate any structured data. Record the settings with the accepted result for later comparisons.
Chat for work with a clear finish
Use GPT 6.2 Sol chat to request a code change, a document draft or a decision within an application workflow. Send the supporting material in an ordered conversation and define what a useful answer must contain. A patch needs expected behavior; a release note needs approved changes and an audience; an agent step needs the available actions and the decision it should make.
OpenAI says Sol is intended for everyday coding and agent work. Organize each conversation around the change, document or decision you want to review, then choose the reasoning effort, reply budget and format to match that deliverable.
Choose the controls around the task
The endpoint requires messages. Its remaining public fields adjust the reply budget, reasoning, requested format and use of application tools. Message count and input tokens are separate limits, so a conversation can satisfy one bound while exceeding the other.
| Parameter | Type | Default and limits | Practical role |
|---|---|---|---|
| messages | array, required | 1 to 256 messages | Conversation in chronological order |
max_tokens | integer | 4,096; range 16 to 128,000 | Cap the generated reply |
reasoning_effort | string | medium; low, medium, high, xhigh, max | Choose reasoning effort |
response_format | object | Optional | Request plain text or a JSON object |
| tools | array | Optional; up to 128 definitions | Describe tools the model may request |
tool_choice | string or object | Optional | Control whether and which tool may be selected |
parallel_tool_calls | boolean | true | Permit several tool requests in a turn |
The input ceiling is 922,000 tokens. Keep the relevant instructions, source material and prior decisions within the conversation budget. For a long project discussion, identify the current question and the decisions that still govern it so the model can work from a clear context.
Effort and reply size serve different purposes
Start at medium when establishing a reference configuration. Raise or lower effort while keeping the task and acceptance check unchanged, then inspect the difference in the delivered work. OpenAI says reasoning is included in the output token budget, so a large visible answer also needs room within that budget. A higher effort setting does not itself specify how much text you want.
Tools need an application around them
Declare the actions available to the current task and make their argument descriptions understandable. Use tool selection to restrict the next decision when the workflow requires it. Permit parallel requests when your application can handle the requested operations independently; use sequential decisions when a later operation needs an earlier result. Inspect arguments and results before advancing the workflow.
Write input that a reviewer can check
Give the task a concrete boundary. For a bug repair, include the affected function, the failing case and the expected behavior. State which interfaces must stay stable and ask the answer to explain the proposed patch. Verify it in your project before accepting it.
For release notes, separate approved changes from unresolved issues and tell the model who will read the draft. Ask it to mark missing source information rather than supply unverified details. When extracting records, define the expected fields and how to represent absent values; a JSON request still needs a check against the original passage.
Carry decisions forward clearly
Arrange messages from earlier context to the current request. Preserve decisions that remain relevant and remove unrelated material before assembling the next conversation. OpenAI says stable prompt prefixes with appended instructions help preserve reasoning across turns. Keep your own record of the source material and settings so you can compare accepted work across requests.
Read the displayed price before submitting
Use the price shown on this page when planning a request. Consider how much source material you send, the reply cap you select and whether the task needs another round of revision. A reply cap describes an allowed budget, rather than an estimate of useful text. Keep the requested scope focused: specify the files a patch should affect or the sections a draft should contain before deciding how much output to allow.
Review the deliverable in its working context
For a code change, compare the proposed behavior with the failing case and check that the surrounding interfaces still match your requirements. For a release note, trace each statement back to the approved changes and review the wording for its intended audience. For a tool decision, inspect the requested action and arguments before your application proceeds.
When the answer needs revision, include the relevant result in the conversation and state the specific correction. Keep accepted decisions visible so the next reply can build on them. Describe what is still unresolved and whether you need a revised patch, a shorter draft or corrected fields.
Limits and related choices
Check the 256-message ceiling, 922,000-token input limit and reply cap before building a long session. OpenAI says Sol accepts text and image input and produces text. Pair visual context with a written question that identifies what the answer should explain or change.
GPT 6.2 Astra and GPT 6.1 Sol are related families on this site. OpenAI says Astra targets complex professional work, which makes it a candidate to evaluate when a task needs broader investigation. Keep GPT 6.1 Sol as a comparison when your application already has accepted results from it. Choose between these families using a shared task, the same source material and acceptance criteria suited to your application.
API quick start
curl --fail-with-body -sN https://api.spicyapi.ai/v1/chat/completions \
-H "Authorization: Bearer $SPICY_API_KEY" \
-H "Content-Type: application/json" \
-H "Idempotency-Key: $(uuidgen)" \
-d '{
"model": "openai/gpt-6.2-sol/chat",
"messages": [
{
"role": "user",
"content": "Summarise the following release notes into three bullet points."
}
],
"stream": true
}' \
| jq --unbuffered -Rrj 'select(startswith("data: ")) | .[6:] | select(. != "[DONE]") | fromjson | if .error then "\n[error] \(.error.message)\n" else (.choices[0].delta.content? // empty) end'
See the API reference for authentication, the complete schema, polling, and error handling.



















