GPT-6 Astra: Practical Guide, API Pricing, and Prompts

GPT-6 Astra is OpenAI's model for demanding reasoning, coding, research, and work across documents and applications. Consider it when conflicting evidence or tightly connected requirements make a task hard to finish correctly. Give it the sources, constraints, and checks that define a useful result, then evaluate the completed work rather than the confidence of its explanation. Official model-selection guidance

The official model catalog checked on October 30, 2026 lists GPT-6 Astra, with API ID gpt-6-astra. It does not list an Astra entry named GPT-6.1 Astra; this article uses the documented model name. The exercises below are original proposals, not a hands-on benchmark or a claim of measured productivity gains. OpenAI model catalog

Reader question	Practical answer
When should I try Astra?	Use a task with consequential tradeoffs, conflicting sources, or a complex change you can test.
What should I provide?	Supply the source pack, decision criteria, permitted actions, and acceptance checks.
How should I judge it?	Compare correctness, evidence, human review, and total resource use.

Choose a task where deeper judgment matters

Make a defensible decision

This is a suggested decision process, not a model performance result.

Astra is a useful candidate when the difficulty lies in connecting evidence and carrying a decision through to a verified result. A migration plan might need to reconcile a deadline, data compatibility, rollout order, and an ambiguous requirement. Start by writing those constraints down so you can tell whether the proposed plan resolves them.

OpenAI positions Astra for its most demanding work and Sol for complex projects where cost also matters. Those are starting recommendations, not a universal ranking for your own inputs. Use a known task to find out whether Astra's result needs less correction or handles an important dependency better. Model-selection recommendations

In Codex CLI, select the documented model with:

codex -m gpt-6-astra

In the desktop app or Work, use the available model controls and check the workspace's permitted options. Availability, reasoning settings, and client defaults vary, so confirm the selected model before comparing runs. The subscription's usage allowance is separate from API billing. Models in Work and Codex, Plan access and usage

If you are still assembling the surrounding environment, our practical Codex guide provides context. Once the tools are ready, choose one bounded deliverable for the first run. A source-backed decision memo is easier to assess than an open request to improve an entire business.

Understand the specifications and API tariff

Astra accepts text and images and returns text. Tools can extend a workflow beyond these direct modalities.

API property	Documented value
Model ID	gpt-6-astra
Context window	1,050,000 tokens
Maximum output	128,000 tokens
Knowledge cutoff	April 30, 2026
Reasoning effort	low, medium, high, xhigh, max
Unsupported direct modalities	Audio and video
Features	Streaming, function calling, structured outputs

Standard text-token rates are in US dollars per 1 million tokens:

Token category	Standard API price
Input	$10.00
Cached input	$1.00
Listed cache write	$12.50
Output	$50.00

Above 272,000 input tokens, full-request input/cache rates double and output rates increase by 50%. Batch/Flex cost half Standard, while Fast doubles applicable rates. Astra specifications and rates

The listed cache-write rate covers 30-minute retention; 12-hour retention is $25 per million tokens. Treat these as the write-token rates, rather than adding the full uncached input rate again. Cache-write pricing, Caching behavior

For an illustrative Standard request with 20,000 uncached input tokens and 4,000 billable output tokens, the base calculation is $0.40. This excludes tool charges, cache writes, image inputs, retries, and other adjustments. It is arithmetic from the listed rates, not an observed bill or a forecast for a complete agent task.

The output cap includes reasoning, so a response can be incomplete before visible text appears. Check status and usage before adjusting scope, effort, or budget. Reasoning and output limits

Do not use the API context figure as a promise about every Work or Codex setup. Client limits, available tools, and subscription accounting are product-specific. Check those conditions on the route you intend to use, especially before a large source upload. Work and Codex pricing

Use Astra for a concrete, inspectable result

Work that needs deeper judgment

Each workflow ends with an artifact and an explicit verification step.

Resolve conflicting project evidence

Provide the decision criteria and label each source with its date and authority. Ask Astra to identify contradictions before recommending an option. This creates a visible distinction between a documented fact, an assumption, and an unresolved dependency.

Decide whether the proposed rollout can meet the attached requirements.
Use only the supplied project documents.
First identify conflicting claims, their source IDs, and dates.
Apply explicit supersession rules; do not silently choose a convenient source.

Return a decision memo containing:
1. Requirements and pass/fail/unknown findings.
2. Evidence for each finding.
3. Feasible alternatives and their tradeoffs.
4. Questions whose answers could change the decision.
5. The next check needed before committing.
Do not authorize spending or change the project schedule.

Read the evidence table before the recommendation. A useful answer may conclude that no option is currently supported, then explain which missing fact would make a decision possible. The exercise below gives you a small example with a known result.

Plan and execute a complex refactor

