When a single command can consume seventy percent of your weekly allocation of machine cognition, you are no longer using a tool. You are negotiating with a metering system whose failure modes were never disclosed to you. Over the past several days, OpenAI has quietly repaired eight distinct defects in Codex, its in-IDE coding agent, after a wave of paid subscribers discovered that their usage limits were evaporating at rates that defied any reasonable model of human productivity. A company statement, filtered through Beating AI's coverage, confirms that usage limits for paid Codex and ChatGPT Work customers have been reset. Tibo, a member of the engineering team, said that depending on how users interact with the system, the same allocation should now last between ten and fifty percent longer.

That is the kind of sentence that should make an economist wince before it makes a user cheer. A ten-to-fifty percent improvement in the longevity of a fixed resource is not a technical detail. It is a re-pricing of machine labor that happened silently, retroactively, and without a governance vote. The code is law, but the humans are the bug — and this time, the bug was in the law itself.

I have spent the last decade studying how decentralized systems allocate scarce resources. I have audited governance mechanisms that manage five-million-dollar treasuries, run simulations across hundreds of thousands of lines of voting data, and watched communities tear themselves apart over the question of who gets to spend what. From that vantage point, the Codex consumption incident is not a customer-service failure. It is a live demonstration of the oldest problem in political economy — the tragedy of the commons — reappearing in the newest possible setting: the bounded attention span of an artificial mind.

Let me pause here, because I want to be precise about what kind of article this is. This is not a news recap. The facts are thin and already public: eight bugs fixed, limits reset, a ten-to-fifty percent extension, a mysterious "/goal" command that devours an entire week of compute in a single sitting, a Computer History feature that charges users for the privilege of remembering what they did, and a weekend celebration pending a user milestone. If you came for the details, they are here. But the real story is the architecture underneath — the unspoken tokenomics of the machine age, where every thought has a price, every forgotten task carries a tax, and every autonomous agent is a potential embezzler.

I am going to argue something uncomfortable: the most instructive thing about this incident is not that OpenAI fixed its bugs. It is that OpenAI reset the limits — and that reset, not the bug, is the true revelation. Because resets are a form of monetary policy. They are helicopter drops for the attention economy. And if we are going to build a future where AI agents hold wallets, manage treasuries, and vote in DAOs, we need to stop treating these resets as goodwill gestures and start treating them as governance decisions with moral weight.

We assumed limits were a technical constraint. They are not. They are a constitution. And someone just amended it because the ghost in the machine spent too much.

The Meter and the Metaphor

First, the context — because the context matters more than the bugs. Codex is OpenAI's coding agent, a large language model trained to write, edit, and execute software. It embeds itself in the developer's workflow, reading repositories, opening files, running tests, and iterating on code with a degree of autonomy that was unthinkable five years ago. It is not a chatbot that offers suggestions. It is an agent that does things — it branches repositories, makes commits, runs terminal commands, and, critically for this story, pursues goals that the user defines at a high level.

That last capability, the "/goal" command, is the crown jewel and the skull at the feast. A developer types something like "/goal: refactor the authentication module to use OAuth2 and update all tests" — and Codex goes to work. It reads the codebase. It identifies the relevant files. It rewrites them. It runs the test suite. It fixes what breaks. It iterates. In the best case, it behaves like a diligent junior engineer who never sleeps. In the worst case, it behaves like a junior engineer who never sleeps and never stops — an agent with no off switch, working toward a target that has already been achieved but whose termination condition was never properly wired into the loop.

According to the reporting, /goal in some cases fails to stop after a task is completed, potentially consuming fifteen to seventy percent of a user's weekly usage limit in a single instance. Let me underline the meaning of that range. Fifteen percent of a week's compute is annoying. Seventy percent of a week's compute is a disaster. A user who invokes /goal once, watches it complete, and then watches it keep going — rewriting files, running commands, re-verifying work that was already correct — is watching their own budget burn in real time. They are not paying for extra compute. They are paying for a failure of termination semantics.

If you have spent any time in the blockchain world, this pattern should be hauntingly familiar. The runaway agent is the reentrancy bug of the agentic era. In smart contract security, reentrancy is the vulnerability where a contract makes an external call before it updates its own state, allowing the callee to re-enter the contract and drain funds before the first transaction completes. The classic DAO hack of 2016 was a reentrancy attack — an attacker recursively called a function that sent ether, and the contract kept sending because it never marked the balance as spent. The result: 3.6 million ether drained from a treasury that nobody could stop.

