The cost of an Opus-class AI worker has fallen off a cliff

On 5 February 2026, Anthropic released Claude Opus 4.6, a premium model aimed at difficult professional work, long-running agents and serious software engineering. Its API price matched that positioning: $5 per million fresh input tokens and $25 per million output tokens, with cached reads discounted by 90 percent.¹

Less than six months later, DeepSeek was charging approximately $0.14 per million fresh input tokens and $0.28 per million output tokens for V4 Flash, with cache hits priced at $0.0028 per million. A 31 July post-training update placed the model in roughly the same broad benchmark region as Z.ai's GLM-5.2 and OpenAI's GPT-5.6 Luna.²³

Under a standard cache-heavy token mix, the price of this capability class fell from $3.85 to $0.058 per million tokens. That is a decline of approximately 98.5 percent—a 66-fold reduction—in 177 days.

It is a striking number. It is also easy to misunderstand. The models are not identical; benchmark suites changed during the period; token prices are not task prices; reasoning models vary wildly in verbosity; and "Opus 4.6 class" is not an official category.

The chart is therefore not a declaration that a DeepSeek token is interchangeable with an Opus token. It measures the collapse in the market price of a particular operational role: the primary reasoning engine inside a code-using business agent.

What counts as "Opus 4.6 class"?

The category is defined by a job, not a parameter count.

An Opus-class model is capable of serving as the primary reasoning engine for a durable, code-using business agent—one that must sustain a multi-step job involving software, tools, private data and imperfect intermediate results.

That definition is deliberately stricter than "good chatbot" and broader than "scores 50 on a benchmark". A qualifying model needs several kinds of competence at once.

Reasoning under ambiguity

Business tasks rarely arrive as clean benchmark questions. Requirements may be incomplete, records may conflict and the agent may need to discover what is missing before it can proceed. A small extraction model can be excellent within a narrow envelope and still fail as soon as the task requires judgment.

Repository-scale software work

Generating a standalone function is not enough. A code-using agent may need to locate the relevant parts of an unfamiliar repository, preserve local conventions, coordinate changes across several files, run tests, interpret failures and revise its approach. This is software maintenance, not autocomplete.

Tool discipline

The model must produce valid calls, preserve state through the observation-action loop, distinguish intended actions from completed actions and verify the result before declaring success. Models that sound intelligent in conversation can become unreliable when connected to a shell, database, browser or deployment system.

Long-context continuity

The models in this comparison generally expose context windows around one million tokens. A large advertised window does not guarantee perfect recall, but it changes what can fit inside an agent's active workspace: policy, tool schemas, memory, repository maps, documentation, current task state and previous tool results.

Economic viability as the normal worker

The final criterion is commercial. A frontier model can be reserved for an exceptional architecture decision or a high-consequence review. The tier examined here is the model that can plausibly perform the bulk of a capable agent's ordinary work.

Why begin with Opus 4.6?

The history could begin with Opus 4.5 in late 2025. Opus 4.6 gives a cleaner boundary: it arrived in early February, was explicitly positioned around complex professional and agentic work, and performed strongly in contemporary evaluations of coding and real-world knowledge tasks.⁴

The historical claim is modest: in February 2026, Opus 4.6 was a defensible choice for a difficult code-using agent, and it was priced as a premium flagship.

That does not imply that DeepSeek 0731 behaves exactly like Opus 4.6. It means that six months later a much cheaper model had entered enough of the same operational territory to compete for the same work.

Two definitions of equivalent capability

A historical series can be built in two ways. Both have defects.

Constant benchmark capability

The strict approach selects models within a narrow range on one current benchmark. On the present Artificial Analysis Intelligence Index, GPT-5.5 high, GLM-5.2 max, Luna max and DeepSeek V4 Flash 0731 max occupy roughly the 50–53 band.⁵⁶

That gives a clean constant-score series beginning with GPT-5.5 in April. The problem is that benchmark suites, effort settings and evaluation harnesses evolve. A current score is not a perfect time machine. Applying today's yardstick retrospectively can make the model that led the market in February appear never to have belonged in the category.

Constant operational role

The second approach asks which model a serious developer would plausibly have selected for this job at the time. That produces the lineage used here:

Claude Opus 4.6 → GPT-5.5 → GLM-5.2 → GPT-5.6 Luna → DeepSeek V4 Flash 0731

This is less mathematically tidy but more faithful to an actual procurement decision. The article uses operational equivalence constrained by benchmark evidence, rather than pretending that an aggregate score captures every relevant behaviour.

The six-month sequence

Claude Opus 4.6: 5 February

Opus 4.6 began the period as a premium proprietary model for difficult professional and agentic workloads. The relevant prices were $0.50 per million cached-input reads, $5 for fresh input and $25 for output. Its strength came with high total task costs: both the rate card and the volume of reasoning output mattered.

