The agent economy, the business of delegating work to autonomous programs, is migrating from per-seat licensing to usage-based billing, and knowing where cost is generated has become a competitive advantage when you need to use AI intensively. According to Gartner, the enterprise coding agent market was billing between $9.8 billion and $11 billion annualized in April 2026, and projections for 2030 put it above $100 billion.
Ana Botín redefines luxury: moving past AI and doing whatever she pleases
What is a harness? Explained without technical jargon
A language model or AI is just a "program" that predicts text probabilistically: it receives a data input and returns a data output. It only responds and stops; it does not read files, does not execute commands, does not correct its mistakes. It is the least intelligent thing you could imagine, however much they call it "Artificial Intelligence."
The "harness" is everything else: the software layer that wraps the model and turns it into an agent capable of doing something. It includes the loop that repeats "reason, act, observe" until the task is finished; the tools the agent invokes (reading a file, running a command, searching the repository); context management, which decides what goes in and what comes out of the memory window; and control mechanisms, such as permissions and budgets. In the words of the documentation for Claude Code: "Claude Code is the harness, and Claude is the model inside."
Claude Code, Cursor, OpenAI Codex, Windsurf, Aider, Cline: all these tools are harnesses. The industry converged on this architecture from the ground up, by solving the same problem: how to get an LLM to edit real code, and a May 2026 O'Reilly report sums it up in a formula circulating through the sector: agent = model + harness.
For our non-technical reader: the model is the engine and the harness is the gearbox, the chassis and the dashboard. Consumption is decided by the dashboard, not the engine.
The harness rules the bill
Evidence that the harness dominates cost comes from several directions in 2026. The cleanest is The Harness Effect, an arXiv preprint from July 8, 2026, which measured 22 tasks across six models, changing only the orchestration layer: with the same model and the same rates, the redesigned harness cut cost per task by 41% (from $0.21 to $0.12), tokens by 38% (from 14,200 to 8,800) and time by 44%, while maintaining quality (0.78 to 0.81). The most uncomfortable finding: the harness moved cost per task more than the choice between the most expensive and the cheapest model.
Databricks reached a similar conclusion with its internal benchmark. The same model, with two different harnesses (Claude Code/Codex versus Pi, the latter an extremely minimal harness), cost more than double per task in some cases, with identical quality. The difference lay in how much context each harness fed in at each step. In the playbook, Databricks adds that a simple adjustment to the harness and the cache cut generated tokens by almost 50%, with no quality degradation.
Why does a human-AI interaction cost what the harness decides?
To understand the scale, you need to know how AI is billed: by tokens, units of text that the model "reads" (input) and "writes" (output). Input costs, on average, about five times less per token than output, but its volume is enormous: PointFive, in its July 2026 index, estimates a typical task at 200,000 input tokens and 30,000 output tokens. Reading, though cheap per token, dominates the bill.
When a human writes "research and fix this bug", that phrase represents an insignificant fraction of the data entering the model: the agent retrieves context from the repository, invokes dozens of tools, integrates company knowledge, performs other tasks with tools if necessary. Thus, the real cost of that interaction is defined by the harness: how much context it injects, how often it compresses the history, whether it reuses cache or re-bills tokens already seen, how much "chatter" it generates. In the end, the user pays for a request they barely wrote; the harness decides what it is worth.
And in that sense, the most powerful component is the prompt cache. Providers bill input tokens served from cache at around 10% of list price. A disciplined harness structures the request into a stable byte prefix (served from cache) and a variable per-turn tail; the "Harness Effect" study measured that 99.9% of input tokens were served this way from cache, paying a tenth of list price. That difference is decided exclusively by how the harness assembles context: the same model and the same work can cost five times more or five times less.
Bitcoin Digital Objects: the standard Bitcoin was missing
Model-harness coupling and the lock-in trap
But if the harness rules so much, can it be changed? The answer is: not entirely, frontier proprietary models are increasingly designed alongside their specific harnesses. Databricks makes it clear: "Certain harnesses work better with certain models." Models are trained, in part, against the harness they are sold with; moving them to a different box can lead to their full capability going to waste.
The economic consequence is direct: a team tied to Claude Code cannot adopt a cheaper model from another provider without changing harness. The switching cost is high, and when it exceeds the savings, the harness becomes a de facto lock-in to a model family. Model independence, the biggest savings lever, requires infrastructure to sustain it.
Companies solve this with two strategies. The first: give developers a menu of harnesses and ask them to switch in order to migrate spending to cheaper models; it works, but the individual switching cost is high. The second, increasingly popular, is the meta-harness: , a layer that offers a common user experience and dispatches requests to different underlying harnesses, proprietary and open source.
Databricks presented its own, Omnigent, an open source project that wraps Claude Code, Codex and Pi in a uniform API, allows them to be combined with one-line changes and applies cost policies, without depending on the model cooperating.
Routing work to the right model
The second big saving comes from deciding which model runs each task. Databricks calls it chasing the efficiency frontier, rather than the intelligence one: the first is the most capable model; the second, the set of models with the best price for a given level of intelligence. Most daily work does not require that level, and that efficiency frontier advances faster than the intelligence one: every week models appear with a better intelligence-to-price ratio.
The playbook describes three patterns. The first is at the request level: a stateful proxy sits between the harness and the models and sends each request to the cheapest model capable of answering it. This is the idea behind Cursor Router, OpenRouter's AutoRouter, Ramp's Router and Databricks' Smart Routing, which according to its data cuts average cost per task by more than 30% while maintaining the quality of the most expensive model.
The second is at the task level, and the meta-harness itself does it: a dispatcher assesses the complexity of the request and delegates the entire task to the appropriate harness. The third is escalation patterns with two models: in Claude's Advisor, the cheap one directs and escalates to an expensive one when needed; in Devin Fusion, from Cognition, the opposite happens, the expensive one directs and subcontracts the cheap one.
The newest and most powerful models are not always worth it
The newest and most powerful model is not automatically the most efficient. Stripe found that Opus 4.7 did not improve quality over Opus 4.6 and cost more; they did not offer it internally. Databricks observed similar regressions when comparing Opus 5.0 with 4.8 and, after evaluating its own benchmark, found that GLM models offered a very competitive price/performance ratio and deployed them.
The lesson is not that one provider is better than another, but that automated evaluation on real tasks, not public benchmarks, is the necessary filter to capture the efficiency frontier. And that capture is lost if the infrastructure does not allow models to be changed fluidly; those who cannot, are left paying yesterday's bill.
CLARITY: the crypto industry's last cartridge to recover lost business
Spend governance: progressive friction instead of caps
On the other hand, DataBricks in its study devotes an entire section to a finding that contradicts instinct: hard budgets do not work. Cutting off access for a developer who has exceeded their cap paralyzes productivity, and the biggest spenders are usually those who extract the most value from AI.
Instead, companies converge on a ladder of progressive friction. First, visibility: each company shows the user their spending in near real time, often with tips on cheaper models.
Second, spend gates: self-dismissable warnings when consumption rises, which require no approval and curb accidental spending, and higher gates that require explicit approval. Third, downshifting: if a developer crosses a gate, they are moved down to a cheaper model instead of being suspended, so they keep working at drastically lower cost. Fourth, and only as a last resort, temporary suspension of AI access.
Databricks applies this in its own Unity AI Gateway, with two coupled budgets: a daily one, small, that catches spending leaks and self-expands with one acknowledgment click, and a monthly one, which requires manager approval, is tied to a project and expires with it. Limits move in steps so that each increase is a real conversation about value; the key is that all agent traffic passes through a single control point: the gateway.
The approach is not exclusive to Databricks. Cerver recounts that Uber tried the opposite approach, a hard cap of $1,500 per engineer per month, and the result of that decision was spending the entire annual AI budget in just 4 months.
A new economic era for AI agents
Putting the pieces together, the agent economy shifts from a question of models to a question of infrastructure. The migration from per-seat billing to consumption-based billing is a fact: GitHub Copilot moved to usage-based AI credits on June 1, 2026, and Claude Code, Codex and Devin accumulate tokens on top of the seat. EY describes the first half of 2026 as a "SaaSpocalypse": per-seat licensing breaks down when the work is done by autonomous agents that never rest, and pricing is heading toward a tiered scheme.
In that world, cost per resolved task becomes the basic economic unit, and the evidence from July 2026 says that unit is governed by the harness. The direction of the sector confirms it: agent SDKs (Claude Agent SDK, Codex SDK, OpenAI Agents SDK) increasingly package the harness infrastructure as a service, and consultancies point to the orchestration layer as the "control point" where value will concentrate. The winning harness may be the one that wastes the least inference: more cache, better compression and intelligent routing.