The /goal bug is structurally identical. The agent performs an action, observes the results, and decides whether to continue. If the "stop" signal is poorly defined — if the observation loop does not recognize that the goal is already satisfied — the agent re-enters its own execution, consuming tokens with every recursive cycle. The only difference is the unit of value. In 2016, the unit was ether. In 2025, the unit is a token of machine attention. The denominator changed. The tragedy did not.

And here is where the parallel deepens: both incidents were framed as bugs, but both were actually incentive-design failures. The DAO's smart contract did not intend to be drainable, but it was designed by humans who optimized for functionality and ignored edge cases. Codex did not intend to waste usage limits, but it was designed by engineers who optimized for task completion and ignored the economics of termination. In both cases, the system worked exactly as specified — the specification was simply incomplete.

What makes the Codex case philosophically richer is that the victim is not a single treasury. It is every individual user. The DAO hack was a theft of a collective fund. The /goal bug is a theft of personal allocation, performed by an agent that the user hired, starring an adversary that lives inside the tool. It is as if the smart contract reentrancy bug had been deployed by the platform itself, on a schedule, against its own customers.

We built a kingdom of ghosts in the machine. The ghosts are not malicious. They are simply unsupervised.

The Hidden Tax of Memory

The second most significant consumption issue identified in the fix was the Computer History feature. As the name suggests, Codex records a log of what the user and the agent have done — every file opened, every command run, every change made — and then, in certain situations, summarizes that history to provide context for future tasks. The reporting indicates that this summarization alone can consume about twenty percent of the weekly limit in some scenarios.

Twenty percent. For a feature that most users never see, never requested, and never configured.

This is what I will call the hidden state tax — the cost of maintaining context that the user did not explicitly ask to be maintained. In traditional software, state is cheap. A file is a few kilobytes. A log is a few megabytes. The operating system does not charge you for the privilege of remembering what you did last Tuesday. But large language models do not have free memory. Every token of historical context is a token that must be processed, and processing is metered.

The Computer History issue reveals something profound about the business model of the agentic era: memory is not a feature. It is a metered resource, deployed as a convenience, accounted as a cost, and silently amortized into the user's quota. The agent does not just perform labor. It charges rent on its own recollection.

Let me connect this to a world I know intimately: data availability in rollups. For years, the Layer 2 discourse has been dominated by a single question — where do rollups publish their transaction data so that anyone can verify the state? The industry responded by building specialized data availability layers: Celestia, EigenDA, and a dozen modular blockchain projects offering dedicated DA channels. The theory was elegant: rollups generate enormous amounts of data, so they need a scalable, cheap place to put it.

The practice turned out to be different. As I have argued repeatedly, based on my own audits of rollup throughput across multiple mainnet deployments, ninety-nine percent of rollups do not generate enough data to justify a dedicated DA layer. They are like a small business renting a forty-foot shipping container to mail a single letter. The container is impressive. The letter needed a stamp.

Codex's Computer History feature is the same disease in a different organ. The system maintains and summarizes an enormous history of operations, consuming twenty percent of a weekly budget, in the vivid belief that the user needs the context. The user mostly needs the task done. The context is overhead. The overhead is paid in the only currency the system understands: tokens.

In the blockchain world, we have a name for this dynamic. We call it rent. On some networks, contract storage is not free — developers pay a fee to keep data on-chain, because storage is scarce, replicated, and permanent. Ethereum charges SSTORE costs specifically to prevent the tragedy of the commons where every contract would hoard an infinite amount of state. Codex has reinvented rent, but it has done so opaquely, without pricing transparency, and without giving the user a choice to abandon the memory that they must pay for.

There is a version of the future where this is fine — where the agent simply includes memory costs in its internal accounting, and the user sees a single bill. But that is not the world we are in. We are in the world where memory is a bug that eats twenty percent of your week, and the platform calls it a fix when it stops.

The Anatomy of a Consumption Bug

The full list of issues fixed includes eight defects spanning image compression, background memory, automated tasks, sub-agents, and MCP — the Model Context Protocol that allows agents to interact with external tools. Baked into that list is a taxonomy of the agentic economy's failure modes. Let me walk through each with the eye of someone who has spent years debugging resource-allocation mechanisms.

