Maximize Value, Not Intelligence

Prices collapsed. Value skyrocketed. Here is what to actually buy.

In December 2023 we wrote about a text classifier that did not work as a business.0 The requirement was 95% accuracy at under $200 per million classifications. GPT-4 hit the accuracy easily and cost about $1,700 per million. A great demo and a dead venture.

The fix was not a better model. It was a worse one. We went down the ladder—GPT-3.5, then Ada 2 embeddings with logistic regression, then BERT running free in a Colab notebook—and only stopped at Word2Vec, where accuracy fell far enough that the remaining savings stopped being worth it. The thesis was use the dumbest model that the problem will bear, and the only way to find that point is to go one step too far and come back.

Here is that argument as it appeared in 2023, in one chart—the same four models, ranked by the only number that mattered:

GPT-4 is the most capable model on that chart and the only one that loses money—about $1,500 per million classifications. The winner was the least sophisticated model that still cleared the accuracy bar, and it happened to be free.

That discipline still holds in 2026. But two things changed underneath it, and together they changed what the question even is.

The other half of the ratio

Our companion piece measured one term: the price of a fixed level of coding capability has been falling roughly 5× to 10× per year.0 That is the denominator.

Value is capability divided by cost, and the numerator moved too. The cheap tier did not merely get cheaper—it got good. That is the difference between a discount and a windfall. A discount lets you do the same work for less. A windfall changes which work is worth doing at all.

This article is about collecting the windfall: which providers to buy, how to route between them, and—the part that actually matters—which jobs in your project and your business just crossed the line from "not worth automating" to "obviously worth automating."

That is what the windfall looks like plotted against time: the MIT paper's estimated annual decline in the price of a fixed benchmark score, inverted into a capability-per-dollar index. It is not a claim that models got 10× smarter on their own—the denominator moved while the benchmark bar stayed put.

There is a scoreboard now

In 2023 you had to build the cost-versus-accuracy chart yourself. In 2026 somebody publishes it.

BenchLM's coding-value leaderboard divides each model's weighted coding score by its output-token price, which surfaces capability per dollar instead of capability alone.0 Ranked that way, the leaderboard you have been reading is nearly upside down.

BenchLM's raw list of 84 models is topped by names you would never actually run: sub-15B-parameter models scoring in the 20s and 30s on coding, cheap enough that dividing by their price makes the ratio enormous. That is a real ranking artifact, not a buying recommendation—a model that cannot hold together a multi-file change is not a value pick at any price. Restricted to models with a coding score that clears a usable bar for real repository work, here is the same leaderboard as of August 2026:

Value score = weighted coding score ÷ output price per million tokens. Source: BenchLM coding-value leaderboard, verified August 17, 2026.

That rising curve is the trend. This next chart is a single frame from it—the models you are actually choosing between in August 2026, not a timeline:

The values climb steeply as you move down the cost ladder. Sol is among the best raw coders on BenchLM and ranks 73rd by value; Luna gives up about 7% of Sol's raw coding score and returns roughly 23× the coding capability per dollar. Anthropic's ladder tells the same story upside-down: Fable 5 leads the Claude coding ranks and still scores only 1.6 on value ($50 output), while Haiku 4.5 at $5 output lands at 9.3—better than Sonnet or Opus on this index, and still nowhere near Luna. That gap is the story: coding value per dollar is rising fast across the board, and Luna is the recent standout—especially after OpenAI cut its price.

On July 30, 2026, OpenAI cut Luna by about 80% to $0.20 input and $1.20 output per million tokens, trimmed Terra by about 20% to $2 and $12, and left Sol untouched at $5 and $30.0 A 25× price gap between the cheap tier and the flagship is not a rounding error in your routing policy. It is the routing policy.

Note what happened to the middle. On this scoreboard Terra is dominated: Luna beats it on coding score and costs a tenth as much. A balanced tier that is worse and pricier than the budget tier is not a compromise, it is a default you should stop accepting.

