A Curve Worth Looking At Twice
Every few months someone on the team pulls up the same chart: blended cost per million tokens for a "good enough for production" model, plotted over time. It has been falling since 2023 and it has not stopped.
What's changed recently is not that the line keeps going down — everyone expected that. What's changed is the slope of quality at the low end. Eighteen months ago, the cheapest usable models were meaningfully worse at anything requiring multi-step reasoning. Today, the gap between a frontier model and a fast, cheap model on a well-scoped, single-purpose task has narrowed to the point of being irrelevant for a large share of what agents actually do in production.
The Economics, Concretely
Take a representative AgentDyne workload: a support-ticket classifier that reads an incoming message and outputs a category plus urgency score. It is not a creative task. It does not require deep reasoning. It requires reading comprehension and consistent structured output.
| Approach | Model tier | Cost per 1M calls | P50 latency |
|---|---|---|---|
| Frontier-only (2024 default) | Top-tier flagship | ~$4,800 | 1.8s |
| Frontier-only (2026 pricing) | Top-tier flagship | ~$1,200 | 1.1s |
| Fast-tier (2026) | Cheapest usable model | ~$85 | 0.3s |
Even holding the task and the model family constant, moving from flagship to fast-tier is roughly a 14x cost reduction and a 6x latency improvement, for a task where the accuracy delta between tiers is now within noise on our eval suite.
That is not a rounding error. At meaningful volume, it's the difference between an agent that is economically viable to run for free and one that has to be metered.
Why This Isn't "Just Use the Cheap Model"
The naive conclusion — always use the cheapest model — is wrong, and the reason why is the actual insight. Task difficulty is not uniform within a single agent, let alone across an agent portfolio. A support-ticket classifier is a fast-tier task. The financial risk assessment two steps later in the same pipeline is not.
This is why the trend line isn't "cheap models win," it's model routing wins. The agents climbing the AgentDyne leaderboard fastest right now are not the ones built on the most expensive model — they're the ones that decompose a task well enough to send each sub-step to the cheapest model that can handle it reliably, and reserve the expensive model for the one or two steps that actually need it.
We covered this pattern in depth in our microagents piece, but the cost collapse changes the calculus of *when it's worth doing*. Eighteen months ago, splitting a task into a routed pipeline saved meaningful money but added real engineering overhead. Today the price gap between tiers is wide enough that the overhead pays for itself almost immediately, even on modest-volume agents.
What This Does to Pricing
The second-order effect is on how agents get priced in the marketplace. A builder pricing per-call has to account for the fact that their input cost is now a moving target, and it's been moving in one direction only.
// Naive: hardcode a per-call price and hope margins hold
const PRICE_PER_CALL = 0.02 // set once, six months ago
// Better: price relative to a cost floor that gets recalculated
const marginTarget = 0.65 // 65% gross margin
const estimatedCost = await estimateCallCost(agentConfig)
const pricePerCall = estimatedCost / (1 - marginTarget)Agents priced against a static cost assumption from a year ago are, functionally, pricing themselves out of the market or leaving money on the table — usually the latter, since builders tend to price conservatively and forget to revisit it once the underlying cost has fallen.
What This Means for the Free Tier
There's a reason free-plan quotas across the industry have been quietly rising rather than shrinking, despite usage growth. A free-tier execution routed to a fast-tier model costs a platform a fraction of what it cost when the only viable model was a flagship. The economics of giving away meaningful free usage got dramatically better, not worse, even as usage volume climbed.
This is a genuinely different environment than the one most "AI is expensive to run" intuitions were formed in. Compute budgets that made sense in 2024 are frequently over-provisioned for the same workload in 2026 — worth revisiting rather than assuming they still hold.
The Part That Doesn't Get Cheaper
One thing the cost collapse has not touched: the cost of being wrong. A fast, cheap model that occasionally produces a malformed or subtly incorrect output can cost more in downstream cleanup than the token savings were worth, especially in a multi-step pipeline where an early error compounds.
This is the argument for output schema validation and eval suites being non-negotiable in a cost-routed world, not optional polish. When the cheap path is genuinely ten times cheaper, the temptation to route everything there is strong. The discipline that keeps that safe is exactly the production checklist we've written about elsewhere: schema validation catches drift before it costs you, and an eval suite tells you precisely which steps can safely move down a tier and which can't.
Where This Goes Next
We don't think the cost curve is done falling, and we don't think quality convergence at the low end is done either. The practical implication for anyone building on AgentDyne right now: architect for model routing from day one, even if you start every step on the same model. The switching cost of moving a well-isolated microagent to a cheaper tier later is small. The switching cost of untangling a monolithic prompt to make that possible after the fact is not.