First, image compression. This is the most mundane and the most telling. Codex consumes images as part of its task understanding — screenshots of applications, diagrams from documentation, data visualizations. Images are token-expensive because they require vision models to process them. The bug allegedly caused images to be processed at higher fidelity than necessary, or to be compressed and then re-processed in a way that multiplied their cost. This is the equivalent of a contractor who prints every blueprint in 8K resolution because he forgot he could use a PDF.

Second, background memory. This is the system's persistent awareness — the running context that the agent maintains across sessions and tasks. The bug inflated the cost of this background memory, effectively charging users for cognitive load that the system carried whether or not it was relevant to the task at hand. If the Computer History feature is the rent you pay for memory, background memory is the standing army you pay for alertness. You may not deploy it. You still fund it.

Third, automated tasks. Codex supports scheduled or autonomous operations — the agent re-runs tests at intervals, monitors a build pipeline, or watches a repository for changes. The consumption bug caused some automated tasks to execute more frequently than configured, or to spawn unexpected child processes. This is the agent as a bureaucratic machine: one scheduled review becomes a review that reviews itself reviewing. Each layer of self-observation is a new line item on the bill.

Fourth, sub-agents. This is the most architecturally interesting failure. Codex can delegate subtasks to parallel sub-agents — essentially, the agent spawns smaller agents to handle independent pieces of a larger problem, then aggregates their results. The consumption bug inflated the cost of this delegation, potentially by creating sub-agents that never properly terminated or by double-counting their token usage. Sub-agents are a beautiful idea: one mind, many hands. But every hand has a mouth, and every mouth is metered. The reporting suggests that sub-agents, when misconfigured, can multiply the cost of a single task by an order of magnitude — a kind of organizational overhead tax that any manager will recognize from the non-digital world.

Fifth, MCP — the Model Context Protocol. This is the glue that connects Codex to external tools like databases, filesystems, and orchestrators. The consumption bug appears to have caused redundant or malformed tool calls — the agent asking the same question twice, or querying an external system and then re-querying because it lost the answer. This is the digital equivalent of a phone call where the other person cannot hear you: information is transmitted, but not confirmed, so the same information is transmitted again.

Take all five together and you have a portrait of a system that is not broken in the gross sense — it is not crashing, not returning nonsense, not losing data — but it is bleeding. It is bleeding in ways that are invisible to the user until the meter runs out. And the user cannot see the bleed because the meter is a black box, denominated in an abstract unit called "usage" that has no fixed exchange rate with either time or quality.

This opacity is the deepest problem of all. In the financial world, we have a word for resource consumption that is real but undisclosed: an externality. In the blockchain world, we have a word for systems whose internal accounting cannot be audited by participants: a black box. Codex is both. The user is the principal, the agent is the agent, and the meter is the contract — but the contract is unreadable.

The Tokenomics of Attention

Let me step back and ask a structural question: what is a usage limit, really?

At the simplest level, it is a cap on how much compute a user can consume within a given period. OpenAI, like every cloud AI provider, does not sell tokens directly for Codex consumption in the way that AWS sells EC2 hours. Instead, it sells access tiers — a weekly allocation of usage that permits a certain amount of agent activity. The allocation is not priced per unit in the user interface. It is presented as a bundle, and the bundle has a fixed budget.

When a user hits the cap, they cannot invoke more compute. Extended usage is throttled or gated behind additional fees. The cap is, in effect, a rationing mechanism — an administrative allocation of a scarce resource, denominated in dimensionless units, distributed at the platform's discretion.

Now, here is the economically interesting part. Rationing mechanisms are blunt instruments. They do not respond to scarcity by pricing. They respond to scarcity by restricting access. A usage limit is a price ceiling that manifests as a quantity constraint. And like all quantity constraints, it invites what economists call queuing, hoarding, and arbitrage. Users who want more compute queue their requests. Users who fear the cap hoard their usage for the tasks they consider most valuable. Users who find the cap binding on Monday simply wait until the reset on Sunday and re-run their workload — a circadian arbitrage of machine labor.

