The number that should stop you is not a benchmark score. It is $600 a day.
That is the median spend among researchers using a single coding-agent, according to OpenAI's own disclosure. Not the peak tier. Not a pilot budget. The median. And usage is doubling monthly.
Put those two facts in the same sentence and the software business you have spent a decade modeling quietly breaks apart. We were told AI tooling is a cheap subscription — a $20 line item, a productivity garnish bolted onto headcount. The ledger says something else. At $600 a day, one user runs an annual run-rate near $219,000 in metered spend. That is not a seat. That is a salary. And a salary is not how you price software.
I have audited capital allocation theses since 2017, when I put 50 ETH into reading whitepapers instead of chasing presales. The lesson then is the lesson now: the number nobody wants to compute is the number that matters. Everyone is watching what the agent can do. Almost nobody is watching what the agent costs.
The coding-agent category matured faster than any developer tool before it. These are not autocomplete engines. They are LLM-driven systems that plan multi-step tasks, call tools, edit files, run terminals, and execute code inside sandboxes. The capability base is borrowed from a handful of frontier models. The differentiation lives in the harness — the agent loop, the tool routing, the context management, the execution isolation.
The named field is crowded. OpenAI ships a coding-agent. Anthropic ships Claude Code. OpenAI ships Codex. Google ships Gemini CLI. Cursor, Devin, and Copilot occupy adjacent ground. On paper, they converge: same model tier, similar interfaces, comparable benchmarks.
For four years, the on-chain compute narrative has promised to commoditize exactly this layer. DePIN networks, decentralized inference markets, verifiable compute — all of them sell the same thesis: computation is a commodity, and the middlemen will be disintermediated. The demand signal inside OpenAI's disclosure is the first hard number that tests that thesis.
The pricing history is instructive. On-premise software sold perpetual licenses. SaaS converted those licenses into subscriptions priced per seat, because value was tied to how many humans logged in. The cloud then broke the seat model for infrastructure, pricing by consumption because value scaled with usage. Coding agents collapse both logics into one product: a human-facing workflow priced by machine consumption. The industry has not decided which metaphor governs it. The meter suggests the answer is being decided for them.
The architecture of trust is built, not inherited. That applies to software pricing too. Seat-based SaaS was a pricing architecture designed for a world where value scaled with humans. The cloud introduced usage-based pricing for a world where value scales with consumption. Coding agents sit exactly at the collision point. The billing model that wins will not be decided by preference. It will be decided by where the cost actually lands.
Start with the unit economics, because they are unambiguous.
At $600 a day, the annualized figure is $219,000 per user. A seat-based developer tool — Copilot, Cursor at the low tier — prices between $10 and $40 per seat per month. Annualized, that is $120 to $480. The gap is not 20%. It is roughly 450x to 1,800x. A spread of three orders of magnitude is not a pricing nuance. It is a different business model wearing the same category label.
The only coherent explanation is metered billing — per token, per API call, per unit of compute consumed. Revenue tracks consumption, not headcount. That reframes the company. A metered coding-agent is closer to a compute reseller than a software vendor. It buys inference and resells it inside a workflow. Its top line scales with tokens burned. Its gross margin is a function of inference cost, cache efficiency, and model-tier selection.
This matters for the whole industry because it inverts the SaaS playbook. SaaS margins are beautiful — 70% to 90% gross, because serving the millionth user costs almost nothing. A metered compute business carries a marginal cost on every single request. Gross margin can be far thinner, and it can compress as usage grows. A revenue line that grows 100% monthly is not automatically good news if the cost of goods sold grows at the same rate. You can scale straight into a loss.
Now look at the mechanics underneath the spend. A $600 day is not a person typing prompts. It is a long-horizon, multi-turn, high-concurrency process. The agent runs for extended periods, holds large context windows, calls tools repeatedly, and retries on failure. Every one of those behaviors multiplies token consumption. The engineering that decides whether this is profitable is unglamorous: prefix caching, KV-cache optimization, continuous batching, speculative decoding. The margin on an agent is written in cache-hit rates, not in benchmark leaderboards.
Consider what a single long-horizon task actually consumes. Planning steps, tool calls, file reads, test runs, error corrections, and retries all sit in the context window simultaneously. Without aggressive prefix caching, the model re-reads the entire history on every turn, and cost grows super-linearly with task length. With caching, the same task can cost a fraction. The difference between a profitable agent and a money-losing one is frequently a caching policy and a context-compression strategy — decisions made by infrastructure engineers, not prompt designers.
That is the first insight most readers will miss. The competitive frontier of coding agents is not intelligence. It is cost-per-completed-task. And cost-per-task is an infrastructure problem.
Which pulls the conversation into the only domain where I actually keep my ledger: compute infrastructure.
Usage doubling monthly is the cleanest demand signal the compute thesis has ever received. If the base is not trivially small, it means inference demand is compounding at roughly 100% per month inside this single product. Multiply that across a category with a dozen serious competitors and the aggregate compute pull is enormous. This is the demand side that decentralized compute networks have spent years waiting for.
So why is a centralized vendor capturing $219,000 annual ARPU while DePIN compute markets still fight for credibility?
The answer is not price. Decentralized compute is often cheaper per raw FLOP. The answer is reliability and workflow lock-in. An agent that edits production files, executes deployments, and runs for hours cannot tolerate a node that drops mid-task or returns nondeterministic results. The harness is where the trust lives. The architecture of trust is built, not inherited — and a decentralized compute market that cannot guarantee task completion will lose to a centralized one that can, regardless of the price tag.
I learned this the expensive way. During the 2020 DeFi Summer, I ran yield strategies across Compound and Aave managing over $200,000 in TVL. The returns looked great on paper. What nearly killed the strategy was not the APY. It was execution reliability — a failed transaction, a mispriced gas estimate, a liquidation that fired because a keeper bot hiccuped. The same discipline applies here. Raw compute price is the headline. Execution reliability is the business.
The distributional consequence is a compute gap. A well-funded lab can absorb $219,000 per researcher per year without blinking. A ten-person startup cannot. That asymmetry does not show up in any benchmark, but it compounds. The teams with capital buy more agent-hours, ship faster, and widen the productivity scissors. The teams without it fall behind on throughput, not on talent. This is the quiet re-centralization of software production — away from distributed talent and toward concentrated compute budgets.
There is a second, quieter cost that almost nobody has priced into the agent economy: settlement and data availability. Every agent action that touches an on-chain component — a payment, an attestation, an identity check, a compute receipt — consumes blockspace. As agents scale, they become a new class of high-frequency, low-value transaction generator.
I hold a specific and uncomfortable view here. Post-Dencun, blob data is cheap. That cheapness is temporary. Blob space will saturate within roughly two years of sustained adoption, and when it does, rollup gas fees will double again. The agent economy is one of the demand sources that will drive that saturation. If you are building an agent that settles on a rollup and you have modeled unit economics against today's blob prices, you have modeled against a subsidy, not a cost. Re-run the numbers at 2x fees. Re-run them at 5x. The agents that survive are the ones whose economics do not depend on cheap data availability.
Now the competitive layer. The coding-agent field has structurally low barriers. Most products sit on the same few frontier models. Differentiation comes from harness engineering — tool quality, context handling, sandbox fidelity, repository integration depth. That is real work, but it is replicable work. It is not a moat in the way a proprietary model would be.
This creates a specific strategic tell. OpenAI chose to disclose usage and spend, not capability benchmarks. That is a narrative shift from "we are smartest" to "we are most used." When a vendor stops competing on ability and starts competing on adoption, it usually means the ability race has been commoditized. The story moved from the model to the meter.
That shift has a cost. High-spend users are exactly the users most attractive to a cheaper alternative — an open-weight model paired with a self-built harness. Stickiness, therefore, does not come from model quality. It comes from workflow lock-in: how deeply the agent is embedded in repositories, CI pipelines, review processes, and organizational memory. The architecture of trust is built into the workflow, not inherited from the model.
The consensus reads OpenAI's disclosure as an AI-capability story. It is not. It is a compute-pricing story, and it exposes a blind spot the crypto industry has been avoiding for years.
The blind spot is this: decentralized compute has been sold as a cost play, when it should have been sold as a reliability play. Everyone assumed the winning argument was cheaper FLOPs. The market is telling us the winning argument is task completion you can bet on. That is a hard problem — verifiability, deterministic execution, graceful failure, slashing for bad results. It is also the problem that separates a real network from a token narrative. The projects that treat reliability as the product, not the pitch, are the ones positioned to absorb agent demand.
There is a second blind spot, and it is about people, not silicon. The disclosure flags human oversight as an open question, and it is being treated as a footnote. It should not be. When usage doubles monthly and spend hits $600 a day, the agent is performing substantive, autonomous work. Oversight does not scale for free — review cost rises linearly with agent output. The likely reality is scale first, govern later, and the risk is automation bias: humans approving agent output faster than they can actually verify it. A coding agent that writes unsafe code, or introduces a subtle supply-chain flaw, produces defects that hide inside code that looks correct. That is a governance problem dressed as a productivity win.
And one more thing the number does not tell you. "Researchers" is an undefined denominator. Self-reported data, no cohort size, no margin, no billing model. If the base is a hundred power users, doubling monthly is interesting but small. If it is ten thousand, it is a structural shift. A growth rate without a denominator is a vibe, not a metric. Treat the direction as real and the magnitude as unverified.
The next narrative is not model intelligence. It is metered compute accountability. The seat-based software model is being repriced in real time, and the winners will be decided by gross margin, cache efficiency, and execution reliability — not by leaderboard position.
Watch three things. First, whether decentralized compute networks pivot from price to verifiability, because that is the only argument that beats a centralized vendor on task completion. Second, whether blob space economics hold, because every agent that settles on-chain is quietly betting against saturation. Third, whether the harness becomes the moat, because if it does, the model layer is already a commodity.
The agents are not getting smarter for free. Someone is paying $600 a day to find out. The question is whether the industry is reading the meter — or just the benchmark.