Flash-Lite is dominated too, and by a wider margin—Luna beats it on both coding score (73.0 vs. 41.9) and price ($1.20 vs. $1.50). The Claude and OpenAI flagship tiers cluster at the bottom of the value index; the budget tier at the top is where the numbers moved in 2026.

Don't optimize the wrong ratio

Now the correction, because a naive reading of that table will cost you money.

BenchLM says it plainly: value rankings favor cheap models even when absolute performance is modest. That is exactly why the raw leaderboard needed filtering before it was worth a table above—divide by a small enough price and almost anything looks like a bargain, including models nobody should point at a real repository. But the correction goes one layer deeper than “exclude the toy models.” Even restricted to models that can hold a real repository together, a bare Score/$ ranking is a starting point, not a shopping list.

This is exactly the 2023 lesson, and it is worth being precise about it, because it is usually remembered wrong. We did not choose BERT because it was the cheapest. We chose it because it was the cheapest thing that still cleared the bar. Word2Vec was cheaper still and we rejected it. The bar came first; the price optimization happened underneath it.

Score-per-token is a discovery tool. It tells you which models deserve a trial. It is not the metric you run your shop on, because it ignores everything that happens after the tokens are billed: retries, tool calls, test runs, and your own attention. The metric that matters is accepted changes divided by the sum of model cost, tool cost, and human repair time.

Which means four numbers, tracked per model and per task class:

• Merge rate — did the agent produce a change you accepted without major repair?
• All-in cost per accepted change — not token cost. Include retries and sandbox time.
• Human minutes per accepted change — usually the largest term, and the one nobody logs.
• Escalation rate — what fraction of tasks fell through the cheap tier to an expensive one?

A model that is 6× cheaper and leaves you fifteen minutes of cleanup is not cheaper. In 2023 we ran an evaluation set and read the cost-per-million off a chart. The 2026 equivalent is instrumenting your actual workflow, because agent cost is task-shaped, not token-shaped.

Two tiers, and when to leave one

Once you exclude the toy-scale models and the two dominated ones, the market sorts itself into two tiers and the routing rules fall out.

Value (Luna today) is where almost all real repository work belongs. It is strong enough to navigate a repo, run tests, and iterate, and cheap enough that you do not think before running it. This is your default, and for most solo developers it is the whole story.

Premium (Sol, the top Claude variants) buys the highest absolute completion rate. Reserve it for tasks whose expected failure cost is high: ambiguous specifications, cross-cutting architecture, fragile migrations, security-sensitive changes.

There is no useful ultra-cheap tier sitting below Luna—not because cheap models do not exist, but because the ones cheap enough to matter are not good enough to trust with a real change, and the ones good enough to trust are Luna or better. If you find a genuine exception—a narrow, high-volume, low-stakes job where a smaller model clears your bar and Luna is overkill—route it there. Do not go looking for one on the strength of a leaderboard rank alone.

Terra, Flash-Lite, Kimi K3, GPT-5.3 Codex: dominated on value — skip unless the task demands it.

The cheap tier's cost advantage is enormous enough to absorb a lot of failure. At a 25× price ratio, you can run roughly twenty-four Luna attempts before you have spent what one Sol attempt costs. Five retries on the cheap tier costs about a fifth of one attempt on the flagship.

But do not read that as permission to retry blindly, because retries are not independent. A model that took a wrong path will happily take it again unless something in its input changed. The policy that actually works is a bounded repair loop that changes state: feed the failing test output, feed the diff it just produced, feed the compiler error—then try again, at most two or three times. Escalate on an objective signal, not on a feeling: CI still red, tests still failing, no measurable progress between attempts, changed-file count blowing past a threshold.

And skip the ladder entirely when the task announces itself as hard. Ambiguous, architectural, and security-sensitive work should start at the top. The cheap-first default is a policy for the bulk of your queue, not a religion.

What to actually buy

The durable framework is four moves in order: tier, route, cache, measure. Tiering and routing are above. The other two are where solo developers leave the most money on the table.

Buy on your variance, not your peak

The most important thing to understand about 2026 pricing is that flat-rate subscriptions are quietly being re-metered.