GPT-5.5: 23 April

GPT-5.5 provides the first especially clean current-benchmark match. Its high-effort configuration sits around 53 on the present Artificial Analysis index, but its $5 input and $30 output rates did not lower the category's price.⁷

Its place in the sequence is useful precisely because nothing became cheaper: through late April, this capability still carried American-flagship pricing.

GLM-5.2: 16 June

GLM-5.2 was the first large discontinuity. Z.ai released an open-weight mixture-of-experts model aimed at long-horizon tasks, with a one-million-token context and strong coding and agent performance.⁸

Its rates were approximately $0.26 per million cached tokens, $1.40 for fresh input and $4.40 for output. Artificial Analysis scored the maximum-reasoning configuration at 51 and reported roughly $0.46 per weighted task.⁹

GLM also showed why a rate card is only half the economics. It could generate far more reasoning output than GPT-5.5 while solving the evaluation suite. Cheap tokens do not automatically make a cheap task.

GPT-5.6 Luna: 9 July, then 30 July

OpenAI launched Luna as the cost-sensitive member of GPT-5.6 at $0.10 per million cached tokens, $1 for fresh input and $6 for output.¹⁰

Three weeks later, OpenAI cut those prices by 80 percent, to $0.02, $0.20 and $1.20 respectively. The model did not become cheaper because a successor replaced it; the same product became five times cheaper less than a month after launch.¹¹

That is unusually direct evidence of a market repricing in real time.

DeepSeek V4 Flash 0731: 31 July

DeepSeek's post-training update pushed the rate lower again. The official API priced cache hits at $0.0028 per million tokens, cache misses at $0.14 and output at $0.28. The model supports a one-million-token context, structured JSON and tool calling.¹²

The "Flash" name would once have implied a visibly compromised lightweight model. Here it described a sparse model competing in a capability region occupied weeks earlier by an open-weight flagship.

Method one: a normalised token basket

Comparing only fresh-input prices would be misleading. A durable agent pays for at least three classes of token:

• stable context retrieved from cache;
• fresh input added during the current step;
• generated reasoning and answer output.

Artificial Analysis commonly normalises prices using a blend of 70 percent cache-hit input, 20 percent fresh input and 10 percent output.¹³ The formula is:

This is not a prediction of every application. It is a standardised basket. A one-shot chatbot with no cache reuse will do worse; a durable agent with a stable prefix may do better.

Worked example: Opus 4.6

Applying the same arithmetic to every model gives:

For DeepSeek:

The decline is therefore:

Or, expressed as a multiple:

The assumptions inside the 98.5 percent

The calculation is reproducible. It is not neutral.

It assumes cache hits

Providers differ in how prefixes are matched, how long caches persist and whether writing a cache carries an additional charge. An agent that puts stable policy and tool definitions at the beginning of its prompt may achieve excellent reuse. One that continually rewrites the prefix may not.

It treats tokens as fungible

One model may finish in 5,000 generated tokens while another consumes 40,000. A cheap output token is useful only if the model does not compensate by producing many more of them.

It ignores long-context surcharges

Some providers charge higher rates after a prompt crosses a context threshold. A one-million-token window does not necessarily mean every token within it is billed at the short-context headline price.

It ignores failures and retries

A model costing one-tenth as much per attempt is not cheaper if it fails often enough to require repeated calls—or a developer to repair the result.

Method two: approximate cost per task

Artificial Analysis's task-cost measure attempts to account for actual token consumption. Conceptually, it adds the charges for fresh input, cache hits, cache writes, reasoning output and answer output for each benchmark component; divides by its task count; and applies the component's weight in the overall index.

This is more useful than a rate card because it penalises verbosity. It is still not literally the price of fixing a Jira ticket.

The historical series is not homogeneous

The lower infographic deliberately distinguishes three kinds of evidence:

• Published task costs, where the evaluator reported a direct figure;
• Repriced traces, where observed token use can be recalculated after a uniform rate cut;
• Historical estimates, where benchmark versions and reporting formats prevent a clean direct comparison.

These figures should not be read to the third decimal place. The suite, weighting and model configurations changed, and the newest DeepSeek result underwent early cache-accounting corrections. The defensible conclusion is the order of magnitude: the cost of attempting a weighted benchmark task at this broad capability level appears to have fallen by roughly 96–97 percent.

Verbosity is the hidden economic variable

GLM-5.2 demonstrates the problem vividly. Its $4.40 output rate was less than one-sixth of GPT-5.5's $30. But Artificial Analysis reported roughly 140 million output tokens for GLM across its index evaluation, compared with about 43 million for GPT-5.5 high.¹⁴

On output charges alone:

GLM still cost less, but the output advantage was around twofold—not the nearly sevenfold ratio implied by the rate cards.

The economically relevant expression is:

