groundy
Agents & Frameworks

GPT-6.2 Sol vs Astra for Agent Work: When the Ultrafast Tier Pays

Route GPT-6.2 Astra to complex code and computer use, Sol to routine tasks. Vendor data supports distinct roles, but independent measurements are needed to justify Ultrafast.

Published 4 references
A skeptical green resin dinosaur points down two paths, one toward a patched ceramic building and the other toward an open pavilion. A separate yellow fin lies in the foreground.
On this page10 sections

Start with GPT-6.2 Astra for changes to existing codebases, document-template work, and computer-use subtasks; route everyday coding, routine writing, and brief-to-web-app generation to GPT-6.2 Sol. The gateway model IDs are openai/gpt-6.2-astra and openai/gpt-6.2-sol. That establishes availability through Vercel AI Gateway, not support in every agent framework or OpenAI provider implementation, so your dispatcher still needs a compatibility check.

Keep fast mode and Ultrafast as separate, per-subtask decisions. The practical case for Ultrafast is strongest where output tokens dominate the cost and lower latency shortens a sequential workflow. It is much weaker for sparse planner calls or input-heavy retrieval. These are routing defaults based on Vercel’s vendor positioning and pricing statement, not independent measurements of GPT-6.2 quality or speed.

What the changelog establishes, and what it does not

Vercel’s November 17 changelog announces both OpenAI models together and gives them distinct jobs:

  • GPT-6.2 Astra: “for complex, multi-step projects, with improvements to implementing and testing changes in existing codebases, following document templates, and computer use.”
  • GPT-6.2 Sol: “for everyday coding, writing, and agent workflows, including building interactive web applications from a written brief.”
  • Both models: fast mode and OpenAI’s Ultrafast service tier, described as “lower latency at higher per-token rates.”

The same changelog supplies the model IDs, Ultrafast request settings, and a setup command for coding agents. It also claims that GPT-6.2 Astra’s Ultrafast output-token price is 60% lower than GPT-6 Astra’s.

That is enough to design a dispatch policy. It is not enough to declare a performance winner. The announcement provides no latency measurements, throughput measurements, task-success comparison, or token-usage breakdown for the new models. The independent studies available here evaluate the previous GPT-6 generation, not GPT-6.2.

This distinction matters because the two parts of the decision have different evidence standards. Model selection can begin with the vendor’s stated workload fit, then be corrected by your own task results. Spending more for a latency tier should require measurements from your loop.

Route by subtask, not by agent

An agent rarely has one uniform workload. A coding run might retrieve a large amount of repository context, plan a change, generate a patch, run tests, and then write a concise summary. Choosing Astra or Sol once for the entire run hides those differences. Routing at the subtask boundary lets you reserve Astra for the work it is positioned to handle without sending every routine writing step to the same model.

The following table is a starting policy, not a benchmark result:

SubtaskModel starting pointFast mode or Ultrafast starting pointBasis and limitation
Implement and test changes in an existing codebaseAstraOff initially; test it only if generation latency sits on the critical pathAstra’s stated focus is implementing and testing existing-codebase changes. No independent GPT-6.2 comparison is available.
Follow a detailed document templateAstraOff initially; consider a trial for long, output-heavy documentsThis follows the vendor’s explicit template positioning. It does not establish better template compliance.
Computer-use actionsAstraOff initially; measure completion time and retries before changing tierAstra is positioned for computer use. Prior-generation robotics evidence does not establish GPT-6.2 desktop performance.
Generate an interactive web application from a written briefSolBest candidate for a measured Ultrafast trial when output dominatesBrief-to-app generation is Sol’s stated use case and can involve substantial generated output. Actual token share must be measured.
Everyday coding and routine writingSolOff initially; enable selectively for latency-sensitive generationSol is the vendor’s default for these workloads, not a measured quality winner.
Sparse planning over retrieved context or stored historyChoose by task complexityDo not enable solely because of the output-price claimPrior-generation planner telemetry shows a loop with few calls and substantial episode wall time, not an output-token-heavy workload.

The model and tier columns should remain independent. Astra can handle a complex task without Ultrafast, and Sol can handle a routine task that justifies Ultrafast because it generates a large user-facing artifact. Complexity determines the model candidate; token mix and latency determine whether the faster service is worth buying.

When does the Ultrafast tier pay?

Start with the request-cost arithmetic:

cost = input_tokens × input_rate + output_tokens × output_rate

A discount on the output rate affects only the second term. If token counts and other charges remain unchanged, the claimed 60% reduction would leave the applicable output portion at 40% of its previous rate. It would not reduce total request cost by 60%.

The comparison’s scope is equally important. Vercel states:

GPT-6.2 Astra’s Ultrafast output-token price is 60% lower than GPT-6 Astra’s.

That compares two generations of Astra on Ultrafast output tokens. It does not establish any of the following:

  • A 60% reduction in input-token cost.
  • A 60% reduction in the total cost of an agent episode.
  • A 60% advantage for GPT-6.2 Sol.
  • A lower price for GPT-6.2 Astra Ultrafast than for GPT-6.2 Astra without the faster service.

The last point is easy to miss. The changelog describes fast mode and Ultrafast as higher-rate options. A lower rate than the previous generation’s Ultrafast output price can coexist with a higher rate than the new model’s default processing path.

Ultrafast therefore pays when two conditions hold together. First, output must account for enough of the workload that output pricing changes the economics. Second, the latency improvement must save time that matters: a user waiting for an interactive change, or a sequence in which the next action cannot start until the current response finishes. A hypothetical batch of overnight writing jobs could be output-heavy without benefiting much from lower latency. Conversely, a short interactive response could be latency-sensitive without generating enough output for the price claim to matter.

The announcement supplies no latency magnitude, so neither benefit can be assumed. Measure cost per completed task and end-to-end wall time, not just the quoted token rate.