April 2026 was the turn. GitHub restructured its individual Copilot tiers and paused new signups on April 20, moving premium model access behind multipliers and more restrictive tiering. Cursor pushed frontier models behind Max Mode for legacy Team and Enterprise plans. And Anthropic cut the server-side prompt cache TTL from one hour to five minutes—no price change on paper, but long coding sessions now rebuild context far more often, and you pay for every rebuild.0

That last one is the tell. The most consequential price increase of 2026 was a cache setting, not a price.

So when a plan says "flat rate," find out which of three things it means:0

• Metered with rolling windows — Claude Pro/Max, ChatGPT Plus/Pro, Cursor Pro. A subscription price with session or weekly limits that agentic workloads exhaust quickly.
• A capped value multiplier — DevPass, Cursor Ultra. Your subscription buys roughly two to three times its price in provider-rate usage, and then it stops. This is a discount, not unlimited.
• Genuinely unlimited — Featherless, Standard Compute. Real, but open-weight models only, with concurrency and context restrictions.

The buying rule: pay for variance, not for peak. If your usage is steady and daily, a subscription converts an unpredictable bill into a fixed one and that is worth real money. If your usage is bursty—three heavy days a month—metered API tokens through an aggregator will beat any subscription, because you are not paying for the twenty-seven quiet days.

For a single-model shop, a single-vendor plan is hard to beat. Z.ai's GLM Coding Plan runs about $18, $72, and $160 per month for Lite, Pro, and Max, discounted roughly 10/20/30% for monthly, quarterly, and yearly commitments, with allowances of about 80, 400, and 1,600 prompts per five-hour window respectively. It drives Claude Code, Cline, and Roo Code directly.0 That is near-frontier coding quality at a price that used to buy autocomplete.

Caching is the biggest lever you are not pulling

Agent loops are input-dominated. Stanford's Digital Economy Lab named this the "pricey context snowball": the agent re-sends a growing context window on every step, and a fifty-turn session can run a 25:1 ratio of input to output tokens.0

Cached input costs roughly a tenth of fresh input. Since input is the dominant term, cache discipline moves your bill more than model choice does—and it is free. Keep a stable prefix (system prompt, project conventions, file tree) at the front of the context so it stays cacheable, and stop reordering it between calls. Do the long session in one sitting rather than three, now that the TTL is five minutes and not an hour.

The orchestration layer matters for the same reason. Holding the model constant, a July 2026 paper found that swapping in a better harness cut cost per task by 41%—more than switching between the cheapest and most expensive model did.0

And for anything that does not need an answer right now—the whole chore catalog below—batch it. OpenAI's Batch and Flex processing runs at half rate, which puts Luna at $0.10 input and $0.60 output per million.0

What we'd buy today

Timestamped deliberately. This table is accurate as of August 2026 and will rot. Re-check it quarterly—the whole point of the price collapse is that the right answer keeps moving.

Two non-obvious calls there. The first is skipping the middle tier: if your cheap tier fails, the evidence that made it fail is usually enough to justify going straight to the top rather than paying twice on the way up. The second is pinning the model by hand, which deserves its own warning.

"Auto" is not a synonym for "cheap"

It is natural to assume the router modes are the frugal choice. Read the pricing page before you assume it.

In Cursor, Auto mode is on Pro plans—but only Auto Cost charges a flat rate regardless of what it picks. Auto Balance and Auto Intelligence bill at the selected model's real API rates, plus a Cursor Token Rate of $0.25 per million tokens whenever the pick is a third-party model—often 2–4× more expensive than pinning Composer 2.5 or Luna yourself. The Cursor Router—the deeper request-classification system on Teams and Enterprise—is not what individual Pro users get.0

Read that again in buying terms: Auto is a mode that is willing to spend more on your behalf, with a markup. It is a convenience feature, not a savings feature, and for an individual developer it can comfortably cost more than pinning a model yourself.