For production, human review and rework must be added. A five-cent agent run that creates 15 minutes of developer cleanup is not a five-cent result.

Why durable agents benefit disproportionately

A persistent code-using agent has an unusually cache-friendly prompt shape. It may carry a stable prefix containing identity, policy, tool definitions, repository overview, durable memory and security rules. Each step appends new files, tool outputs and task state.

Consider a simplified 20-step job in which each step contains 150,000 cached tokens, 25,000 fresh input tokens and 8,000 output tokens. Ignoring cache-write charges, long-context adjustments, tool fees and retries:

Opus 4.6

Twenty steps: approximately $8.

Repriced Luna

Twenty steps: approximately $0.35.

DeepSeek 0731

Twenty steps: approximately $0.12.

This is an illustration, not a measured benchmark result. It shows why the economics matter structurally. At Opus pricing, developers have an incentive to suppress turns and minimise verification. At DeepSeek pricing, the system can afford another test pass, a critic model, more repository inspection, careful memory updates and retries using alternate strategies.

The savings need not all become margin. Some can buy reliability.

Why did prices fall so quickly?

No single mechanism explains the curve.

Sparse mixture-of-experts models

GLM-5.2 and DeepSeek V4 Flash are mixture-of-experts systems. GLM has hundreds of billions of total parameters but activates only a fraction for each token; DeepSeek's V4 Flash model card describes roughly 284 billion total parameters and about 13 billion active.¹⁵

Active parameter count is not a complete invoice calculator—attention, memory bandwidth, expert routing, batching, numerical precision and hardware utilisation all matter—but sparse activation allows broad learned capacity without evaluating the whole network for every token.

Open-weight hosting competition

Open weights separate the model from the provider. Multiple companies can compete to serve the same model using lower precision, better batching, custom kernels, speculative decoding, different accelerators and thinner margins. The serving stack becomes a competitive product of its own.

Cache economics

For durable agents, cache pricing can matter more than the headline fresh-input rate. DeepSeek's cache-hit rate makes carrying a large stable prefix almost negligible relative to the rest of the loop. Luna's cut similarly transformed the economics of repeated context.

Strategic pricing

OpenAI attributed its cuts to improved efficiency. The timing also moved Luna much closer to a price frontier being reset by Chinese open-weight models. It is reasonable to describe the market behaviour as a price war without pretending to know any company's unpublished internal motivation.

What does not belong in the class?

A cheap model does not qualify merely because it has a long context window or performs well on short-answer tests. It must demonstrate sustained planning, repository work, reliable tool use and recovery from failure.

Conversely, materially stronger systems belong in an escalation tier. Combining every frontier model into this comparison would hide the phenomenon being measured: one previously premium level of capability is becoming cheap.

API behaviour matters as well. A model can possess enough abstract intelligence and still be unsuitable because its structured output is unreliable, its tool protocol is awkward or its provider lacks the required security and operational controls.

How to measure the class in production

Public benchmarks identify candidates. They do not select the production winner.

An internal test set should contain complete jobs drawn from actual traffic: a bug spanning several files; an ambiguous support request requiring private research; a configuration change that must be verified safely; a failed tool call requiring recovery; an instruction that must survive a long execution; and a task the model should escalate rather than bluff through.

The primary economic measure should be:

Results should be separated by task type. A model may be an excellent default for research and routine maintenance while requiring escalation for architecture, security or unfamiliar debugging.

The likely result is a routed workforce

The collapse does not imply that every agent should use DeepSeek—or any other single model. It makes routing more attractive.

A practical hierarchy uses deterministic code or a tiny model for extraction and classification; an economical Opus-class model for ordinary autonomous work; a stronger model after repeated failure or detected ambiguity; and a premium model or human for high-consequence review.

The objective is not the cheapest individual call. It is the cheapest reliable path to a verified result.

A capability threshold is becoming infrastructure

The easy reading of the chart is that tokens became 98.5 percent cheaper.

The more important development is that a useful threshold of autonomous software capability is moving from premium service to commodity infrastructure.

The transition happened in four steps:

1. Opus 4.6 and GPT-5.5: American-flagship capability at roughly $4 per blended million tokens.
2. GLM-5.2: similar operational territory below $1.
3. Repriced Luna: the category below 20 cents.
4. DeepSeek V4 Flash 0731: approximately six cents first-party, with competitive hosting potentially lower.

The frontier itself remains expensive. Labs will keep building stronger models and charging premium rates. But the frontier leaves a wake: a capability first appears in a flagship, then moves into balanced products, open weights, competing hosts and commodity services.

For code-using business agents, this transition took 177 days.

In February, selecting an Opus-class worker was an architectural commitment with a visible operating cost. By August, the same broad reasoning tier was cheap enough to run continuously, verify aggressively and route dynamically.

Six months is no longer a normal AI procurement cycle.

It is an economic era.