GPT-6 Astra Pricing: Real Cost per Agent Task 2026

A bottom-up cost model for OpenAI's flagship: the full rate card, the measured dollars per finished task, and the four multipliers that quietly decide your bill.

Independent measurement puts one completed coding-agent task on GPT-6 Astra at between $1.41 and $4.72, depending on nothing more than which reasoning effort you passed in the request - Artificial Analysis. That is a 3.3x swing on a single parameter, on the same model, doing the same work. The list price of $10 per million input tokens and $50 per million output tokens does not appear anywhere in that range, and it is not the number that produced it.

The problem is that almost every published guide to GPT-6 Astra pricing stops at the rate card. A rate card prices tokens. An agent does not buy tokens, it buys finished tasks, and the conversion rate between the two is where the entire cost of an agent program is decided. That conversion depends on how many times the loop runs, how much of the context is a cache hit rather than a fresh read, whether any single request crosses 272,000 input tokens, how often the task fails and has to be repeated, and how much human time is spent checking the result. McKinsey's July 2026 analysis of enterprise agent economics found that 60% of agentic AI spend goes to response refinement, the checking and correcting loop, rather than to the first inference - MarketScale. The rate card describes 40% of the bill at best.

This guide builds the other 60% from first principles. It starts with every price OpenAI charges for GPT-6 Astra, including the tiers most articles omit, then reconstructs what an agent task actually consumes, using measured token counts from independent benchmark runs rather than estimates. It costs seven workload archetypes end to end with the arithmetic shown, converts cost per attempt into cost per completed task using real pass rates, compares the same task priced across nine models, walks through every channel you can buy Astra work through, and ends with the levers that move the number and the failure modes that blow it up. The audience is not assumed to be technical. Every calculation is written out.

Contents

1. The complete GPT-6 Astra rate card, including the tiers nobody quotes
2. First principles: an agent buys finished tasks, not tokens
3. The measured number: what one agent task actually costs on Astra
4. Where the money goes: the cached-input majority nobody budgets for
5. Four multipliers on one rate card: effort, context, speed, and batching
6. From cost per attempt to cost per completed task
7. Seven agent workloads, costed end to end
8. Computer use and browser agents: the screenshot tax
9. The competitive field: the same task priced on nine models
10. Every way to buy Astra work, and what each channel really charges
11. Thirteen levers that move the bill, ranked by effect
12. How an Astra budget actually breaks
13. A decision framework for building on Astra in 2026
14. Future outlook: where agent pricing goes next

The master table: real cost per completed agent task, ranked

The table below ranks eleven model and effort configurations by what they actually cost to complete one agent task, measured rather than estimated. The cost and token figures come from Artificial Analysis's Coding Agent Index, which runs each model inside its native harness (Codex for OpenAI, Claude Code for Anthropic, Opencode for Gemini) across DeepSWE, Terminal-Bench v2.1 and SWE-Atlas-QnA, then reports the average pay-per-token API cost per task and the average input, cached and output tokens consumed - Artificial Analysis. Quality scores are that index on a 0 to 70 scale. Cache prices come from each provider's own pricing documentation.

The weights reflect what actually decides an agent program's economics rather than what is easiest to measure. Cost per completed task carries the most weight because it is the only figure that survives contact with a finance review. Loop token efficiency is weighted heavily because it is the mechanism behind cost, and because it is the one property that keeps paying off as prices change. Agentic quality matters because a cheap model that fails half its tasks is not cheap. Cache economics gets its own column because in a real agent loop the cache-read price, not the input price, is the dominant rate. Bill predictability captures the cliffs, promotional expiries and effort sensitivity that turn a forecast into a surprise.

Read the table for its shape rather than its winner. The top of the ranking is not occupied by the best model, and the bottom is not occupied by the worst one. Claude Fable 5.1 posts the highest agent quality in the field and lands seventh, because $9.18 per task is a hard number to defend when a configuration two points behind costs a fifth of that. Claude Opus 5 lands last despite scoring 68, because eleven million tokens per task is an enormous loop and the price per token is not low enough to absorb it. Meanwhile GPT-6 Astra at low effort runs a task on 668,900 tokens, the tightest loop anyone measured, and that single property carries it into the top five despite the worst cache economics on the board.

That is the argument of this entire guide compressed into one table. Astra is not expensive because its tokens cost $10 and $50. Astra is expensive when you leave the effort dial at max, when your prompts cross 272,000 tokens, and when your cache hit rate is poor, and it is genuinely competitive when you do not. The rest of this guide is about which of those things you control.

1. The complete GPT-6 Astra rate card, including the tiers nobody quotes

Most coverage of GPT-6 Astra pricing quotes two numbers and stops. The real rate card carries sixteen token prices across four service tiers, plus separate charges for built-in tools, and at least four of those prices will appear on your invoice within the first month of running an agent. OpenAI released Astra on September 3, 2026, positioning it as a frontier model built for computer use, software engineering and long-horizon agentic work rather than as a general chat upgrade - Fortune. The model exposes a 1,050,000 token context window with a maximum of 922,000 input tokens and 128,000 output tokens, and a knowledge cutoff of April 30, 2026 - OpenAI.

The base rates are $10 per million input tokens, $1 per million cached input tokens, $12.50 per million cache-write tokens, and $50 per million output tokens. Those four apply only when the request stays under 272,000 input tokens. Cross that line and the entire request reprices, not just the tokens above the threshold. Long-context requests bill at $20 input, $2 cached input, $25 cache writes and $75 output per million - OpenAI pricing. Batch and Flex service tiers halve every rate. Fast mode doubles them. All of these stack with the long-context repricing, which means the worst-case rate on Astra is Fast mode at long context: $40 per million input and $150 per million output, eight times the short-context batch input rate.

The full rate card, per million tokens:

Two things about this table matter more than the headline row. First, the cached input price of $1 per million is the rate you will actually pay for most of your tokens once an agent loop is running, and it is the number to optimise against. Second, the gap between the cheapest and most expensive row is 4x on input and 4x on output, and you can move between rows without changing a single line of your prompt. That is unusual. On most APIs the price is the price, and the only lever is which model you call. On Astra, four separate switches reprice the same call.