Pinning is not hard, and it is the whole discipline of this article in one setting. Composer 2.5 at $0.50 input and $2.50 output scores 21.1 on the value index—rank #25, ahead of GLM 5.2 and every US flagship tier. Luna is cheaper still on output at 60.9. GLM 5.2 and Kimi K2.5 are credible third choices if you want a single-vendor API or an open-weight path. Pick one for the bulk of your work, escalate to Sol or K3 when the task justifies it, and never default to Codex or Terra just because the tool suggested them.

The general rule generalizes past Cursor: any feature that picks the model for you is a feature that can pick an expensive one. Find out whether it is optimizing for your bill or for your satisfaction, because those are different objectives and only one of them is yours.

The jobs that just crossed the line

Here is where the value boom stops being a smaller invoice and starts being a different business.

In 2023, the classifier had a break-even: $200 per million. Below that it was a venture; above it, a demo. Every chore on your backlog has the same structure. It is worth automating when the all-in agent cost plus your review time comes in under the value of the thing simply getting done—and for a long list of jobs, that number just went from "no" to "obviously yes" without anyone announcing it.

These are not glamorous. That is the point. They are the work that is perpetually valuable and perpetually last in the queue.

Nobody announces the crossing. You just notice the backlog stopped growing.

The second crossing: automation you build on automation

The chart has a second panel for a reason. Price explains the first row of that list and none of the second.

Automated penetration testing was never one price cut away. Neither was continuous threat intelligence. What both needed was a current, machine-readable map of how data actually moves through your system—which services touch which data, which flows cross a trust boundary, where personal data comes to rest. Nobody maintained that by hand. The diagram was stale the week after the offsite, so the work that depended on it stayed theoretical no matter what tokens cost.

Once mapping your data flows becomes a chore an agent does on every merge, it stops being a document and becomes an interface. A pen-test agent that can read the current flow map does not have to guess where the trust boundaries are—it gets told, continuously. Threat intelligence stops being a firehose of advisories and starts being a filter: this CVE touches that service, which sits on the path to the customer records, so it matters this week and the other four hundred do not.

That is the compounding. The first automation produces an artifact. The artifact is what makes the second automation possible. And the second one produces artifacts of its own—a current inventory of reachable attack surface, a ranked list of what is actually exposed—that a third layer can stand on.

The sharpest version of this is the emergency case, and it is a genuinely different thing from the routine one. Automated dependency upgrades are a convenience: a bot opens a PR, CI runs, you merge it Thursday. Automated emergency response is a capability—an agent that wakes at 3 a.m. to a zero-day in a package three levels deep in your tree, determines from the flow map whether the vulnerable path is actually reachable in your system, and either ships the patch or makes the call to take the affected service offline until a human is awake. That decision needs the dependency graph, the data-flow map, and the reachability analysis to all already exist, maintained, current. Each was somebody's abandoned side project until the cost of keeping it current fell through the floor.

Which is the part worth internalizing: the interesting jobs are usually not the ones that got cheap. They are the ones that got possible, because something underneath them got cheap first. When you are deciding what to automate next, the question is not only "what does this save me"—it is "what does having this, current and machine-readable, let me build on top of it."

When the agent starts writing the backlog

Everything above is defensive. Triage, patching, quarantine, drift—work that keeps the lights on and you out of trouble. Worth automating, and none of it changes what your company is.

The thing worth paying attention to is not defensive at all.

The pattern goes like this. An agent reads your customer communications—support tickets, sales calls, churn interviews, the feature requests buried in threads nobody re-reads—and does what a product owner does with them. It notices that the same friction got described five different ways by five different customers. It turns that into a proposal. It ranks the proposals by the value they would unlock against what they would cost to build. Then it builds the top few. The product owner wakes up to a list of features that already exist, waiting to be approved.

Look at what has to be true underneath for that to work. The customer conversations have to be somewhere an agent can read them. The codebase has to be navigable. The test suite has to be trustworthy enough that an unattended change can actually be believed. That is the same compounding again: this is not one clever product, it is four boring capabilities that each stopped being expensive, stacked.