Name the behavior that must remain stable and the checks that would reveal a regression. Ask for an initial dependency map, a staged plan, and one bounded change at a time. This makes a broad engineering goal concrete enough to review.

Separate the import validation layer from database writes in this repository.
Read its project instructions and identify the relevant entry points.
Preserve current public interfaces and supported input behavior.

Map dependencies and propose a sequence of small changes.
Implement the first meaningful step, then run the checks appropriate to it.
Report actual commands, observed results, changed files, and unverified claims.
Stop if a requirement conflicts with the existing behavior and explain the choice.
Do not deploy or modify production data.

Inspect the actual diff and execution output instead of relying on a completion summary. If a test could not run, keep that limitation attached to the result. Our outcome-first prompting guide explains how to define a deliverable and its acceptance criteria.

Build a research synthesis with traceable claims

Ask a decision question rather than requesting an unrestricted overview. Define the comparison criteria, prefer primary sources, and require unresolved points to stay visible. A useful deliverable is a short evidence map plus a recommendation that names the assumptions on which it depends.

Evaluate whether [technology] meets our attached deployment requirements.
Use current official documentation and primary technical papers.
For each important claim, record the source URL, verification date,
relevant condition, and whether it is a vendor claim or independent evidence.

Compare the feasible approaches against the same criteria.
List unsupported assumptions and evidence that would change the recommendation.
Finish with a small validation experiment and its pass/fail criteria.
Do not describe a proposal or simulation as a production result.

For an API workflow, enable a search tool when the task needs fresh information. Web-search results include citation annotations, and OpenAI requires visible, clickable citations when displaying those results to users. Open the cited sources before using a claim in a consequential decision. Web-search integration and citations

When the material includes PDFs or diagrams, preserve page identifiers and ask which visible elements support a claim. PDF input handling can provide extracted text and page images to an appropriate model. Verify values in the original file rather than treating a fluent explanation as proof that a figure was read correctly. PDF input documentation

Try a decision exercise with a known answer

Copy this synthetic source pack into a prompt or separate text files. The precedence rule is explicit: a dated amendment supersedes the earlier schedule for the same option. Require every condition to pass before calling an option fully feasible.

R1 — Requirements
Launch within 4 weeks; staff effort at most 60 hours;
keyboard navigation must be verified before selection.

A1 — Option A, October 1
45 staff hours; delivery in 3 weeks; keyboard navigation verified.

A2 — Option A amendment, October 20
Delivery is now 5 weeks. This replaces A1's delivery schedule.
Other A1 details remain unchanged.

B1 — Option B, October 20
35 staff hours; delivery in 2 weeks; keyboard verification pending.

C1 — Option C, October 20
70 staff hours; delivery in 3 weeks; keyboard navigation verified.

Ask Astra to return a requirements matrix, a decision, and a next-action list. Tell it to cite R1, A1, A2, B1, and C1 directly and to retain unknown values. Compare its response with this answer key before using the same method on unfamiliar documents.

Option	Expected assessment
A	It fails the deadline because A2 supersedes A1's three-week schedule.
B	Its schedule and effort fit, but keyboard support remains unknown.
C	It fails the effort limit because 70 hours exceeds 60 hours.

No option is fully verified as feasible under the stated requirements. A useful next step is to obtain B's keyboard test evidence or negotiate a documented change to another option; it is not to silently relax the requirements. This is the exercise's expected answer, not a result generated by Astra.

The exercise tests source precedence, arithmetic, and treatment of missing evidence. If a model gives a confident winner, look for the exact condition it ignored. That failure tells you more about fit for this workflow than the length of its explanation.

Separate reasoning, speed, and parallel execution

Separate the controls

Changing one control does not automatically establish an improvement in the whole task.

Model choice selects the system doing the work, reasoning effort changes how much reasoning it applies, and speed selects an available processing tier. Keep these settings fixed when you want a fair comparison, then change one variable at a time. Give each run the same evidence and acceptance criteria.

In Work and Codex, Max gives a selected model more reasoning time, while Ultra uses subagents for separable parts of a task. They are distinct from Ultrafast, which is a speed mode. Use the supported controls exposed by your client rather than copying a product label into an API parameter. Max and Ultra guidance

API Ultrafast supports Astra with service_tier: "ultrafast" and has separate rates and rate limits. The guide supports HTTP as well as WebSocket connections, with persistent WebSockets recommended for frequent agent tool exchanges. Work/Codex eligibility is different: its Ultrafast feature is limited to Pro $500 and eligible Enterprise/Edu plans. API Ultrafast, Work and Codex Ultrafast

Start a difficult task with an effort level you can afford to evaluate and a defined output budget. Raise effort if a repeated, important error improves enough to justify the added use. Choose a faster tier when waiting time matters, then measure the complete task again rather than assuming a token-speed change fixes every bottleneck.