Built-in server-side tools carry their own charges on top of tokens. Web search bills at $10 per 1,000 calls, code interpreter runs from $0.03 to $1.92 per 20-minute session depending on memory allocation, and file search costs $0.10 per gigabyte-day of storage plus $2.50 per 1,000 tool calls - OpenAI pricing. For a research agent that fires eight searches per task, that is eight cents of tool fees before a single token is counted, which sounds negligible until you multiply it by ten thousand tasks a month and find $800 sitting in a line item nobody forecast.

Rate limits are the last part of the card, and they are a cost constraint even though they are not a price. Tier 1 accounts get 500 requests and 500,000 tokens per minute. Tier 5 accounts get 15,000 requests and 40 million tokens per minute. The jump from Tier 4's 4 million tokens per minute to Tier 5's 40 million is tenfold, and it gates whether you can run agents in parallel at all - OpenAI. An agent fleet that has to serialise because of a token-per-minute ceiling costs more in wall-clock time and in idle infrastructure than the tokens themselves, which is a cost that never appears on the OpenAI invoice.

2. First principles: an agent buys finished tasks, not tokens

Start with the structural question rather than the pricing question. What does a business actually buy when it deploys an agent? Not tokens, and not inference. It buys a finished unit of work: a merged pull request, a resolved support ticket, a filled expense report, a reconciled spreadsheet, a drafted contract. The token is an input to that outcome the way electricity is an input to a factory. Nobody manages a factory by tracking kilowatt-hours, and nobody should manage an agent program by tracking tokens.

This reframing produces an equation with four terms rather than one. The cost of a finished task equals the tokens consumed per attempt, multiplied by the blended price of those tokens, divided by the probability that an attempt succeeds, plus the cost of the human time spent verifying the result. Every one of those four terms moves independently, and three of them are not on any provider's pricing page. That is why token prices have fallen by more than 99% in roughly two years while enterprise AI bills tripled anyway - MarketScale. Cheaper tokens made agents viable, agents consume vastly more tokens than chat, and the volume increase outran the price decrease.

The magnitude of that volume increase is the fact most cost models get wrong. As organisations move from chat assistants to agentic workflows across a process, token consumption per task grows by one to two orders of magnitude, because a single user request fans out into many model calls as the agent plans, calls tools, reads results, verifies its own work and corrects itself - Correlation One. Vantage's analysis of real agentic coding sessions models a representative fifty-turn session at roughly one million input tokens against forty thousand output tokens, an input-to-output ratio near 25 to 1, with input accounting for about 85% of the session cost - Vantage. Chat is output-heavy. Agents are overwhelmingly input-heavy, and that inversion is why the output price everyone quotes is the least important number on the rate card.

There is a second structural consequence, and it is the one that separates a good agent architecture from an expensive one. Because context accumulates across turns, and because every turn resends the accumulated context, the token cost of an agent loop grows roughly with the square of its length rather than linearly. A twenty-turn loop does not cost twice a ten-turn loop, it costs closer to four times, unless caching intervenes. Prompt caching is the mechanism that flattens that curve, which is why cache pricing is not a footnote on an agent's rate card. It is the rate card.

Reason from that and a clear priority order falls out. The single largest lever on agent cost is the number of turns the loop runs, because it drives the quadratic term. The second is cache hit rate, because it sets the price of the accumulated context. The third is which model runs which turn, because most turns in a loop are mechanical and do not need frontier reasoning. The token price itself is fourth, and the output price is a distant fifth. Any cost optimisation program that starts with "negotiate a better token price" has started at the bottom of the list. We covered the deeper mechanics of this in our analysis of the true cost of LLM inference in 2026, which traces the same arithmetic from the infrastructure side.

3. The measured number: what one agent task actually costs on Astra

Estimates are worthless here because the variance is too large. What matters is measurement, and the most rigorous public measurement of cost per agent task comes from Artificial Analysis, which runs each model inside the harness its vendor actually ships (Codex for OpenAI, Claude Code for Anthropic) and reports the average pay-per-token API cost of completing one task across a three-benchmark suite. Their GPT-6 Astra results, published the week of launch, give the cleanest available answer.

At max effort, one Codex task on GPT-6 Astra costs $4.72. At xhigh it costs $3.27, at high $2.89, at medium $2.19, and at low $1.41 - Artificial Analysis. The corresponding quality, measured on the Coding Agent Index, moves from about 62 at low effort to 67 at max. So the top of the dial costs 3.3 times the bottom of the dial and buys roughly five index points. Whether that trade is worth it is a workload question, not a general one, but the shape of the trade is unambiguous: the marginal dollar buys steeply diminishing quality.

The comparison that reframes Astra's reputation is what the same measurement says about everyone else. GPT-5.6 Sol at max effort costs $5.00 per task, more than Astra at max, despite listing at $4 and $20 per million rather than $10 and $50. Claude Opus 5 at xhigh costs $8.17 and Claude Fable 5.1 at max costs $9.18, both roughly double Astra's max-effort figure at similar or slightly higher quality. Astra is the more expensive model per token and the cheaper model per task, against every frontier competitor measured.

The chart below shows the full field, and it is worth reading carefully because the ordering has almost nothing to do with the rate cards.

The mechanism behind that ordering is token consumption, and it is dramatic. Astra at max effort consumes 2.1 million total tokens per task. Sol at max consumes 6.8 million. Opus 5 at xhigh consumes 11 million. Gemini 3.8 Flash, the cheapest tokens in the comparison, consumes 14.4 million - Artificial Analysis. Astra at low effort finishes a task on 668,900 tokens, which is one twenty-first of what Gemini 3.8 Flash needs for the same suite. That is the entire story: Astra's tokens cost 13 times more than Gemini 3.8 Flash's, and Astra uses 21 times fewer of them.

