Introduction
Send GPT 6.2 Astra the brief, source files and acceptance criteria in one conversation. OpenAI built this model for complex deliverables, so state what a finished result must contain before it starts.
| Field | Value |
|---|---|
| Input | Text |
| Output | Text |
| Input context | 1,050,000 tokens |
Key features & highlights
Keep the question beside its evidence
Bring requirements, excerpts and prior decisions into one conversation, with up to 922,000 input tokens across as many as 256 messages. Label documents and their sections so the reply can point a reviewer back to the source. Finish the request with the decision you need and the criteria it must satisfy.
Evaluate effort against the assignment
Choose low, medium, high, xhigh or max reasoning effort; medium is the default. Start with a representative assignment and keep its source material and acceptance criteria stable while adjusting the setting. Review the treatment of assumptions, conflicting requirements and unresolved questions to decide which setting suits your work.
Make room for the deliverable
The reply allowance defaults to 4,096 tokens and can be set between 16 and 128,000. Choose it alongside the requested format: a concise decision note and a detailed technical report need different amounts of space. State the sections you expect, then inspect the returned work for omissions before passing it along.
Describe the actions your tools support
Supply up to 128 tool definitions and use the tool-choice control to shape which calls may be requested. Parallel requests are enabled by default; turn them off when your workflow depends on ordered results. Describe each function clearly, review its requested arguments, and return the result for the next decision.
Request parameters
| Parameter | Required | Description |
|---|---|---|
messages | Yes | Give Astra the brief, source material and acceptance criteria; user messages may also carry images. at least 1 items · at most 256 items |
max_tokens | No | Output budget for Astra's reasoning and visible reply: minimum 16, default 4,096, maximum 128,000. |
reasoning_effort | No | Pick low, medium, high, xhigh or max for Astra; medium is the default, and harder deliverables justify stepping up. |
tools | No | Declare the functions Astra may request, up to 128; your application validates the arguments and runs each call. at most 128 items |
parallel_tool_calls | No | Turn this off when Astra's function calls must run one at a time; it is on by default. Default: |
tool_choice | No | Let Astra decide with auto, block calls with none, force one with required, or name a specific function. |
response_format | No | Request plain text, a JSON object or a JSON schema from Astra, and validate the result before using it. |
Pricing
Input $8 / Output $40 per 1 million tokens; Prompts over 272K tokens: Input $16 / Output $60
Use cases
Requirements review for engineering teams
Provide a specification, a change request and the decisions already made through messages. Ask for contradictions, missing requirements and a proposed review checklist, with each observation tied to a source section. Include relevant code excerpts when the decision depends on an implementation detail.
Research notes with traceable evidence
Bring experiment notes and measurements as text, then request separate sections for observations, interpretations and follow-up questions. Choose reasoning effort for the analysis task and ask the reply to preserve units, identify assumptions and connect each conclusion to the relevant measurement.
Structured operations handoffs
Use response_format to request an object describing a work item, its supporting evidence and unresolved questions. Define the fields in the conversation and explain how to represent unavailable values. Parse the reply and validate its contents before handing the work item to another application.
Inventory checks with application tools
Define the inventory lookup functions your application can provide in tools, and use tool_choice to control access. When a follow-up depends on a lookup, disable parallel requests and return the relevant result before asking for a recommendation. Review function arguments as part of your application workflow.
Prompt guide & pro tips
Describe the decision and deliverable
Put the question, audience and acceptance criteria in messages alongside the relevant source material. Ask for missing evidence to be named rather than filled with guesses.
Organize the conversation
Order messages from oldest to newest and identify the source of each document or excerpt. Keep within 256 messages and 922,000 input tokens, selecting material that contributes to the task.
Choose effort and reply budget
Begin with medium reasoning effort and the 4,096-token default reply budget, then adjust for the work you need. Set an output allowance between 16 and 128,000 tokens and describe the sections the finished answer should contain.
Define the handoff and review it
Request the desired response format and define any tools your application will handle. Check the answer against the supplied evidence and acceptance criteria before using it in another workflow.
Turn extensive context into a focused answer
GPT 6.2 Astra takes an ordered conversation and produces a text reply. Bring the requirements, source material and decisions that matter to your assignment, then describe the deliverable you want. A technical review might call for findings tied to document sections; an operations handoff might need an object that another application can read.
The endpoint accepts up to 922,000 input tokens across 1 to 256 messages. Organize that space around the question: give documents recognizable names, retain relevant units and dates, and separate source excerpts from instructions. End with the decision to resolve and the criteria for a useful answer.
Build the request
Provide messages in chronological order, starting with the oldest entry. The remaining parameters let you choose the reply budget, reasoning effort, output format and available tools.
| Parameter | Type | Purpose and range | Default |
|---|---|---|---|
| messages | array | Required conversation history; 1 to 256 entries | Required |
max_tokens | integer | Reply budget from 16 to 128,000 tokens | 4,096 |
reasoning_effort | string | low, medium, high, xhigh or max | medium |
response_format | object | Requested reply format, such as text or JSON | Optional |
| tools | array | Function definitions; up to 128 entries | Optional |
tool_choice | string or object | Controls whether and which tool may be called | Optional |
parallel_tool_calls | boolean | Allows multiple tool requests in a turn | true |
Check the message count and input-token total separately before submitting a large conversation. A few lengthy messages can reach the token ceiling, while a conversation with many short exchanges can reach the message ceiling.
Match effort to the assignment
Begin with medium reasoning effort and use a representative task to choose among the five settings. Keep the instructions, source excerpts and acceptance criteria stable when comparing replies. Look for resolved contradictions, well-supported conclusions and questions that need a decision from you.
Choose max_tokens around the intended deliverable. A short recommendation needs a different allowance from a detailed requirements review. Ask for named sections and a clear stopping point so the reply stays focused on the requested work. If the answer is incomplete, check the reply budget and narrow the scope of the next request.
Make the response usable
For a JSON handoff, use response_format and explain the expected fields in messages. Specify what each value means, how to represent missing information and which source supports it. Have your application parse the reply and validate the values before storing or forwarding them.
For prose, define the audience and the action the answer should support. Ask for an opening recommendation, evidence grouped by issue and a separate list of unresolved questions. Review quotations, calculations and references against the documents you provided.
Write instructions that guide the work
Name the deliverable before adding detail. For example: "Review these requirements and the proposed change. Link each conflict to a source section, identify assumptions, and finish with acceptance criteria for the project owner." Place the requirements and change request in the conversation with distinct labels.
For research notes, preserve the measurement names, units and relevant conditions. Ask the reply to distinguish observations from interpretations and to show which source supports each conclusion. For an engineering review, identify the applicable revision and describe the decision the team needs to make.
Break a broad assignment into reviewable parts when it contains several independent decisions. After reviewing a reply, append corrections and follow-up questions to the conversation. Identify any earlier assumption that has changed so the next answer can use the updated context.
Connect application tools
Describe the functions available through tools, including what each function does and what its arguments mean. Use tool_choice to control tool selection. Your application handles requested actions and returns their results to the conversation for subsequent reasoning.
Parallel tool requests are enabled by default. Set parallel_tool_calls to false when a later lookup depends on an earlier result, such as checking a selected inventory item after finding its identifier. Check requested arguments against the user's task before executing a function, then review the final answer against the returned data.
Plan pricing and choose a family
Use the current price displayed on this page to plan your requests. Consider the source material you will send and the reply budget you choose, and review actual usage as you refine a recurring workflow. Keep the same assignment and evaluation criteria when deciding how much context and output space the task needs.
Consider GPT 6.2 Sol for routine work: OpenAI describes Sol as suited to everyday tasks and Astra as suited to demanding assignments. Compare replies against your team's acceptance criteria and the displayed prices. If you already use GPT 6 Astra, review representative requests from that integration before adopting this family.
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-astra/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.



