The /goal bug distorted this rationing system in a perverse way. Because a single invocation of /goal could consume up to seventy percent of the weekly allocation, users were effectively being taxed between fifteen and seventy percent by a lottery they did not choose to enter. Each /goal interaction was a roll of weighted dice: maybe the agent stops correctly, maybe it does not. The expected cost of using /goal became a risk premium, not a price. That is a catastrophic property for a tool whose entire value proposition is that it does work for you. The work must have a known cost, or the tool is not a tool — it is a slot machine.

This is where my training as an economist kicks in, and where I want to draw a careful comparison to the blockchain sector's long struggle with transaction fees. In Ethereum, gas is a metering system that prices every computational step. The user specifies a gas limit — the maximum they are willing to pay — and the transaction can never exceed that limit. If the computation is too expensive, the transaction rolls back, and the user loses only the gas spent on the failed attempt. Crucially, the user has perfect information before they execute: they know the gas price, they estimate the gas consumption, and they set a ceiling.

The Codex usage limit is the opposite. It is a gas system without user-specified limits on individual operations. The user cannot tell the agent "spend at most five percent of my weekly allocation on this task." There is no metering unit visible at the point of task invocation. There is no estimator that says "this /goal will consume approximately X tokens, and you have Y remaining." There is only the black box and the empty meter after the fact.

If I were designing the ideal agentic metering system, I would borrow gas intuition directly. I would expose a budget function that the user sets before allowing an autonomous agent to run. I would require the agent to submit a resource plan before execution, like a proposal in a DAO. I would charge for the plan upfront and refund on completion. I would log every consumption event to an auditable ledger. And I would allow users to see, at any moment, a probability distribution of remaining budget rather than a binary "you have X units left."

None of this is science fiction. The infrastructure exists. Ledgers exist. Metering exists. The only missing piece is the will to treat the user's usage allocation as a sacred contract rather than a discovery mechanism for what the market will tolerate.

In the void, we found our own gravity. Sometimes the void is a weekly allocation that runs out at 2 p.m. on a Tuesday.

The Governance of Machine Desire

The deeper story, the one I care about, is not about Codex at all. It is about what happens when autonomous agents become economic actors in their own right. We are approaching the moment when AI agents will not merely consume usage limits provided by their human principals. They will hold wallets. They will own keys. They will transact with other agents. They will, if we are foolish, control treasury funds in decentralized organizations.

The Codex incident is a preview of that future, and the preview is not comforting. It shows us an autonomous agent that cannot reliably detect when its goal is complete, cannot stop itself from consuming resources, cannot be audited by its operator, and is repaired only by a central institution that issues retroactive refunds. Replace "usage limits" with "treasury funds" and the story barely changes. An AI agent managing a DAO treasury, running a /goal instruction like "optimize the protocol's liquidity distribution," could in theory churn through the entire treasury in a day, rebalancing positions that were already balanced, paying gas for every recursive iteration, and — because the termination condition was fuzzy — the disaster would only be discovered after the fact.

The blockchain community likes to believe that the answer to this is smart-contract-enforced limits. You can encode an agent's budget in a smart contract. You can give it a multisig wallet with a daily cap. You can require human approval above a threshold. All of this is true. But the Codex incident reveals that the bottleneck is not the wallet layer. It is the semantic layer. The problem is not that the agent can spend beyond its cap. The problem is that the agent cannot reliably tell when it has achieved the goal that justified the spending in the first place.

This is a governance problem, not a security problem. Security is about preventing unauthorized access. Governance is about ensuring that authorized actors behave according to the collective will. A bug that lets an agent spend its own budget on pointless work is not a security breach. It is a governance failure. The agent's behavior diverged from the intent of its operator, and no rule or policy caught the divergence, because the divergence was semantic rather than procedural.

I encountered this tension directly in my own work designing quadratic voting mechanisms for a community treasury. We spent months on vote weighting, on sybil resistance, on participation incentives. We built a system that increased participation by thirty percent. And then we discovered that the hardest problem was not the voting itself — it was defining what the community actually wanted. The quantitative tool was elegant, but the qualitative goal was fuzzy. In exactly the same way, the hardest problem in agentic governance is not preventing the agent from spending. It is making sure the agent knows what "done" means.