OpenAI's own launch material makes the same argument on a different benchmark, and unusually for a vendor chart, it plots cost on the x-axis rather than hiding it. On AutomationBench, a business-workflow evaluation, Astra traces a curve from roughly 30% accuracy at about $1.10 per task up to 41.4% accuracy at around $1.75, while GPT-5.6 Sol tops out near 18% at under a dollar and Claude Fable 5.1 is plotted at 31.4% out beyond $4 per task, marked as a reported score rather than a measured curve.

Two cautions before anyone takes these numbers to a budget meeting. First, all of them are coding and workflow benchmarks, and your workload is probably not a benchmark. Benchmark tasks are well-specified, bounded, and have a verifiable success condition, which is close to the best case for token efficiency. Second, Artificial Analysis attaches an explicit warning to its token-usage data: prompt cache hit rates vary significantly by provider routing, and that variation materially changes effective cost. The measured numbers are the right starting point and the wrong ending point. Our guide to why AI coding benchmarks lie works through how far a benchmark result can be trusted to predict production behaviour.

4. Where the money goes: the cached-input majority nobody budgets for

Here is the single most useful fact in this guide, and it is one that almost no pricing article mentions. In a measured agent loop, roughly 90% of all tokens are cached input. On Astra at max effort, 1.9 million of the 2.1 million tokens per task are cache reads. On Claude Opus 5 at xhigh, 10.6 million of 11 million are. On Gemini 3.8 Flash, 13.3 million of 14.4 million are - Artificial Analysis. Output tokens, the ones with the scary $50 price tag, are a rounding error by volume.

This inverts the entire cost model. If nine tokens in ten are cache reads, then the cache-read price is your effective token price, and everything else is noise. On Astra that price is $1 per million, which is the standard 0.1x multiplier applied to the $10 input rate - OpenAI caching guide. On Claude Fable 5.1, Anthropic set the multiplier at 0.025x, making cache reads $0.25 per million on the identical $10 base input price - Anthropic. Two models with identical sticker prices, and a 4x difference on the rate that governs 90% of the tokens.

Anthropic cut that multiplier deliberately and said what it was worth. The company estimated the change makes typical workloads about 25% cheaper and highly agentic workloads up to 45% cheaper, without moving the headline price at all - VentureBeat. That is a pricing move aimed precisely at the token distribution described above, and it is the clearest signal available that the labs now compete on the cache rate rather than the headline rate. If you are choosing between two models with the same sticker price, the cache multiplier is the tiebreaker.

None of which helps if your cache does not hit. OpenAI's caching is automatic on supported models and requires an exact prefix match, with a minimum of 1,024 visible input tokens and a 30-minute lifetime that refreshes on every reuse without another write charge - OpenAI. The list of things that silently invalidate a hit is where agent architectures go wrong.

A cache hit is destroyed by any of these:

• Changing the model mid-conversation, including a fallback to a cheaper tier
• Editing tool definitions, names, descriptions, schemas, or even their ordering
• Changing reasoning.effort between turns of the same conversation
• Rewriting earlier turns rather than appending new ones
• Running context compaction, which rewrites the prefix by definition

The fourth and fifth entries deserve more attention than they usually get, and the third is the trap that catches sophisticated teams. A common and otherwise sensible optimisation is to start a task at low effort and escalate to high effort when the agent struggles. On Astra that escalation invalidates the entire accumulated cache prefix, so the next turn pays the full $10 per million input rate on context that would have cost $1 per million. On a 500,000-token context, that one switch costs $4.50 in a single call. Escalating effort is still often correct. It is simply not free, and it should happen at a task boundary where a fresh cache is expected rather than mid-loop where one is not. The same trap applies to any routing layer that swaps models between turns, which is why our guide to model routing for agents argues for routing at task boundaries rather than turn boundaries.

The practical takeaway is a design rule, not a setting. Structure every agent prompt so that the stable material comes first and never moves: system instructions, tool definitions in a fixed order, reference documents, then the growing conversation appended at the end. OpenAI's own documentation reports applications achieving cache hit rates of about 70% and above 90% with that structure - OpenAI. The difference between a 40% hit rate and a 90% hit rate on Astra, on a workload with a million input tokens per task, is roughly $4.50 per task. Over a hundred thousand tasks a year that is $450,000 of pure prompt architecture.

5. Four multipliers on one rate card: effort, context, speed, and batching

The rate card in section one is not a price, it is a grid, and four independent switches decide which cell of the grid your request lands in. Understanding those four switches is the difference between a bill you can forecast and a bill that arrives as news. None of them require changing your prompt or your model, which is precisely why they are so easy to leave in an expensive position by accident.

The first switch is reasoning effort, and it is the largest. Astra accepts five values: low, medium, high, xhigh and max, and unlike earlier OpenAI models it does not support a none or minimal setting - OpenAI. Effort does not change the price per token at all. It changes how many tokens the model spends thinking, and the measured effect on cost per task is 3.3x from low to max. Most production agent traffic sits at whatever the harness defaults to, which is usually medium or high, and most teams have never tested whether the tasks they run actually need it.

The second switch is the 272,000 token context threshold, and it is the one that produces genuine bill shock because it is a cliff rather than a slope. A request with 272,000 input tokens bills at the standard rate. A request with 272,001 input tokens reprices the entire request at double input and 1.5x output. CloudZero's worked example is instructive: a 280,000-token request costs roughly $7.10, while the same request trimmed to 272,000 tokens costs roughly $3.72 - CloudZero. Eight thousand tokens, about six pages of text, nearly doubled the price of the call.

The reason this matters so much for agents specifically is that agents grow their context monotonically. A loop that starts at 40,000 tokens and adds 15,000 per turn crosses the threshold on turn sixteen, and every turn after that pays double. Nothing announces it. The agent does not behave differently. The only signal is the invoice at the end of the month, which is why any Astra agent running long horizons needs a hard context budget enforced in code, with compaction or summarisation triggered comfortably below 272,000 rather than at the model's actual limit.