Prior-generation evidence reveals the loop shape

The most useful quantitative evidence here comes from a RoboMME study using GPT-6 Astra, not GPT-6.2. In that system, Astra serves as a System 2 planner, selecting a grounded subtask from stored visual history. It runs at medium reasoning effort through Codex CLI.

The paper reports:

On RoboMME, the system succeeds in 79.13% of episodes with an average of 3.63 Astra calls and 80.84 seconds per episode.

It also reports a result 34.62 points above the best published non-oracle baseline. This is not a failing system being used as a cautionary example. It is a successful system whose call pattern clarifies the tier question.

With an average of 3.63 planner calls per episode, this is not a workload shaped like continuous long-form generation. The 80.84-second figure covers an episode, not an isolated Astra response, and the study does not supply the token counts or latency breakdown needed to price Ultrafast. The defensible inference is narrower: a planner invoked sparsely inside a longer embodied process should not be upgraded merely because output tokens have become cheaper. Input processing, other system components, and sequential waiting may dominate the cost or elapsed time. That inference applies to this loop; it is not a universal property of planning agents.

Two other studies bound the independent evidence. A post-quantum cryptography migration study reports four exploratory trials using GPT-6 Astra through Codex and Claude Fable 5.1 through Claude Code passing all 40 checks, including both baselines. This confirms that the previous Astra generation was already being used inside an agentic coding workflow. Because both baselines also passed and the trials were exploratory, it does not isolate an Astra advantage or predict GPT-6.2 migration quality.

A separate robotic manipulation evaluation reports that GPT-6-Astra beat the strongest listed baseline, FLUX 3 Action at 42.9%, by 14.2 percentage points. That provides independent prior-generation evidence relevant to embodied work. Robotic manipulation is not the same task as operating a desktop interface, however, and the result says nothing directly about GPT-6.2 Astra’s computer-use performance.

Together, these papers support using Astra-class models in agent loops and inspecting the shape of those loops. They do not turn the new siblings’ positioning language into measured performance.

Configuration still needs a framework compatibility test

The following wiring instructions are all vendor-documentation-sourced and have not been independently tested for this article:

  • Use openai/gpt-6.2-astra or openai/gpt-6.2-sol as the AI Gateway model ID.
  • In the AI SDK, request Ultrafast by setting providerOptions.openai.serviceTier to 'ultrafast'.
  • In Chat Completions and Responses requests, set service_tier to 'ultrafast'.
  • For coding agents such as Codex and Cursor, Vercel instructs users to install the latest Vercel CLI and run npx vercel ai-gateway setup.

Those steps establish the documented gateway path. They do not prove that an intermediary agent framework forwards arbitrary model IDs, preserves providerOptions, or exposes the raw service_tier field. Before changing production routing, send one controlled request through the actual framework path and confirm which model and tier were billed. The changelog names fast mode alongside Ultrafast, but the supplied configuration instructions above concern Ultrafast; they should not be treated as interchangeable configuration labels.

Reasoning effort is another knob worth recording. The RoboMME deployment used medium reasoning effort through Codex CLI, which is a useful reminder that planner cost and delay cannot be attributed to the service tier alone. That prior-generation setting is not a recommended GPT-6.2 default.

Verify the price claim before building a budget around it

The 60% figure remains vendor-sourced and has not been checked here against OpenAI’s own pricing documentation. Before using it in a forecast, verify four things:

  1. The exact comparison. Find current OpenAI model and pricing documentation for GPT-6.2 Astra and GPT-6 Astra, and confirm that the compared rates are both Ultrafast output-token rates.
  2. The billing unit and route. Confirm the units and billing conditions, then check whether the path you actually use, including AI Gateway, bills at the rates you found.
  3. Your token mix. Replace the generic discount with observed input and output totals for each subtask. A lower output rate cannot rescue a budget dominated by retrieved context.
  4. The completed-task result. Compare total cost, retries, task success, and wall time against the same new model without Ultrafast. Comparing only against GPT-6 Astra would answer a different question.

For the routing experiment itself, log the model ID, service tier, input tokens, output tokens, response latency, end-to-end task time, retries, and completion result for each subtask. Run representative existing-codebase changes and brief-to-app jobs through both candidate routes where the choice is uncertain. If the faster tier lowers latency but increases retries or corrections, judge it by completed work rather than response speed.

I would therefore keep the default dispatch simple: Astra for existing-codebase surgery and computer use, Sol for brief-to-app generation and routine writing, with no faster tier purchased at the agent level. Enable Ultrafast on individual generation routes only after the pricing scope is confirmed and your own runs show a worthwhile cost-and-latency trade. For retrieval-heavy or sparse planning loops, the 60% output-price headline is not, by itself, a reason to change tiers.

Frequently Asked Questions

What are the gateway model IDs for GPT-6.2 Astra and Sol?

The gateway model IDs are openai/gpt-6.2-astra and openai/gpt-6.2-sol.

How do you request the Ultrafast service tier in the AI SDK?

In the AI SDK, request Ultrafast by setting providerOptions.openai.serviceTier to 'ultrafast'.

What does the 60% price reduction claim actually compare?

GPT-6.2 Astra’s Ultrafast output-token price is 60% lower than GPT-6 Astra’s.

References

Follow the links in the article for context. The supporting material is collected here for further reading.

  1. GPT-6.2 Astra and Sol now available on AI Gatewayvercel.comAccessed
  2. RoboMME study using GPT-6 Astraarxiv.orgAccessed
  3. Post-quantum cryptography migration studyarxiv.orgAccessed
  4. Robotic manipulation evaluationarxiv.orgAccessed

Join the discussion

Share a useful perspective or ask a question about this article.

Discussion guidelinesComments privacy