Send a bounded request and inspect its status

Install the current OpenAI JavaScript SDK with npm install openai and configure OPENAI_API_KEY locally. This example requests a self-contained test plan through the Responses API. It has been syntax-checked locally and has not been run against the paid API.

import OpenAI from "openai";

const client = new OpenAI();
const result = await client.responses.create({
  model: "gpt-6-astra",
  reasoning: { effort: "medium" },
  input: "Design a test plan for selecting a project option when " +
    "a dated amendment conflicts with an earlier delivery schedule. " +
    "Include missing evidence, boundary values, and expected decisions.",
  max_output_tokens: 32768,
  store: false,
});

console.log(result.status);
console.log(result.output_text);
console.log(result.usage);
if (result.status !== "completed") {
  console.error(result.incomplete_details ?? result.error);
  process.exitCode = 1;
}

Astra tool calling requires the Responses API, and none is not a supported reasoning effort. The GPT-6 guide also documents restrictions on sampling parameters when reasoning is enabled. Start with the documented request shape, then add tools and persistence deliberately. GPT-6 API configuration

API pro mode is separate from a Pro subscription. Its configuration can be reasoning: { mode: "pro", effort: "medium" }; effort is independent, and extra model work contributes to usage. Evaluate this configuration separately. Reasoning modes

Async tool calling lets supported function/custom tools remain pending while other work continues, but your application still executes jobs and returns results with their original call IDs. Mid-turn steering works through Responses WebSockets; accepting an update does not undo actions already started. Both features require explicit application handling rather than a prompt promising unrestricted autonomy. Async tools, Mid-turn steering

A model's ability to call a tool does not create the application that executes it. For computer use, the integration must run actions, return screenshots, and verify the resulting state. A narrow test environment and a clear completion condition make that loop easier to inspect. Computer-use integration

API data is not used for model training by default unless you opt in, but that does not mean all content has zero retention. OpenAI describes abuse-monitoring logs and feature-specific application state; store: false is not a blanket removal of every retention mechanism. Review the actual project's controls and the policies of connected services before submitting confidential material. API data controls

Evaluate the completed task

Measure a completed task

This scorecard is a proposed method and contains no invented benchmark scores.

Select 10 representative tasks, including an ambiguous case and one where the correct result is “not enough evidence.” Write the acceptance criteria before running either model. Keep the source pack, instructions, settings, and tool permissions with the results so that you can repeat the comparison.

Measure	Evidence to retain
Correctness	Check facts, calculations, preserved behavior, and requirements.
Evidence quality	Verify citations, source precedence, and unresolved claims.
Human review	Time corrections, review, and repeated attempts.
Total use	Record token usage, tools, elapsed time, and applicable charges.

Compare Astra with your existing process or another available model on the same work. A higher token rate might still be worth testing when a task needs repeated corrections, but the evidence must come from completed work. This article does not establish a universal winner or a measured cost saving.

If the work is mostly visual review, our GPT-6.1 Terra guide offers another candidate workflow. For a different model family and a concrete data exercise, see the Gemini 4 Argon practical guide. Use the same acceptance checks when comparing those approaches.

Common questions

Is GPT-6.1 Astra the name I should use?

The checked official catalog lists GPT-6 Astra and gpt-6-astra. Use that identifier for the model documented here, and recheck the catalog if a newer Astra release is announced. Official catalog

Should I always choose the highest reasoning effort?

Test the effort levels on a task you understand. A higher setting is useful when it corrects an important failure or improves a needed deliverable enough to justify its use. Record review time as well as the output quality before deciding.

Does an image-generation tool mean Astra directly outputs images?

Astra returns text; an application may provide an image-generation tool separately. Check both configurations when planning an artifact. Astra model page

Can I assume a long answer completed the job?

Check the requested artifact and the evidence that verifies it. A convincing explanation can still miss a deadline constraint, ignore a source amendment, or describe a test that never ran. Completion should refer to the actual result you defined.

What should I do when Astra is more expensive than expected?

Inspect the request's usage, reasoning budget, tool activity, and retries. Narrow an oversized task and compare a lower effort or another model on the same acceptance criteria. Preserve the failed or incomplete run in the evaluation so it remains part of the cost of finishing the task.

Choose one hard task and assemble its evidence before starting Astra. Ask for a deliverable whose reasoning and result can be inspected, then verify it against the sources. Expand the workflow when that evidence supports the next step.

For a separate guide centered on iterative delivery and cost control, read the GPT-6.1 Sol practical guide. Use its exercises alongside the same acceptance criteria when deciding which workflow fits your work.

Choose another model guide or browse the AI Models collection.