The third switch is service tier, and it splits cleanly by whether a human is waiting. Batch and Flex halve every rate. Fast mode doubles them. For agents this is less useful than it first appears, because the defining property of most agent work is that a subsequent step depends on the current one, and Batch is asynchronous with no latency guarantee. The workloads where Batch genuinely applies are the ones where you can fan out independent tasks and collect results later: nightly document classification, bulk enrichment, evaluation runs, regression suites over a corpus. Those are real and often large. They are just not the interactive agent loop that most of this guide is about.

The fourth switch is data residency, which applies a 10% uplift on every token category when you pin inference to a specific region rather than using global routing. It is small next to the other three, and it is usually a compliance requirement rather than a choice, but it compounds with everything else. A Fast-mode long-context request on a residency-pinned endpoint bills at $44 per million input tokens, which is 8.8 times the batch short-context rate for the identical prompt.

Put the four switches together and the spread is 80x, from $0.50 per million for a cached batch read to $40 per million for a Fast-mode long-context uncached read. That is a wider range than the gap between GPT-6 Astra and GPT-5.6 Luna, two models that differ by 50x on list input price. The switches matter more than the model choice, and they are the part of the bill that almost nobody audits. The related dynamic on the effort dial specifically is covered in more depth in our piece on setting the effort dial to cut AI costs.

6. From cost per attempt to cost per completed task

Everything so far prices an attempt. A business pays for outcomes, and attempts fail. The conversion is arithmetic that any finance team would recognise: expected cost per completed task equals cost per attempt divided by the probability of success, plus the expected cost of cleaning up the failures that slip past your checks. DoiT formalised the same equation in its August 2026 analysis of Claude and OpenAI economics, and it produces results that reorder every ranking built on cost per attempt alone - DoiT.

Work an example. Suppose an attempt costs $2.19 (Astra at medium effort, the measured figure) and the task succeeds 70% of the time. Expected cost per completed task is $2.19 divided by 0.70, which is $3.13. Now suppose you move to max effort, where an attempt costs $4.72 and the success rate rises to 80%. Expected cost per completed task becomes $5.90. The higher-effort configuration bought ten points of success rate for an 89% increase in cost per outcome, which is a bad trade. But flip the numbers: if low effort succeeds only 45% of the time, its $1.41 attempt becomes $3.13 per completed task, identical to medium despite costing a third as much per try. The cheapest attempt and the cheapest outcome are frequently different configurations, and only measurement on your own workload tells you which.

The failure rates that go into that division are workload-specific and usually worse than benchmark numbers suggest. On OSWorld 2.0, the computer-use benchmark, Astra scores 72.6%, up from GPT-5.6 Sol's 65.7%, and it cuts average time per task from about 75 minutes to about 40 - DataCamp. A 72.6% success rate means more than one task in four fails, which multiplies expected cost by 1.38 before any retry logic. On harder agentic suites the numbers are far worse. Astra scores 59.3% on Agents' Last Exam and 41.4% on AutomationBench, and at 41.4% the expected-cost multiplier is 2.4x - OfficeChai.

The second term, cleanup cost, is the one that most cost models omit entirely and the one that most often decides whether an agent program is economic. DoiT's measurement of engineer time found that senior engineers spend 4.3 minutes reviewing AI-generated code against 1.2 minutes for human-written code, a 3.6x increase in review burden per unit of output. At a loaded cost of $150 an hour, 4.3 minutes is $10.75 of human time attached to a task whose model cost was $2.19. The model is 17% of the true unit cost. Anyone optimising the 17% while ignoring the 83% is solving the wrong problem, which is a large part of why McKinsey found 93% of enterprise AI teams exceeding their budgets in its May 2026 FinOps survey of 75 respondents - MarketScale.

There is a hopeful reading of this that is also true. If human review is the dominant term, then the model property worth paying for is not raw capability but reliability and low hallucination, because those reduce review time. Astra's reported hallucination rate of 4.2% against GPT-5.6 Sol's 12.2% is, on this analysis, worth more than several of its benchmark wins, because a two-thirds reduction in wrong answers reduces the expensive human term rather than the cheap token term - OfficeChai. That is a genuinely different way to justify a premium model, and it is the justification that survives scrutiny.

7. Seven agent workloads, costed end to end

Benchmarks measure coding agents because coding agents are easy to score. Most deployed agents do something else. This section prices seven common workload shapes on Astra using the official rate card, with every assumption stated so you can substitute your own numbers. All figures use the standard short-context tier at $10 per million input, $1 per million cached input and $50 per million output, and assume a mature cache with a hit rate around 85% for multi-turn work.

The method is deliberately simple. For each archetype, estimate the fresh input tokens, the cached input tokens, the output tokens and any server-side tool calls, then multiply each by its rate and add. The value is not in the specific numbers, which will differ for your workload, but in seeing which term dominates in each shape. It is rarely the term people expect.

The 176x spread between the cheapest and most expensive row is the point. A single structured extraction on the world's most expensive frontier model costs five and a half cents, which is why the instinct to route every simple call to a cheap model is often not worth the engineering it takes. At the other end, a long computer-use task costs nearly ten dollars per attempt before you divide by a 72.6% success rate, at which point it is $13.36 per completed task and you are firmly in territory where a human doing the same work for fifteen minutes is price-competitive.

Look at which term dominates in each row and a design principle emerges. In the retrieval and support rows, output tokens are the largest single line despite being the smallest count, because the $50 output rate is fifty times the cached-input rate. In the last three rows, cached input dominates completely, because volume overwhelms the price differential. The crossover happens somewhere around 100,000 cached tokens per task. Below that, controlling verbosity is the highest-leverage optimisation. Above it, controlling context growth is, and verbosity barely matters. Two different cost problems wearing the same clothes.

The research-agent row deserves a note because it contains the one line item people forget. Eight web searches at $10 per thousand calls is $0.08, which is 3.5% of that task's cost and easy to dismiss. But server-side search results also enter the context as input tokens, so each search charges twice: once as a tool fee and once as the tokens it injects. A search returning 3,000 tokens of results costs $0.01 in fees and $0.03 in fresh input, and the injected tokens then persist in the context for every subsequent turn, where they are re-read as cache hits. One search on turn two of a twelve-turn loop is paid for eleven more times at the cache rate. This is the mechanism by which research agents become expensive, and it is invisible in any per-call view of the bill.

