OpenAI Publishes Guide to Choosing and Running GPT-6 Models

Matching the model to the workload

The guide frames model choice and reasoning level as an intelligence and price tradeoff. According to OpenAI, GPT-6 Astra is meant for the hardest reasoning work where maximum intelligence is needed. GPT-6.1 Sol is recommended for complex coding, research and computer use. GPT-6 Luna targets focused tasks at scale, such as extracting invoice fields, classifying requests or producing structured summaries.

In the API, developers can also set the reasoning effort. OpenAI suggests the following:

• Low for routine tasks such as extracting facts or making small edits.
• Medium for work requiring judgment, such as planning a feature or comparing options.
• High for difficult debugging, deeper analysis or careful review.
• Extra high or Max, where supported, only if High falls short and the improvement justifies the added time and cost.

In Codex, OpenAI advises starting with the default reasoning level for the model, then lowering it for simpler tasks or raising it for deeper analysis.

For speed, the API offers Fast mode, which gives faster and more consistent response times at a higher per-token cost than Standard processing. Ultrafast, available in Codex and the API for GPT-6 Astra, speeds up token generation independently of reasoning effort.

Writing better prompts and skills

The guide recommends starting with a clear assignment: the result you want, who it is for, the relevant context and constraints, and what counts as done. It then points to four areas, drawn from a separate piece titled Rethinking skills and prompts for GPT-6 Astra.

• Create better skills: keep descriptions short and explicit about when each skill should run, and replace rigid recipes with more flexible guidance.
• Update AGENTS.md: explain when particular documents and tests matter, and explicitly authorize safe routine workflows, such as running local tests with disposable data and no production access.
• Set decision boundaries: state which actions can proceed independently and which need approval, instead of blanket "always ask" rules.
• Be prescriptive about persistence: define what "done" includes, such as implementing the change, running it, inspecting the result and fixing failures.

OpenAI also encourages users to define the output they want, including which decisions the model may make, when it should ask for input, and what a useful response looks like. A short handoff covering what changed, what was checked and what still needs attention is one example.

Keeping long-running work on track

OpenAI says the GPT-6 family can take on tasks that span hours or days. In the API, mid-turn steering lets developers send a correction through the Responses WebSocket API while the model works. Updates are queued and do not cancel running tools or undo completed actions. Asynchronous tool calling lets the model continue independent work while an app runs a slower task such as tests.

GPT-6.1 Sol supports multi-agent workflows in the Responses API, assigning independent work to subagents and combining their findings. Multi-agent is currently in beta.

In Codex, GPT-6 Astra can ask for clarification while it works, and users can steer an active task with new information. The guide advises telling Codex which tasks can continue and when it should pause if the user will be away.

Computer use is available for GPT-6 Astra, GPT-6.1 Sol and GPT-6 Luna. It lets the models interact with websites and desktop apps, including those without an API. OpenAI recommends using an API or connected tool when it can do the job directly, and computer use when the model must read a screen, click buttons or fill in a form.

Preparing for production

On cost, OpenAI says cached input tokens cost up to 95% less than uncached input tokens, depending on the model. It advises putting stable instructions and reference material before changing task details and keeping tool definitions consistent. Cost estimates for a full workflow should include cache writes and any long-context rates. For longer conversations, compaction reduces context size while preserving the state needed to continue.

Before deploying, the guide recommends running representative tasks and measuring task success, latency and cost per successful task, as well as deciding how to monitor behavior and reviewing data controls. For developers, the practical message is to pick the cheapest model and reasoning level that reliably completes the task, and to test that choice before scaling it.