The Great Inference Reckoning: What OpenCode vs. Anthropic Reveals About AI’s Unsustainable Economics

The Moment Everything Changed

Last week, Anthropic did something that sent ripples through the AI developer community: they cut off OpenCode’s access to Claude.

Not for building something malicious. Not for violating content policies. Not for any of the reasons you’d expect a company to lose API access.

OpenCode’s crime? Using Claude exactly the way the future of AI is supposed to work.

They(their users to be exact) were running coding agents endlessly iterating, building, testing, failing, learning, trying again - powered by a $200 Claude Max subscription. The agents would loop through problems with the persistence of a determined toddler, eventually arriving at solutions through sheer repetition and refinement.

Anthropic’s response was swift and, from a business perspective, entirely rational: OpenCode users were often consuming 5-10 times the inference they’d paid for. The math simply didn’t work.

But here’s what makes this story fascinating: it’s not really about OpenCode at all. It’s about a fundamental tension at the heart of the AI industry - one that threatens to reshape how we think about intelligence, iteration, and the economics of thinking machines.

The All-You-Can-Eat Problem

To understand why Anthropic acted, you need to understand the brutal economics of inference.

Every time you send a prompt to Claude, GPT-4, or any cloud-hosted model, somewhere in a data centre, GPUs spin up to process your request. Those GPUs cost money - lots of it. The electricity alone to run them is staggering. The cooling systems. The real estate. The engineering teams keeping everything running.

When Anthropic charges $200/month for Claude Max, they’re making a bet: that the average user will consume a predictable amount of inference. Some users will be light; others will be heavy. The pricing assumes it all averages out.

But agents broke that assumption.

A human developer might send 50-100 prompts in a productive day. An agent running in a loop? Thousands. Tens of thousands. The meter never stops running because the agent never gets tired, never takes a coffee break, never decides to check Twitter instead of working.

This is the all-you-can-eat buffet problem. Subscription pricing works when consumption is bounded by human limitations. Remove the human from the loop, and suddenly you have customers showing up with dump trucks to the salad bar.

The Delicious Irony

Here’s where the story gets interesting.

OpenCode’s vision - agents that iterate relentlessly until they solve the problem isn’t some fringe idea. It’s essentially Anthropic’s own roadmap for Claude.

Think about what Anthropic has been building toward: Claude that can use computers, Claude that can work autonomously, Claude that can tackle complex multi-step tasks without constant human oversight. The “Claude Ralph Wiggum” plug-in that’s been floating around the community captures this perfectly - an agent that might not get things right the first time, but through persistence and iteration, eventually stumbles into the correct solution.

This is the future everyone is building toward. And Anthropic just punished a company for arriving there early.

The irony is almost poetic. OpenCode built exactly what the AI industry has been promising. They just forgot that the economics hadn’t caught up with the vision yet.

The Question That Changes Everything

This brings us to the pivotal question that should keep every cloud AI provider awake at night:

If agents can solve problems through persistence, why pay for expensive cloud intelligence?

Think about it. If the solution to a coding problem is “keep trying until you get it right,” the model’s raw intelligence becomes less important than its ability to iterate cheaply. A brilliant model that you can only afford to run 10 times might be worth less than a mediocre model you can run 10,000 times.

This isn’t theoretical. It’s happening right now.

Local models like Minimax M2.1, Zai GLM-4.7, and DeepSeek’s upcoming V4 range are reaching a threshold of “good enough.” They’re not as capable as Claude or GPT-4 on any single inference. But when you can run them infinitely on your own hardware?

The math changes completely.

The Rise of Infinite Iteration

Local inference makes the number of iterations economically irrelevant.

Your electricity costs something, sure. Your GPU depreciates over time. But the marginal cost of one more inference is essentially zero. Run your agent 100 times or 100,000 times - your monthly bill doesn’t change.

This fundamentally alters the value proposition of AI coding assistants.

With cloud models, you’re paying for intelligence-per-query. Every prompt costs money, so you want each one to count. You optimize for getting the right answer quickly.