The computer-use row uses assumptions worth stating plainly, because it is the least benchmark-anchored estimate in the table. Anthropic's documentation, which is the most explicit public accounting of computer-use token overhead, puts a screenshot at roughly 1,000 to 1,800 tokens as image input and the computer toolset definition at about 4,500 input tokens per request - Anthropic. At 120 steps with cumulative context, three million total tokens is a conservative figure. OSWorld 2.0's longer tasks run to hundreds of tool calls, so a genuinely long desktop workflow can be several times this.

8. Computer use and browser agents: the screenshot tax

Computer use is the capability OpenAI built Astra around, and it is also the most expensive way to spend tokens that exists. Understanding why requires looking at what a computer-use loop actually sends over the wire, which is not text. Every step returns a screenshot, the screenshot is image input, image input is expensive per unit of information conveyed, and the screenshot then stays in the context for the remainder of the task. A desktop workflow is an accumulating pile of pictures, priced per token.

The arithmetic is unforgiving. A single screenshot at 1,500 tokens seems trivial at $10 per million, about a hundredth of a cent. But OSWorld 2.0 tasks average 318 tool calls under the paper's strongest evaluation setting, against about 30 in the previous version, and each call adds its screenshot to a context that every subsequent call re-reads - OSWorld 2.0 paper. By step 200, each call is re-reading roughly 300,000 tokens of accumulated screenshots. Even at the $1 cached rate that is thirty cents per step, and there are another 118 steps to go. This is the quadratic growth described in section two, made concrete and made visual.

Astra's answer to this is not a lower price, it is a shorter loop. OpenAI reports that Astra cuts average OSWorld 2.0 task time from about 75 minutes to about 40 while raising the score from 65.7% to 72.6%, and claims 1.9x faster task completion than Sol on Mind2Web inside the Codex harness - DataCamp. It also reports Astra using roughly 65% fewer output tokens than Claude Opus 5 on Agents' Last Exam. Fewer steps and shorter outputs attack the quadratic term directly, and on a workload where the quadratic term dominates, that is worth considerably more than a 4x cheaper token.

The video below is OpenAI's own developer-facing walkthrough of the model, and it is the clearest available demonstration of what a multi-application desktop task looks like when the model drives it, including the browser and spreadsheet work that generates the screenshot volume discussed here.

There is a structural alternative to paying the screenshot tax, and it is worth knowing about because it changes the cost by an order of magnitude rather than a percentage. Instead of feeding the model pixels and asking it to decide where to click, you expose the application's state as structured data and let the model read and mutate that state through code. Research on this approach reports roughly 9x lower cost per task on OSWorld 2.0 by replacing screenshot loops with state manipulation - AI Weekly. Where an API exists, use the API. Computer use is what you do when there is no API, and it should be priced as the expensive fallback that it is.

Browser-based work sits between the two. OpenAI's Operator, the browser agent product, has been reported at roughly $0.50 per completed browser task in early usage, which is far below the desktop figures above because a browser exposes a document object model that can be read as text instead of a screen that must be read as pixels - Coasty. If your workflow can be expressed as browsing rather than as desktop operation, that choice alone is worth roughly twenty times the cost difference. Our deeper treatment of the benchmark itself is in what 72.6% on OSWorld actually means, and the broader field is mapped in our computer use benchmarks ranking.

9. The competitive field: the same task priced on nine models

Astra does not exist in isolation, and the honest question is not whether it is expensive but whether anything else does the same job for less. September 2026 produced an unusually dense cluster of releases: Anthropic shipped Claude Fable 5.1 on September 1, Google shipped Gemini 3.8 Flash on September 2, and OpenAI shipped Astra on September 3. Three frontier releases in three days, with three very different pricing philosophies.

The philosophies matter more than the prices. OpenAI priced Astra at a premium and defended it on efficiency, charging 2.5 times the current GPT-5.6 Sol rate and arguing that the shorter loop more than compensates. Anthropic held its headline price and cut the cache rate, keeping Fable 5.1 at $10 and $50 while setting its cache-read multiplier to 0.025x instead of the standard 0.1x, a move aimed squarely at agentic workloads - Anthropic. Google priced Gemini 3.8 Flash at utility rates with an expiry attached, holding $0.75 and $3.75 per million through December 31, 2026, after which both figures double - Enterprise DNA. One lab competes on efficiency, one on cache mechanics, one on introductory pricing.

Beneath the frontier sits a tier that has become genuinely usable for agent work and is priced two orders of magnitude lower. The live model catalogue puts Meta's Muse Spark 1.3 at $1.25 and $4.25 per million, Alibaba's Qwen3.8 Max at $2 and $6, Moonshot's Kimi K3 at $3 and $15, Z.ai's GLM-5.3 at $1.40 and $4.40, and DeepSeek V4 Flash at under $0.10 and $0.18 - OpenRouter. Several of these post Coding Agent Index scores within a handful of points of the frontier. GLM-5.3 scores 60 on the Intelligence Index against Astra's 61, at a fourteenth of the input price.

Read the last two columns together and the entire premise of token-price shopping falls apart. Gemini 3.8 Flash charges a thirteenth of Astra's input rate and produces a more expensive task than Astra at medium effort, because it needs 14.4 million tokens where Astra needs 1.1 million. GPT-5.6 Luna charges a fiftieth of Astra's rate and genuinely is cheaper per task, at $0.29, but it scores 57 on the Coding Agent Index against Astra's 67, so a meaningful share of those tasks come back wrong. Cheap tokens do not produce cheap tasks, and on their own they never produce cheap outcomes.