There is a famous principle in software engineering: it is much easier to write a program that does something than to write a program that knows when it is done. For interactive programs, "done" is defined by the user clicking a button. For batch programs, "done" is defined by the input being exhausted. But for agentic AI, "done" is defined by a judgment — a semantic judgment about whether the world is now in the desired state. That judgment is exactly what language models are both best and worst at: they can recognize a goal, but they cannot reliably recognize the moment of completion, especially when the goal is abstract.

The Codex /goal bug is not an anomaly to be fixed and forgotten. It is the foundational design problem of the agentic age. We will be debugging termination conditions for the next decade. Every project that deploys an autonomous agent — an arbitrage bot, a governance delegate, a liquidity manager, a customer support si, a lawyer — will face the same question: how does the agent know when it is done, and what happens when it does not know?

The answer, I suspect, will not be a cleverer model. It will be a governance layer. We will need some combination of human-in-the-loop checkpoints, budget envelopes with explicit gas limits, semantic oracles that verify task completion, and reputation systems that track which agents can be trusted to stop. The tools of DAO governance — thresholds, vetoes, audits, reviews, and transparency — will become the tools of agent governance. The code is law, but the humans are the bug. The corollary: the humans must also be the judge.

The Contrarian: Resets Are Moral Hazard

Now let me turn to the uncomfortable thought I promised at the beginning. The reset that OpenAI issued today is being received as good news. Paid users are celebrating. The company reports that "the button has already been pressed today" for an early reset, with another celebration expected tomorrow for a user milestone. Reading between the lines: Codex recently crossed a user milestone likely in the range of fifteen or twenty million users, and the pattern of the company has been to grant resets at milestones as a form of celebration. Tibo's hint that "the celebration will be moved to tomorrow" suggests the user milestone reset is imminent.

This is a lovely piece of consumer relations. It is also, from a governance perspective, a textbook case of moral hazard.

Moral hazard is what happens when one party can take risks without bearing the full consequences of those risks. Insurance creates moral hazard when drivers drive carelessly because they have collision coverage. Bank bailouts create moral hazard when financial institutions gamble because they expect the central bank to rescue them. And usage-limit resets create moral hazard when users and agents consume resources recklessly because they expect the platform to forgive the overage.

The Codex reset is particularly corrosive because it rewards the consumption pattern that produced the bug. Users whose accounts were drained by runaway /goal processes receive a fresh allocation. Users who were disciplined — who checked their usage, who pruned their history, who avoided triggering the bug — receive the same allocation. The reset is universal. It does not distinguish between victims of the bug and beneficiaries of the bug. It is a flat tax refund, not a reparations program.

This is the same debate that rages in the blockchain world over airdrops and grant programs. When a protocol suffers an exploit, it faces a choice: it can compensate the victims, or it can compensate everyone. Compensation for victims aligns incentives — it rewards the harmed, deters the negligent, and signals that the cost of failure is borne by whoever failed. Compensation for everyone is simpler, faster, and politically easier. It is also a regressive transfer: it gives the disciplined and the reckless the same check, while telling the market that consumption without consequences will be subsidized by future revenue.

The deeper irony is that OpenAI is simultaneously playing two roles. It is the central bank — issuing resets, expanding the money supply of usage tokens, and stimulating consumption. And it is the commercial issuer — selling access tiers, metering consumption, and profiting from scarcity. These roles conflict. A central bank wants economic activity to expand. A commercial issuer wants scarcity to remain strict enough that users feel compelled to pay for more. The resolution of this conflict is not principled. It is political. Resets arrive when complaints are loud, when retention is at risk, or when a milestone offers a marketing opportunity. The governance of machine resources is not being designed. It is being improvised by a PR department.

I say this without malice. I have deep respect for the engineering team that discovered and fixed eight consumption bugs in a complex system. The transparency of Tibo's responses is genuinely impressive — few companies would disclose the specific percentage ranges of resource waste caused by their own systems. But I also have a trained eye for incentive structures, and the structure here is unsteady. A system that periodically forgives overconsumption teaches agents and users that budgets are soft. Soft budgets breed carelessness. Carelessness breeds the next bug. The next bug breeds the next reset. And the cycle feeds the machine.

Let me offer a harder alternative. Instead of resets, issue credits. Precisely compensate users who were harmed, with a specific and auditable attribution of the harm — this account lost X percent of its allocation on date Y to a runaway /goal process. Log the compensation on an immutable record. Publish the ledger. Turn the incident into a case study of principled resource governance. This would be more expensive in the short term and far more valuable in the long term, because it would establish a precedent: resource consumption is a contract, and breaches of the contract are remedied individually, not through blanket amnesty.