With local models, you’re paying for hardware once and intelligence forever. You can afford to be wasteful. You can let agents explore, fail, backtrack, try again. The brute force approach becomes economically viable.

And here’s the thing: brute force often works.

The Scaffolding Revolution

“But local models aren’t smart enough,” you might object. “They’ll just iterate forever without making progress.”

This is where the ecosystem around local models becomes crucial.

Tools like SequentialThinking are giving local models structured reasoning capabilities they lack natively. Instead of hoping the model figures out a complex problem in one shot, you break it into steps, force explicit reasoning, and guide the model through a process that compensates for its limitations.

Context7 and similar tools are solving the documentation problem—giving local models access to up-to-date information that helps them avoid the hallucinations and outdated knowledge that plague smaller models.

The pattern is clear: smart scaffolding can compensate for less capable models. And that scaffolding is improving rapidly.

What you’re seeing is the emergence of a different paradigm. Instead of “smartest model wins,” we’re moving toward “best system wins”—where the system includes the model, the tools around it, and the ability to iterate freely.

The Cloud Provider’s Dilemma

This puts Anthropic, OpenAI, and every cloud AI provider in an impossible position.

They can’t price subscriptions low enough to compete with free local inference. The costs are real and substantial. Someone has to pay for those data centres.

They can’t allow unlimited usage without going bankrupt. The OpenCode situation proved that.

They can’t throttle too aggressively without degrading the product. Users paying $200/month expect to actually use the service.

And they can’t stop the local model ecosystem from improving. That train has left the station.

The uncomfortable truth is that the “cloud AI” business model might be fundamentally unstable for agentic use cases. It works great for humans sending occasional queries. It falls apart when agents send continuous streams of requests.

The Bifurcation

What we’re likely to see is a bifurcation in the market.

For interactive, human-in-the-loop use cases: Cloud models will continue to dominate. When you need a thoughtful response to a complex question, when you’re having a conversation, when quality matters more than quantity—paying for the best model makes sense.

For agentic, iteration-heavy use cases: Local models will increasingly win. When the task is “keep trying until it works,” when you need thousands of attempts, when the cost of iteration is the limiting factor—running locally becomes the only economically rational choice.

This isn’t a prediction about which approach is “better.” Both will coexist. But the boundary between them will be determined by economics, not capability.

What This Means for Developers

If you’re building AI-powered tools, the implications are significant.

Don’t assume cloud models are the only option. The gap between local and cloud is narrowing, and for many use cases, local is already good enough.

Design for iteration. If your agent architecture assumes expensive inference, you’re building for a world that’s disappearing. Design systems that can leverage cheap, abundant inference.

Watch the scaffolding ecosystem. Tools that make local models more capable are often more valuable than marginal improvements in model intelligence. The leverage is enormous.

Understand the economics. The cost structure of your AI system determines what’s possible. Infinite iteration enables approaches that are impossible when every query costs money.

The Uncomfortable Conclusion

The OpenCode vs. Anthropic story isn’t really about terms of service violations or usage limits. It’s about a fundamental mismatch between how AI is priced and how AI wants to be used.

Agents want to iterate. They want to try, fail, learn, and try again. This is how they solve problems. This is how they get better. This is the future everyone is building toward.

But iteration costs money when you’re paying per inference. And the companies providing the inference can’t afford to let agents iterate freely.

Something has to give.

Maybe cloud providers will find new pricing models that work for agentic use cases. Maybe local models will improve to the point where cloud inference becomes a niche product. Maybe we’ll see hybrid approaches that use local models for iteration and cloud models for final validation.

What seems clear is that the current equilibrium is unstable. The OpenCode incident isn’t an isolated dispute—it’s an early tremor of a larger earthquake coming to the AI industry.

The question isn’t whether the economics of AI inference will change. It’s whether the cloud providers can adapt fast enough to survive the change.

The irony of this whole situation? The solution to the “agents use too much inference” problem might itself be solved by agents—iterating endlessly on local hardware until they figure out how to be just as good as the cloud models they’re replacing.

Some problems really do solve themselves. You just have to let them run long enough.