The market context behind these choices is worth one paragraph because it explains why the pricing looks the way it does. Menlo Ventures' enterprise survey data puts Anthropic at roughly 40% of enterprise LLM API spend against OpenAI's 27%, with Claude commanding around 54% of enterprise AI coding usage against Codex's 21% - ValueAdd VC. OpenAI is consumer-heavy and enterprise-second; Anthropic is the reverse. Astra's positioning as an agentic and computer-use flagship, priced at a premium and marketed on task efficiency rather than token cost, reads as a direct attempt to compete for the enterprise agent workload where Anthropic currently leads. Our running comparison of the field is in the best LLM for AI agents ranking, and the budget tier specifically in the cheapest LLM APIs price table.

10. Every way to buy Astra work, and what each channel really charges

There are six distinct ways to pay for GPT-6 Astra output, and they are not interchangeable. The same task can cost you nothing extra, four dollars, or a share of a two-hundred-dollar subscription depending only on which door you walk through. Choosing the wrong door is one of the more common and more expensive mistakes in this category, because the channels are priced on completely different units: tokens, credits, seats, and message allowances.

The API is the transparent channel and the one every figure in this guide is based on. You pay per token at the rates in section one, you see exactly what you consumed, and you can optimise every lever discussed here. The subscription channels invert that: you pay a flat fee and receive an allowance denominated in messages or credits, which is excellent for predictability and terrible for optimisation, because the levers that matter most are hidden behind the product. Astra appears in ChatGPT as GPT-6 Pro with plan-specific caps: roughly 50 messages per week on the $100 Pro tier, 200 per week on the $200 tier, 15 per month on Business Standard and 50 per week on Business Premium, at no additional charge over the plan price - Yotta Labs.

Codex sits between the two and is the channel most agent-shaped work actually flows through. Since April 2026 Codex meters usage in API-aligned credits worth about $0.04 each, mapped directly to the underlying token rates, with a typical session costing $0.50 to $2.00 and heavy users landing near $100 to $200 a month - UI Bakery. At $0.04 per credit, Astra's rates translate to 250 credits per million input tokens, 25 per million cached input, and 1,250 per million output. That arithmetic is ours rather than a published table, but it follows directly from the published credit value and the published token rates, and it is the conversion that lets you compare a Codex bill against an API bill on equal terms.

The sixth row is the one that changes the shape of the decision rather than the size of the number, and it deserves the most scrutiny because it is where the market is actually moving. Agent platforms bundle the model cost into a unit of work and take responsibility for the orchestration, retries and infrastructure that this guide has spent several thousand words explaining you have to build yourself. Cognition's Devin meters in Agentic Computing Units, with a Starter plan at $500 for 250 ACUs and overage near $2 per ACU, and typical tasks running 0.5 to 5 ACUs, which is $1 to $10 per task - Usagebar. Cursor runs a two-pool credit model, $20 for Pro and $200 for Ultra with roughly $400 of model usage included, billing third-party frontier models at their API price - CloudZero. Customer support platforms price the outcome directly, with published per-resolution rates from about $0.50 to $2.00 - Quickchat AI. And platforms like o-mega, which builds and operates an autonomous company through AI agents, meter in credits across plans running from $29 for 2,000 credits to $1,199 for 160,000, with the model spend absorbed into the credit rather than billed alongside it.

The trade in every one of those rows is the same: you exchange visibility and control for predictability and less engineering. If your agent volume is low or your team is small, that is usually the right trade, because the levers in this guide take real engineering time to build and the savings on a hundred tasks a month will not pay for a week of it. If your volume is high, the trade inverts, because a 40% saving on a six-figure annual token bill funds a lot of prompt architecture. The crossover is roughly where your monthly model spend exceeds the fully loaded cost of the engineer who would optimise it, which for most teams lands somewhere between $5,000 and $15,000 a month.

One channel-specific caution. Astra is distributed through the OpenAI API, AWS Bedrock and Microsoft Azure, and marketplace pricing is set by the cloud provider rather than by OpenAI, so it can differ from the direct rates used throughout this guide - MindStudio. Each cloud also applies its own rate limits and deployment types, which change how many agents you can run concurrently. If you are committed to a cloud spend agreement, running Astra through the marketplace may be cheaper in net terms even at a higher list rate, because the spend draws down a commitment you have already made. That is a procurement optimisation rather than a technical one, and it is frequently larger than everything else in this guide combined.

11. Thirteen levers that move the bill, ranked by effect

Everything above is diagnosis. This section is treatment, ordered by how much each lever actually moves the number rather than by how commonly it is recommended. The ordering matters because the two lists are almost inverted: the advice you see most often sits near the bottom here, and the changes with the largest effect require architectural work that a settings change cannot substitute for.

The top of the list attacks loop length, because loop length drives the quadratic term in section two. The middle attacks the blended token price. The bottom attacks the unit rates, which is where most cost programs start and where the least money is. None of these are exotic. All of them are things a competent team can implement in weeks, and the first three are frequently worth more than everything below them combined.

The five highest-leverage changes, in order:

1. Cut turns, not tokens. Better tool design, clearer task specification and fewer verification rounds reduce the loop length that everything else multiplies against.
2. Engineer the cache prefix. Stable system prompt, fixed tool ordering, append-only conversation. Moving a hit rate from 40% to 90% cuts a million-token task by roughly $4.50 on Astra.
3. Set the effort dial per task type. Measured swing from low to max is 3.3x. Most tasks in a mixed workload do not need max.
4. Enforce a hard context budget. Stay below 272,000 tokens, and compact or summarise before the cliff, never after it.
5. Route by task, not by turn. Send mechanical steps to a cheaper tier at task boundaries, where a cache miss is expected anyway.

Those five are ordered deliberately, and the reason the fifth is fifth rather than first is the finding in section four: routing that switches models mid-conversation invalidates the cache prefix, and the cache saving it destroys frequently exceeds the token saving it captures. Routing works, and our analysis of cutting agent costs with model routing documents savings in the 60% range, but it works at the boundaries between tasks rather than inside a single agent loop. A router that fires on every turn is a cache destroyer wearing an optimisation costume.