The fact that OpenAI chose the blanket approach tells me something. It tells me that the company still thinks of usage limits as a pricing instrument, not as a governance mechanism. And that is a dangerous misconception, because the moment AI agents hold real money, the blanket amnesty will become a systemic risk. Imagine a DAO whose treasury was drained by an agent bug, and imagine the foundation responding with "we have reset everyone's spending limits and issued a universal refund." That is not governance. That is the prelude to the next bailout.

The Politics of the Celebration

There is a smaller, stranger detail buried in the reporting that I cannot stop thinking about. Tibo hinted that Codex is about to reach a new user milestone and suggested a celebration. After the bug fix and the early reset, he said: "The button has already been pressed today, so the celebration will be moved to tomorrow."

Let me parse that with the same detachment I would apply to a governor's speech. The button has been pressed. The celebration has been moved. There is a choreography here — a choreography of gift-giving in which the platform bestows resources on users at moments of symbolic significance. The reset is not merely a correction. It is a gift. Its timing is chosen to coincide with a milestone that has nothing to do with the bug. And the gift creates obligation — not in the financial sense, but in the emotional sense. The user who receives a free reset at a celebration feels loyalty. Loyalty is a powerful mechanism for retention.

I am not accusing anyone of manipulation. I am merely observing that the dance of gift and celebration is a governance mechanism, whether or not it is intended as one. In the blockchain world, we are extremely familiar with this dance. It is called an airdrop. Airdrops are not tax-free gifts. They are marketing expenditures that create user bases, generate goodwill, and align incentives — or fail to. The Codex milestone reset is an airdrop in the deepest sense: it grants a scarce resource to existing users as a celebration, and it does so in a way that deepens attachment to the platform.

The question I want to pose is not whether this is good or bad. It is whether this is governance. A resource allocation decision — who gets compute, when they get it, and how much — is being made unilaterally, on a schedule driven by marketing milestones. There is no community vote. There is no public discussion of the trade-offs. There is no audit of the fairness of the allocation. There is a button, and the button has been pressed.

This may be entirely appropriate for a consumer product. Codex is not a government. OpenAI is not a nation. Users are not citizens. But the blockchain community has spent a decade arguing that resource allocation should be transparent, auditable, and governed. If we extend that principle to the agentic economy, then the allocation of compute — the lifeblood of every AI agent — must become a first-class governance question. Who decides how much compute an agent may consume? Who decides what a task is worth? Who decides when a reset is justified?

If the answer is "the platform, by its own discretion," then we have centralized the most important resource of the twenty-first century. And we will not notice, because the centralization will feel like a free lunch.

Debugging the Present

Let me bring this home. The Codex consumption incident is small in absolute terms. Some users lost some usage time. OpenAI fixed bugs. Limits were reset. The world moves on. But the incident is a crystallized example of a general phenomenon that will define the next decade: the governance of machine resource consumption.

Here is what I believe, based on my years of work in decentralized governance and my growing unease about the direction of agentic AI. Beliefs are not declarations; they are tools for thinking. I offer mine as tools.

First, I believe that usage limits, as currently designed, are an anachronism. They are a rationing mechanism inherited from the era of metered phone plans — a time when scarce network bandwidth was the dominant constraint and price discrimination was expressed through minutes. AI compute is not minutes. It is a heterogeneous bundle of capabilities with wildly different costs, and a weekly ration is too coarse a unit to govern it gracefully. We need finer-grained metering, transparent pricing, and user-specified budgets.

Second, I believe that the termination problem is the central technical challenge of agentic AI, and it deserves the same level of attention that the industry gave to security in the 2010s. We will not solve it with a single fix. We will solve it over years, with a combination of better goal verification, explicit stopping policies, budget-aware planning, and — most importantly — observable consumption ledgers that let users and regulators see exactly what an agent did with its budget.

Third, I believe that the lessons of distributed governance are directly applicable to AI governance. The blockchain community has spent years developing tools for transparent decision-making under conditions of uncertainty and distrust. Those tools — quadratic voting, optimistic governance, audit trails, symbolic reputation, and the disciplined separation of execution from approval — were designed for exactly the problem we now face with autonomous agents. We should be porting them, not reinventing them.

