OpenAI's GPT-6 Guide Puts Cost Control, Not Capability, at the Center

OpenAI published a practical guide on October 2 for building with its GPT-6 family, and the most striking thing about it is the tone. It is not a capabilities pitch. It is a document about routing work to the cheapest model that can finish it, keeping context small, and deciding in advance when an agent is allowed to act without asking.

The guide names three models — GPT-6 Astra, GPT-6.1 Sol and GPT-6 Luna — and gives list prices for each. It also describes a set of controls for tasks that OpenAI says can now span hours or days, which is the part engineering teams will find hardest to operationalize.

A 100x price spread across three tiers

OpenAI positions Astra as its most intelligent model, priced at $10.00 input, $50.00 output and $1.00 cached input. GPT-6.1 Sol is described as offering near-Astra intelligence for a fifth of the price, at $2.00 input, $10.00 output and $0.10 cached input. GPT-6 Luna, aimed at high-volume everyday work, comes in at $0.10 input, $0.50 output and $0.01 cached input. The guide does not state the billing unit for these figures.

Taken at face value, that is a hundredfold gap between the top and bottom of the family on both input and output, and the cached-input rates widen it further. OpenAI says cached input tokens cost up to 95% less than uncached ones, depending on the model.

The recommended split is conventional: Astra for the hardest reasoning, Sol for complex coding, research and computer use, Luna for focused repeated tasks with a clear goal — the examples given are extracting invoice fields, classifying requests and producing structured summaries. What OpenAI does not provide in this guide is any benchmark data to support the claim that Sol lands near Astra in intelligence, or any guidance on where the quality gap actually shows up. "Near-Astra" is a marketing phrase, not a measurement, and teams will have to establish the boundary themselves on their own tasks.

Three dials, not one

The guide frames model selection as one of three independent levers. The second is reasoning effort, exposed in the API with levels of Low, Medium, High and an Extra high / Max setting that OpenAI suggests testing only where supported and keeping only if the improvement justifies the added time and cost. That is unusually candid guidance from a vendor billing by the token: more reasoning is not reliably better.

Notably, OpenAI says reasoning effort can be changed mid-conversation in the API without breaking the cache. That matters more than it sounds. Cache invalidation is the usual tax on dynamic configuration, and being able to escalate effort partway through a session without paying full freight on the prefix is a real operational win for anyone building adaptive routing.

The third lever is speed. Fast mode in the API delivers faster and more consistent response times at a higher per-token cost than standard processing, aimed at chat apps and coding tools. Ultrafast, available in both Codex and the API for Astra, speeds up token generation independently of reasoning effort. Neither latency figures nor the size of the premium are disclosed.

For cost management, OpenAI points to prompt caching — with the familiar advice to put stable instructions and reference material before changing task details and keep tool definitions consistent — and to compaction, which reduces context size while preserving enough state to continue a long conversation. The guide tells developers to include cache writes and any long-context rates when estimating total workflow cost, an acknowledgment that headline per-token prices understate the real bill.

The prompting advice has inverted

One section amounts to a quiet retraction of several years of prompt engineering orthodoxy. The guide quotes Eric Provencher, who works on developer experience at OpenAI, saying that models have improved enough at handling nuance and ambiguity that overly specific guidance can now hurt results where it used to help.

The practical recommendations follow from that. Skills should have short descriptions that are explicit about when to run, with supporting detail loaded only as needed, and rigid recipes replaced by guidance. AGENTS.md files should explain when particular documents and tests are relevant and explicitly authorize safe routine workflows — the example given is running local tests with disposable data and no production access. Blanket "always ask" rules should give way to stated decision boundaries separating what the model may do independently from what needs approval.

The guide is also prescriptive about persistence: define "done" as implementing the change, running it, inspecting the result and fixing failures, and name the decisions that require human review.

This is a real migration cost. Teams that invested in detailed, defensive prompt scaffolding for earlier models are being told that scaffolding may now be a liability, and the only way to find out is to re-run evaluations.

Controls for agents that run for hours

The long-running task features are where the guide breaks the most new ground. In the API, mid-turn steering lets a developer send a correction through the Responses WebSocket API while the model is working; OpenAI says updates are queued and do not cancel running tools or undo completed actions. Asynchronous tool calling lets the model proceed with independent work while the application runs something slow, such as a test suite, with the result returned when ready — though the guide warns to wait for that result before starting dependent work.

Sol supports multi-agent workflows in the Responses API, assigning independent subtasks such as investigating different parts of a codebase to subagents and merging their findings. OpenAI labels multi-agent as beta.

In Codex, Astra can ask for clarification mid-task, and OpenAI advises telling Codex which work may continue and when it should pause if you plan to be away. Computer use is available across all three models, letting them read screens, click and fill forms in websites and desktop apps that lack APIs; OpenAI points to Playwright for browsers and PyAutoGUI for desktop, and advises using a direct API or connected tool whenever one exists.

The unresolved question is what happens when a multi-hour agent run goes wrong. Queued steering and no-undo semantics mean a bad instruction issued at hour two does not roll back hour one. The guide's answer is upfront boundary setting and monitoring, which puts the burden squarely on the developer.

Customer evidence is thin

OpenAI cites four teams building on Astra. Harvey combines court information, case law, firm documents and lawyer preferences for drafting, with cofounder Gabe Pereyra quoted on giving the model more context for better structured outputs. Cognition uses Astra inside Devin to test software and return evidence, including a simulator recording and a report separating passed checks from untested areas in an iPhone-game example. Hex turns sales-channel questions into written findings and interactive dashboards, and asks the model to sanity-check whether the numbers hold up. Invideo plans timeline edits and custom effects, and reports roughly three times the success rate on color-grading and correction tasks, plus about 50 effects created by a few editors in one day.

The Invideo figure is the only quantified result in the set, and no baseline is given for the comparison. The rest are descriptive.

What to watch

• Whether independent evaluations confirm that GPT-6.1 Sol delivers near-Astra quality at a fifth of the price, and on which task categories the gap becomes material.
• The billing unit and long-context surcharges behind the published rates, which the guide references but does not quantify.
• How quickly multi-agent delegation moves out of beta, and whether subagent orchestration is billed at the parent model's rate.
• Real-world failure modes in multi-hour runs, given that steering is queued and completed actions are not reversed.
• Whether teams actually see regressions from legacy over-specified prompts, which would turn OpenAI's prompting advice into a forced migration rather than an optimization.