The next tier of levers is more mechanical and still meaningful. Move asynchronous workloads to Batch or Flex for an immediate 50% cut on work where nobody is waiting: evaluation runs, nightly classification, bulk enrichment, regression suites. Cap output length explicitly, because on short-context tasks the $50 output rate is the dominant line and models are verbose by default. Prefer APIs over computer use wherever an API exists, for the roughly 9x difference documented in section eight. Deduplicate context aggressively, because agents routinely re-read the same file or search result several times in a single loop, and each re-read is a fresh input charge if it falls outside the cache prefix.

The final tier is the one most programs start with, and it is worth doing after the others rather than instead of them. Negotiate volume pricing once your spend is material, since both major labs offer custom terms above their published tiers. Audit for the residency uplift and drop the 10% regional premium wherever compliance does not require it. Watch the promotional expiries, because GPT-5.6 Sol's discounted rate is committed only through November 21, 2026 and Gemini 3.8 Flash's introductory rate doubles on January 1, 2027, which means two of the cheapest options in this guide have a scheduled price increase attached. Instrument cost per completed task as a first-class metric, reported alongside latency and success rate, because a number nobody measures is a number nobody manages, and every lever above is invisible without it.

12. How an Astra budget actually breaks

Budgets rarely fail because someone did the arithmetic wrong. They fail because a mechanism nobody modelled started running, quietly, in the middle of the month. These are the five failure modes that have actually produced surprise invoices on frontier agent workloads, and each one has a specific detection signal and a specific fix.

The first is silent context creep past the 272,000 threshold. An agent that ran comfortably at 200,000 tokens per request in testing crosses the line in production because real conversations are longer than test ones, and every request from that point bills at double input and 1.5x output. There is no error, no warning, and no change in behaviour. The detection signal is a step change in average cost per request with no change in request volume. The fix is a hard token budget enforced before the call, not after, with compaction triggered at a comfortable margin below the threshold.

The second is cache collapse from a harmless-looking change. Someone reorders the tool definitions, adds a timestamp to the system prompt, or introduces a per-request user identifier near the top of the context. Every one of those breaks the exact prefix match that a cache hit requires, and the workload silently moves from paying $1 per million to paying $10 per million on the majority of its tokens. The detection signal is the ratio of cached to uncached input tokens in the usage response, which is the single most valuable number to log and alert on. A tenfold cost increase with no change in token volume is almost always this.

The third is the retry loop that does not converge. An agent that fails a task and retries is normal. An agent that fails, retries with more context, fails again with more context still, and repeats five times has spent five increasingly expensive attempts to produce nothing. Because each retry carries the accumulated failure history, the fifth attempt can cost several times the first. The fix is a per-task spend ceiling enforced in the orchestration layer, not a retry count, because retry counts do not bound cost when each retry is larger than the last.

The fourth is effort inflation by default. Harnesses ship with defaults, defaults get copied into production, and nobody revisits them. If your Codex configuration sits at max because that was the example in a blog post, you are paying $4.72 per task where $2.19 would have done, and the difference compounds across every task forever. The signal is simply that nobody on the team can say what effort level production runs at.

The fifth is the structural one, and it is the reason McKinsey found 20% of organisations already constraining AI use because of operating costs in its 2026 State of AI survey of 1,719 participants - MarketScale. Agent programs scale by adding tasks, and each new task type carries its own token profile, success rate and review burden. A program that is comfortably economic on three workflows can become uneconomic on the eighth, not because anything got more expensive, but because the eighth workflow has a 35% success rate and a heavy review requirement and nobody costed it before shipping it. The discipline that prevents this is per-workflow unit economics, computed before launch and reviewed monthly, which is the same discipline any operations team applies to any other unit of production. Our analysis of why most agent pilots never scale covers what happens when it is skipped.

The curve above is the most important shape in this guide. Between 95% and 75% success the cost per outcome barely moves. Below 50% it goes vertical. That is why reliability, not price, is the variable that decides whether an agent workload is economic, and it is why a premium model with a materially higher success rate can be the cheap option even at five times the token price. It is also why the correct first response to an expensive agent is almost never "find a cheaper model" and almost always "find out why it is failing."

13. A decision framework for building on Astra in 2026

The question is not whether GPT-6 Astra is worth $10 and $50 per million tokens. That question has no general answer. The answerable question is which of your workloads belong on it, and the framework below sorts them using properties you can observe before you spend anything. Work through it per workflow, not per company, because the right answer genuinely differs between two workflows in the same product.

Start with the shape of the work rather than its importance. Astra earns its premium where the loop is long, the context is large, and the task has a verifiable success condition, because those are the conditions under which its token efficiency and low hallucination rate convert into fewer turns and less human review. It does not earn its premium on short, high-volume, well-specified calls, where a mid-tier model produces an indistinguishable result at a fifth of the price and the loop is too short for efficiency to matter.

Then apply three tests in order. The volume test asks how many times a day this workflow runs; below roughly a hundred runs a day the total spend is small enough that engineering time dominates and you should simply use the best model and move on. The verifiability test asks whether success can be checked automatically; if it cannot, human review will dominate the unit cost and you should optimise for reliability rather than price. The horizon test asks how many turns a typical run takes; under five turns, token price is the dominant term and cheap models win, while over twenty turns, loop efficiency dominates and Astra's measured token advantage becomes decisive.

The benchmark spread above is worth reading with the cost framework in hand rather than as a scoreboard. Astra's largest margins are on AutomationBench at 41.4% against Sol's 18.1% and on ARC-AGI-3 at 99.9% against Sol's 7.8%, which are business-workflow and novel-reasoning tasks respectively - OfficeChai. Its narrowest margins sit in the clinical and coding rows of the same table, where HealthBench Professional reads 63.4% against 60.5% and Terminal-Bench 4.0 reads 57.9% against Claude Fable 5.1's 55.8%. If your workload looks like the first pair, a 2.5x token premium is straightforwardly justified by the success-rate arithmetic in section six. If it looks like the second pair, you are paying a large premium for a small margin, and a mid-tier model or a competitor is the better answer.