And look at where the human went. Not out of the loop—up it. The judgment being asked of a product owner in that loop is no longer "write this ticket" or "groom this backlog." It is "was this the right thing to build." That is a harder question and a more valuable one, and it is the only part of the job that was ever really theirs.

This is the direction the whole shift points. First the agents did the chores. Then they decided which chores were worth doing. Now they are starting to propose the work itself—and the scarce thing is no longer the labor, it is knowing which proposals deserve a yes.

Documentation is the cleanest example because the tooling already exists. Tools like Scribe read a codebase's structure from the code graph, regenerate an accurate AGENTS.md, and open a merge request when the docs have drifted—then keep watching and open another one next time.0 The pattern generalizes to every row above: a trigger, a bounded agent task on the cheapest tier that clears the bar, and a pull request a human looks at.

That last clause is not decoration. None of this auto-merges. The productivity lands in the gap between "nobody had time" and "somebody reviewed it," and deleting the review does not widen the gap—it just moves the failures into production.

The work nobody had time for, finally getting done.

The same shift scales past one person's chores. A clinical-trial matching product is run by a single operator with four standing Claude Code sessions against a shared backlog: one that prioritizes, one that watches traffic and files content tasks, and two working engineering tasks in parallel.0 The interesting part is not the parallelism. It is that a one-person business now has roles.

What $20, $100, and $500 actually buy

Concrete stacks, same caveat as the pick table—accurate August 2026, re-check quarterly. The "can't do" column is the honest one.

The failure mode at every tier is the same, and it is not overspending. It is buying capacity you have no ability to review. Three agents producing pull requests faster than one person can read them is not three times the throughput—it is a queue with a person at the end of it.

The security tax

Every row in that catalog is a new non-human identity holding credentials to your repository, your cloud, or your inbox. That is not a reason to skip them. It is a line item.

The cheap tier is exactly where the temptation to skip scoping is strongest, because each agent feels too small to matter. Recent work on LLM-in-the-loop vulnerabilities found they are consistently harder to repair with automated agents than conventional flaws—an average 10.8 percentage-point drop in Pass@1 repair rate—and three categories, Generated Query Execution, Agent Action, and Model Output Rendering, frequently come back with 0% repair success across most agent–model configurations.0

Scope each agent to the minimum access its job needs, treat everything it ingests—error logs, issues, docs, web pages—as untrusted input to a privileged executor, and keep an inventory. We take this up properly in the companion piece: Bugonomics: The Flip Side of Cheap Coding.

The Jevons resolution

Our first companion ended on an honest catch: cheaper coding does not lower your bill, because the cheapness is what makes the larger workflow affordable enough to depend on. Total spend rises even as unit price falls.

That is true, and here is the resolution. If value per dollar rose 20× and your spend rose 3×, you won. Spending more is frequently the correct response to a price collapse—it is what "the same budget now buys a team" means in practice.

The failure mode is not spending more. It is spending more without measuring the return—which is precisely the 2023 mistake, the one where you ship a beautiful GPT-4 classifier and never check the cost per million until the invoice arrives. The four metrics above exist so that "we spend more on agents than we did last year" is a sentence you can finish with a number instead of a shrug.

The shift in one sentence

In 2023 the answer was to find the dumbest model the problem would bear and stop paying for the rest. In 2026 that is still the answer, with two amendments: it is a routing policy now, not a one-time pick, and the real dividend is not a cheaper invoice—it is the pile of work that was never worth doing becoming worth doing.

Buy on your variance. Cache like it is free money, because it is. Default to the value tier and make the frontier opt-in. And spend the savings on the boring, valuable, perpetually-deferred jobs that just crossed their break-even, with a human still reading every diff.

Maximize value, not intelligence.

Companion pieces

• The Year Coding Became a Commodity — why the price of coding capability collapsed, and why the cost curve and the autonomy curve multiply.
• Bugonomics: The Flip Side of Cheap Coding — the same curve applied to breaking software, and the coding agent as an attack surface.
• Maximize Profit, Not Intelligence — the 2023 original, where the ladder only went down.

References