OpenCode Won the Star Wars — But the Real Story Is Which Side You’re On
A year ago, the question every engineering team asked about code agents was simple: which one is best? Claude Code, Copilot, Cursor — you pick the one with the best output and move on. That question today feels almost outdated. The interesting question in mid-2026 isn’t which agent is best. It’s which side you’re on.
OpenCode forced that question into the open. Anomaly’s open-source agent (the company that previously operated as SST) crossed 171,000 stars on GitHub — surpassing Claude Code’s count and becoming, by that metric, the most-adopted code agent in the open-source world. But the star count is the hook, not the point. The point is how it got there, and who showed up once it did.
First, why developers actually chose it
It would be easy to blame politics — the mess with Anthropic, the partnership with OpenAI, the headlines. That would be wrong, and it’s worth being precise about it. Adoption came first. Developers chose OpenCode for concrete, boring, practical reasons long before any drama. If you skip this part, you misread the entire story.
The core pitch is vendor freedom. OpenCode connects to Anthropic, OpenAI, Gemini, AWS Bedrock, Groq, Azure OpenAI, OpenRouter — more than 75 models — plus self-hosted models via a local endpoint. You bring your own API keys, they stay on your machine, and you pay for what you use. The model you run for heavy reasoning can be different from the one you use for routine cleanup, and you can switch mid-session without restarting. No subscription, no dependency on a single vendor. For anyone who’s watched a tool change its terms overnight, that architecture isn’t a feature — it’s insurance.
It launched in June 2025 with no account, no email, no credit card. You download it and run it. That frictionless entry is a big part of why it expanded the way it did: there was nothing to register and nothing to lose.
It’s terminal-first without being terminal-only. The main interface is a TUI built on Bubble Tea — fast, no GUI overhead, runs straight in your shell — but there’s also a desktop app and an IDE extension for VS Code, Cursor, and others. It finds you where you already work.
And it’s built for real engineering discipline, not just autocomplete. Plan and Build modes give you a review step before the agent touches a single file. LSP integration means the agent reads actual diagnostics from your language toolchain, it doesn’t guess. MCP support and custom commands make it adaptable to however your stack looks. This is the part that matters for senior teams: the agent is designed to be supervised, not blindly trusted.
That’s the adoption story. None of it required a partnership with anyone.
Then politics arrived
This is where it gets interesting — and where the realignment lives that should concern any technical leader.
On January 9, 2026, Anthropic quietly deployed technical safeguards that blocked third-party tools from using Claude through consumer subscription OAuth tokens. Tools like OpenCode had been authenticating as if they were the official Claude Code client; that stopped working overnight, with no warning and no migration path. In February, Anthropic formalized it in their Terms of Service: OAuth tokens from Pro, Max, and Team plans cannot be used with third-party tools. On April 4, the company moved to paid-use billing — third-party use now comes out of paid overage, not out of the subscription. OpenCode removed Claude Pro/Max support from its codebase, citing legal requests from Anthropic. Claude still works in OpenCode through a direct API key; what closed was the subscription flat-rate route.
The economics behind Anthropic’s decision are no mystery. A USD 200/month Max subscription running autonomous agent workloads can consume well over USD 1,000/month in equivalent API costs. The flat rate was never designed for that pattern. From Anthropic’s side, this is a rational defense of a vertically integrated product. It’s a legitimate read, and it’s worth saying plainly.
But the strategy isn’t just about what’s rational — it’s about what the move opens up for everyone else. And what it opened was a door for OpenAI.
OpenAI officially partnered with OpenCode, extending Codex and ChatGPT subscription support within the open-source tool — and not just OpenCode, but other open harnesses too. When Anthropic first blocked third-party access in January, OpenCode launched ChatGPT support within hours, reportedly in coordination with OpenAI. The alignment was deliberate. One provider closed their garden to protect a polished, integrated product; the other planted a flag on the neutral, open ground its competitor had just vacated.
That’s the realignment. It’s not “open source beats proprietary.” It’s two opposite bets on what developers want.
What this actually means for your stack
Strip away the drama and you’re left with a genuine architecture decision, and it’s the kind of decision a CTO should make intentionally instead of inheriting by default.
OpenCode’s neutrality is its entire value proposition. If your priority is vendor freedom — the ability to route to any model, switch providers when terms or prices change, run open-weight or self-hosted models, and keep your tooling independent of any single vendor’s roadmap — OpenCode is built exactly for that. For regulated verticals where model choice and data routing are governance questions, not preferences, that flexibility is the point. For distributed teams that can’t assume everyone is on the same provider’s plan, a model-agnostic agent eliminates a coordination problem before it starts.
Where it doesn’t fit
The same neutrality is overhead if you don’t need it. If your team standardized on one provider’s ecosystem and you value the polish, support, fleet-management features, and autonomy that come from a tightly integrated product, then a cross-provider abstraction layer is friction you’re paying and not using. More integrated agents are integrated on purpose, and that buys real things: smoother defaults, first-party features, a single support surface. Vendor freedom only matters if you think you’ll exercise it. If you’ve already made your bet and you’re happy with it, OpenCode’s greatest strength is a cost you don’t need to carry.
The honest version is this: OpenCode didn’t win because OpenAI showed up. It won because a large number of developers independently decided, for practical reasons, that they wanted to own their tooling and choose their own models. That OpenAI showed up is what turned a popular tool into a political fault line. Both facts are true, and a technical leader needs to read them in the right order — adoption first, alignment second — to decide well.
Which side are you standing on: deep integration with one provider, or vendor freedom at any cost? And did you make that decision intentionally, or did you inherit it?