That produces four concrete recommendations rather than one. For long-horizon coding and computer-use work at scale, Astra at medium or high effort is currently the strongest cost-per-outcome option in the field, and the measured token efficiency is the reason. For high-volume, short, well-specified calls, route to GPT-5.6 Terra or Gemini 3.8 Flash and reserve Astra for escalations. For human-judged output quality, where no test can score the result, weight reliability heavily and consider Claude Fable 5.1 despite its higher measured task cost, because its cache economics and index-leading quality change the arithmetic when review time dominates. For teams below roughly $5,000 a month in model spend, use a platform that bundles the orchestration rather than building the optimisation layer described here, because the savings will not repay the engineering.

The one recommendation that applies to every case is to measure before committing. Every number in this guide is a public benchmark figure or an arithmetic model, and neither is your workload. Run a hundred representative tasks at three effort levels, log the cached-to-uncached token ratio, record the success rate, and time the human review. That experiment costs a few hundred dollars and it will tell you more than any published comparison, including this one.

14. Future outlook: where agent pricing goes next

Three structural forces are visible in the September 2026 pricing moves, and each one predicts something specific about the next year. Reading them is more useful than forecasting a price, because prices in this category change monthly and structures change slowly.

The first force is that competition has moved off the headline rate and onto the rates beside it. Anthropic cut cache reads 75% while holding its input and output prices exactly. Google set an introductory rate with a scheduled doubling. OpenAI runs a promotional discount on Sol with a stated expiry, and prices Astra at a premium defended on efficiency. None of these labs cut the number on the front of the box. All of them competed hard on the numbers behind it. Expect that to continue, which means the comparison that matters over the next year is a blended effective rate computed on your own token mix, not a rate card comparison. It also means that any published price table, including the ones in this guide, is a snapshot with a short half-life.

The second force is that token efficiency is now a product feature rather than a side effect. OpenAI marketed Astra on using roughly 65% fewer output tokens than Claude Opus 5 on Agents' Last Exam and on cutting task time from 75 minutes to 40, and Artificial Analysis independently measured a roughly threefold token reduction against GPT-5.6 Sol at max effort. That is a lab explicitly optimising for the customer's bill rather than for a benchmark score, which is new. If it holds, the next generation of frontier models will be judged partly on tokens per task, and the shape of the market will shift from cheaper tokens toward fewer of them. That is a better outcome for buyers than a price war, because token efficiency compounds with every other optimisation while a price cut does not.

The third force is the one that makes the first two urgent. A customer-service exchange that once cost $0.04 now involves tool retrieval, planning and subagents that turn it into a $1.20 orchestration, a thirtyfold increase driven by workflow complexity rather than by any change in price - EY. At the same time OpenAI's own inference costs are reported to have reached $8.4 billion in 2025 with a projection toward $14.1 billion in 2026 - Sacra. Both sides of the market are absorbing rapidly rising absolute costs against rapidly falling unit costs. That combination historically resolves in one of two ways: either efficiency improvements outrun consumption growth and margins recover, or pricing shifts away from consumption entirely.

The second resolution is already visible at the edges, and it is the most likely direction for the next twelve months. Customer support platforms already price per resolution rather than per token. Cognition prices Devin in Agentic Computing Units that bundle inference, virtual machine time and networking into one metered unit. Anthropic's managed agent product bills session runtime at $0.08 per session-hour alongside tokens - Anthropic. Each of these is a step away from the token as the unit of account, toward something closer to a unit of work. That is what customers actually buy, it is the unit this entire guide has argued you should manage against, and the vendors that price in it will be much easier to budget for than the ones that do not. Our broader treatment of that shift is in the economics of digital labour.

The counterargument deserves airing, because outcome pricing is not obviously better for buyers. A per-resolution or per-task price bundles the vendor's margin into a number you cannot decompose, which removes exactly the visibility that lets a team apply the levers in section eleven. Published per-resolution rates in customer support already span $0.50 to $2.00 for the same unit of value, a fourfold spread that suggests the price reflects vendor positioning at least as much as underlying cost. Token pricing is harder to budget and easier to audit. Outcome pricing is the reverse. The mature answer is probably to buy outcomes where the workload is commoditised and buy tokens where it is differentiating, which is the same conclusion most industries eventually reach about outsourcing anything.

Conclusion: manage the conversion rate, not the rate card

GPT-6 Astra lists at $10 per million input tokens and $50 per million output tokens, and that pair of numbers explains very little about what it will cost you. The measured range for one completed coding-agent task is $1.41 to $4.72 depending on a single parameter, roughly 90% of the tokens in that task are cache reads priced at a tenth of the headline rate, one request crossing 272,000 tokens reprices the entire call, and the human who reviews the output may cost five times the model that produced it. The rate card is the least variable term in the equation.

The decision framework compresses to four questions. How long is the loop, because loop length multiplies everything. What is the cache hit rate, because it sets the real price of nine tokens in ten. What is the success rate, because cost per completed task goes vertical below 50%. Who checks the work, because human review is frequently the largest line item and it is the one the model's reliability actually moves. Answer those four for each workflow and the model choice mostly answers itself.

On the evidence available in September 2026, Astra is the more expensive model per token and, against every frontier competitor measured, the cheaper model per finished task, because it finishes tasks in a third to a fifth of the tokens. That advantage is real, it is independently measured, and it is fragile: it survives only if you keep the effort dial where the work needs it, keep the cache prefix stable, and keep requests under the context cliff. Get those three wrong and you will pay frontier prices for a loop that a mid-tier model would have run more cheaply. Get them right and the premium is one of the better-justified ones in the market.

Whatever you conclude, instrument it. Cost per completed task, cached-to-uncached token ratio, and success rate belong on the same dashboard as latency and error rate. Every optimisation in this guide is invisible without them, and every surprise invoice described in section twelve is detectable with them. That instrumentation is a week of work and it will outlive this model, the next one, and every rate card either of them ships with.

This guide reflects GPT-6 Astra pricing and the agent model landscape as of September 8, 2026. Model prices, promotional rates and benchmark results in this category change monthly, and at least two rates cited here have scheduled changes, so verify current pricing against each provider's own documentation before committing to a budget.