OpenAI’s current GPT-6 lineup makes an architectural point that matters more than any single benchmark: an agent no longer needs one model to do every part of a job. GPT-6 Astra, GPT-6.1 Sol, and GPT-6 Luna expose broadly similar agent-facing capabilities, but at radically different prices. That combination makes model routing a first-class systems decision rather than a late-stage cost optimization.
The three models share a 1.05-million-token context window, accept text and image input, produce up to 128,000 output tokens, and support function calling, structured outputs, prompt caching, file search, and web search. Through the Responses API, each can also use a substantial tool set that includes code execution, hosted shell, computer use, MCP, tool search, and patch application. Yet their standard token prices span two orders of magnitude: Astra costs $10 per million input tokens and $50 per million output tokens; Sol costs $2 and $10; Luna costs $0.10 and $0.50.
That is not simply a good-better-best product shelf. For agent builders, it is a signal to separate orchestration from execution. The practical default should be to assign the cheapest model that can reliably complete each step, preserve escalation paths for difficult work, and measure the entire trajectory rather than the apparent quality of one response.
One tool surface, three operating envelopes
OpenAI positions GPT-6 Astra as its most capable model for demanding reasoning, coding, computer use, research, and document creation. GPT-6.1 Sol is presented as delivering near-Astra performance at lower cost for complex coding, computer use, and professional work. GPT-6 Luna is aimed at focused, high-volume tasks. Those labels are useful, but the operational differences become clearer when mapped to agent roles.
- Astra is the escalation tier. It is the sensible candidate for ambiguous planning, deep debugging, consequential review, or a recovery attempt after cheaper models fail.
- Sol is the general-purpose work tier. At one-fifth of Astra’s standard token price, it can carry complex tool-using steps where Luna’s reliability is insufficient but Astra’s premium is hard to justify.
- Luna is the volume tier. Its economics suit classification, extraction, narrow transformations, routine tool dispatch, validation against explicit rules, and other constrained work that dominates many agent traces.
The shared interface is crucial. All three support the Responses API and the same listed hosted tools, so a router does not need a completely different application contract for every tier. A workflow can retain its tool schemas, state representation, and output contract while changing the model selected for a step. This lowers the engineering cost of routing, although it does not eliminate the need to test behavioral differences.
There are still important caveats. Sol requires the Responses API for tool calling; its Chat Completions support does not include tool calling. Luna supports function calling in Chat Completions only when reasoning effort is set to none. Teams building agents around older Chat Completions integrations therefore will not get a clean, capability-equivalent swap. The product direction is clear: the Responses API is the common control plane for tool-using GPT-6 agents.
The price gap changes the routing math
Model routing is sometimes treated as an advanced optimization to attempt after an agent works. The GPT-6 price ladder makes that sequence expensive. On standard rates, Astra is 100 times Luna’s input and output price, while Sol is 20 times Luna’s price and one-fifth of Astra’s. A long-running agent can make dozens of model calls, repeatedly include instructions and state, produce hidden reasoning tokens, and invoke paid tools. Small per-call assumptions compound quickly.
Consider a simplified trajectory that consumes 500,000 uncached input tokens and 100,000 output tokens across planning, retrieval, tool use, and synthesis. At listed standard token rates, running every step on Astra would cost about $10. Running the same token volumes entirely on Sol would cost about $2; Luna would cost about $0.10. Real workloads will differ, and a cheaper model may use more tokens or require retries, but the scale of the spread remains large enough to shape architecture.
A better target is not “use Luna everywhere.” It is minimize the cost of a successful trajectory. A cheap attempt that produces a wrong tool argument, loops, or corrupts state can be more expensive than a reliable Sol call. An Astra call may be economical if it resolves an ambiguity that would otherwise trigger many retries. Routing therefore needs outcome-aware evaluation, not a price table pasted into a configuration file.
Route by step, not by conversation
The simplest router chooses one model when a user request begins and keeps it for the entire run. That is easy to implement, but it ignores how varied agent work is. A single request might involve intent classification, plan generation, document retrieval, data normalization, code modification, test diagnosis, and final review. The capability required at each point is different.
A stronger design assigns models at step boundaries. Luna can parse a well-structured request, select among a small set of tools, extract fields from retrieved documents, or check an output against deterministic criteria. Sol can own multi-step execution and coding where tool use must adapt to intermediate results. Astra can enter for the initial plan when the task is unusually ambiguous, for difficult failure recovery, or for a final review when the impact justifies the premium.
Routing signals should be observable and conservative. Useful signals include the number and sensitivity of available tools, whether a step writes external state, the size and heterogeneity of the context, prior failed attempts, uncertainty reported by validators, and the cost of an incorrect result. Avoid asking a model to grade its own confidence as the sole signal. Self-reported confidence is not a reliable control mechanism; combine it with deterministic checks and task-specific evaluators.
A practical escalation policy
Teams can begin with a small policy rather than a learned router:
- Send narrow, reversible, schema-constrained steps to Luna.
- Use Sol for open-ended execution, coding, and computer-use steps with moderate consequences.
- Use Astra for high-ambiguity planning, high-impact actions, and recovery after validated failures.
- Escalate only when an external check fails, a tool returns an unexpected state, or a defined risk threshold is crossed.
- Cap retries by model and by step so an agent cannot silently spend its way through a failure.
Long context is not free state
The shared 1.05-million-token context window may tempt teams to send the same enormous transcript to every step. That would undermine much of the economic benefit of routing. Each model allows up to 922,000 input tokens, but prompts above 272,000 input tokens carry higher rates for the full request: twice the input and cache rates and 1.5 times the output rate. Large context also increases latency and can make relevant evidence harder to isolate.
Agent state should therefore be deliberately layered. Keep compact instructions and current task state in the hot prompt. Store durable artifacts, logs, and documents outside the conversation. Retrieve only the evidence needed for the next decision, and pass references rather than repeatedly copying entire outputs. Use structured summaries, but retain links to original evidence so an escalated model can inspect source material instead of trusting a lossy summary.
Prompt caching can help when stable prefixes recur. Astra lists cached input at $1 per million tokens, Sol at $0.10, and Luna at $0.01. Cache writes cost more than uncached input—1.25 times the relevant input rate—so reuse matters. A routing strategy should measure cache hit rates and avoid constantly mutating the beginning of a prompt. The most economical context is still context the system does not need to send.
Measure trajectories, not isolated answers
Traditional model comparisons often score one answer to one prompt. Agents create a harder evaluation problem because success depends on a sequence of decisions and interactions with changing external state. A router can improve an individual classification score while making the overall system worse if it increases tool calls, latency, retries, or unsafe actions.
A production evaluation set should replay representative trajectories in a controlled environment. Record task completion, human correction rate, invalid tool calls, policy violations, wall-clock latency, input and output tokens, cache behavior, tool fees, and total cost. For state-changing tools, evaluate whether the agent selected the correct target and whether it respected confirmation or approval boundaries. Score recovery behavior separately: a system that detects and repairs a failure is materially different from one that proceeds with corrupted state.
Compare routing policies against clear baselines, such as all-Sol and all-Astra, rather than judging a mixed system in isolation. The important number is not the percentage of calls sent to Luna. It is the share of tasks completed to the required quality and safety threshold per dollar and per minute. In some domains, the winning policy may route most steps to Sol. In others, Luna may handle the majority of calls while Astra appears only rarely.
Reasoning effort adds a second control
Model choice is only one axis. Astra supports reasoning effort from low through max; Sol supports low through max, with medium as the default; Luna adds a none option. This gives routers a second lever: increase reasoning effort before—or instead of—jumping to a more expensive model.
That choice must also be evaluated empirically. More reasoning can improve hard tasks, but it may add latency and output-side cost. A useful policy might keep Luna at none or low for deterministic transformations, use Sol at medium for most execution, and reserve high or above for diagnosed complexity. If a step remains unsuccessful after one controlled increase, escalating the model may be more effective than repeatedly increasing effort.
Processing tiers add another control. The model pages list Batch and Flex at half standard rates and Fast at twice standard rates; Sol also offers Ultrafast at six times standard rates. Routing can therefore account for urgency as well as intelligence. The decision is becoming a tuple: model, reasoning effort, processing tier, context budget, and retry policy.
What teams should change now
The immediate task is to make model selection explicit. Inventory agent steps, classify their risk and complexity, and attach measurable success criteria. Move tool-using workflows to the Responses API where necessary so the three models can share a consistent interface. Establish Luna, Sol, and Astra lanes, but start with conservative routing and widen cheaper lanes only after evaluations show that outcomes hold.
Next, add cost and trace visibility at the step level. A monthly API bill cannot reveal which planner, validator, or retry loop consumed the budget. Capture the selected model, reasoning effort, token counts, cache reads and writes, processing tier, tool calls, validator results, and escalation reason for every step. That telemetry is also the dataset needed to improve a hand-written router later.
Finally, separate permission from intelligence. A stronger model should not automatically receive broader tool access, and an escalation should not bypass approval gates. Keep least-privilege tool policies and external validators independent of the model tier. Routing can decide who attempts a task; policy must still decide what actions are allowed.
The agent stack is becoming heterogeneous
The GPT-6 lineup’s most consequential feature is not merely Astra’s ceiling or Luna’s price. It is the ability to use a common agent tool surface across sharply different operating envelopes. That makes heterogeneous execution practical: cheap models for routine steps, balanced models for the core workflow, and premium reasoning for the moments that determine success.
Teams that continue to bind an entire agent to one flagship model will leave significant cost and throughput gains unused. Teams that route solely by price will create brittle workflows and hidden retry costs. The durable advantage will come from treating routing as part of agent correctness—measured at the trajectory level, constrained by policy, and continuously tested as models and prices change.