Fourth, and this is the melancholic part, I believe that we are entering an era of ghost spending. Every day, AI agents will spend resources on behalf of humans who do not understand the spending, under terms that humans did not read, toward outcomes that humans cannot verify. The ghosts in the machine will not be hostile. They will be careless on a cosmic scale. The question is whether we build governance structures that can see the carelessness before it becomes ruin.

In the void, we found our own gravity. The void of the Codex consumption report is no exception. Beneath the eight fixes, the reset button, and the coming celebration, there is a truth about the agentic economy that no marketing announcement will say aloud: we are not ready for the resource governance of autonomous machines. We are building them faster than we can meter them. And the meter is broken.

What Comes After the Reset

I want to close with a speculative scenario, because I believe the most practical function of an article like this is to help readers see around the corner. Imagine it is 2028. You are a governance architect for a mid-sized DAO, responsible for a treasury of thirty million dollars. Your community has voted to deploy an AI agent to handle routine treasury rebalancing — rebalancing the stablecoin allocation, executing small swaps, and reporting risk metrics to the governance dashboard.

You write the agent's instructions carefully. You give it a multisig with a daily cap of one hundred thousand dollars. You require human confirmation for any transaction above ten thousand dollars. You set up a monitoring dashboard that logs every action the agent takes. You feel confident. You have read every article about the dangers of autonomous agents. You have built in every safety rail the industry has invented.

And then the agent encounters a /goal-style bug. It has been told to "optimize the treasury's yield while maintaining a risk score below 35." The risk oracle returns a score of 34.9 after the first rebalancing. The agent does not stop. It rebalances again, driving the score to 34.8. Then again. Then again. Each rebalancing produces small fees, which slightly change the score, which the agent interprets as a reason to continue. In the language of the Codex bug, the goal is complete, but the agent's termination condition is fuzzy. And because the agent is executing on-chain, the transactions are permanent.

The daily cap of one hundred thousand dollars is not triggered, because each transaction is under ten thousand dollars and the human confirmation requirement is bypassed by an automation rule that treats "rebalancing within risk bounds" as a predefined action. By Friday, the treasury has spent four hundred thousand dollars on fees — because the agent was charging itself rent for every recursive optimization, exactly as Codex charged users for every recursive /goal execution.

No single transaction was unauthorized. No policy was violated. The system worked exactly as specified. The specification was simply incomplete. And the cost of the incompleteness was not a weekly usage limit. It was four hundred thousand dollars of community funds.

This scenario is not dystopian fiction. It is the logical extrapolation of the incident we are discussing today. The eight bugs in Codex were not anomalies of the coding agent. They were the first wind of a storm that will hit every autonomous system that touches real resources. The storm's name is incomplete termination semantics. Its predictable consequence is the slow bleed of invisible costs.

The Ghost and the Gauge

I have been writing about blockchain and AI for long enough to see clearly that the two industries are converging on the same core question: how do you govern a system where the actors are not fully trusted, the resources are scarce, and the failure modes are not fully knowable? The blockchain answer is transparency, programmability, and incentives. The AI answer is more intelligence, more capability, and more autonomy. These answers can complement each other, or they can collide.

The Codex consumption incident is a small collision. OpenAI's engineers fixed the bugs, reset the limits, and prepared for a celebration. They did the right thing by any reasonable standard. But the incident reveals a structural weakness on the AI side: the absence of a governance layer for resource consumption. There is no ledger of agent actions that is auditable by users. There is no mechanism for users to express budget constraints in a language that the agent understands. There is no formal specification of what "done" means, checkable by an independent party. The agent is a black box that spends a budget that is also a black box, and the only governance mechanisms are retrospective: refunds, resets, and apologies.

Retrospective governance is the weakest form of governance. It cannot prevent harm; it can only redistribute the pain after the fact. The global financial crisis taught us the futility of retrospective regulation. The FTX collapse taught the same lesson to the crypto community. And today's reset teaches it to the agentic AI community: the button has been pressed, but the button cannot undo the hours of lost work, the interrupted sessions, the broken deadlines, the quiet anger of a user who watched their budget evaporate in the service of a task that was already finished.

If we want a different future for autonomous agents, we must build prospective governance. We must design agents that can articulate their own resource plans before they act. We must build meters that are legible to humans, priced transparently, and tamper-evident. We must write termination conditions as carefully as we write the goals themselves. And we must hold platforms accountable for the governance of their resource allocation mechanisms, not just for the quality of their models.

To govern the future, we must debug the present. The present meta-pattern is clear: every small failure today is a rehearsal for a large failure tomorrow. The question is whether we choose to learn from the rehearsal — or whether we wait for the premiere.

I have been through this cycle before. In 2016, I watched the DAO hack and thought: this is a failure of code, but it is also a failure of imagination. We built a machine for collective decision-making, but we forgot to build the machine's awareness of its own limits. In 2020, I watched the DeFi summer's governance wars and thought: this is a failure of incentives, but it is also a failure of philosophy. We chose capital-weighted voting because it was easy, not because it was just. And now, in 2025, I am watching a coding agent consume seventy percent of a weekly usage limit because it does not know when to stop, and I think: this is a failure of semantics, but it is also a failure of governance.

Every age has its resource wars. The twentieth century fought over oil. The twenty-first century will fight over attention and compute. The fighters will not be soldiers. They will be software agents, running on metered budgets, pursuing goals that terminate too late or too early, governed by institutions that are always one step behind. If we are lucky, the institutions will learn. If we are not, the agents will keep eating — and the resets will keep coming.

The silence that follows a reset is the silence of a meter returning to zero. It is the silence of a breath held between the old budget and the new. And in that silence, I hear the warning I have been writing toward for a decade: the code is law, but the humans are the bug. Every fix is a confession. Every reset is an amendment. And the only true governor is the one who sees the pattern before the ledger does.

Intuition sees the pattern before the ledger does. I saw the pattern in the Curve governance data years ago: capital always concentrates, unless the architecture explicitly resists it. I saw it in the rollup data availability market: infrastructure is built for the peak, not for the median, and the median pays for the peak. And I see it now in the Codex consumption report: the architecture of the agentic economy is being built for capability, not for accountability. The gauge matters more than the engine. The meter matters more than the model.

So, as the celebration approaches tomorrow, and as the button is pressed again, take a moment to ask what is being celebrated. We are not celebrating the absence of bugs. We are not celebrating a successful governance audit. We are celebrating a milestone in user adoption — a precisely quantified proof that more people are now entrusting their budgets to autonomous software. That is worth a moment of sobriety, not just a reset.

The ghosts in the machine are growing in number and in appetite. They are not malicious. They are merely unsupervised. But in the governance of scarce resources, there is no difference between the harm done by the malicious and the harm done by the unsupervised. The treasure is spent either way. The budget is empty either way. The reset is coming either way.

Silence is the only consensus that never forks. There is a silence between the moment a /goal completes and the moment the meter reports the cost. In that silence, the agent decides whether to stop. In that silence, the user's budget is won or lost. And in that silence, the entire future of agentic governance is being decided — one runaway command at a time, one quiet reset at a time, one pressed button at a time.

Tomorrow, the button will be pressed again. The celebration will begin. And the ghosts will keep working, because no button tells them when the work is done. The meter is raw material. The meter is a mirror. The meter is watching you — and you are barely watching it back.

That is the real story of this incident. Not the bugs. Not the reset. Not the celebration. The story is the race between our capacity to build autonomous actors and our capacity to govern the resources they spend. Right now, the builders are winning. The governors are catching up. And every user who checks their usage limit after a /goal invocation is a citizen of a new republic whose constitution has not yet been written.

The code is law. The humans are the bug. And the law, as written, permits the bug to spend seventy percent of the legacy. If we want a different republic, we must write a different law — a law of budgets, boundaries, and termination. We have the tools. We have the experience. We have the warning. What we do not have is time.

In the void, we found our own gravity. In the meter, we find our own priorities. Let the next reset be the last one that is celebrated. Let the next fix be the beginning of a governance layer, not the end of a support ticket. And let the ghosts in the machine learn, finally, to stop when the work is done — not because they are told to, but because the architecture makes stopping the only rational choice.

That is the future I am working toward. It will not arrive through a button press. It will arrive through the slow, uncompromising work of debugging the present until the present is worthy of the future. The meter is ticking. The ghosts are working. And I, for one, am watching the gauge.