What OpenCode actually shipped and the numbers that anchor the conversation
The trajectory of OpenCode through the back half of 2025 and into the first half of 2026 is now reproducible from the public GitHub data, the project's own communications, and the practitioner write-ups that have tracked the install-base growth quarter by quarter.
The operationally important data points, summarized from the consolidated coverage:
- ~161,000 GitHub stars on the OpenCode repository, growing roughly an order of magnitude faster than the conventional 2024 baseline for a developer tool of this category.
- ~7.5M monthly active developers across the CLI, the desktop application, and the VS Code / Cursor / JetBrains extensions — a number that puts the project in the same conversation as the closed-source platform leaders rather than in the long tail of weekend projects.
- 75+ supported model providers, including the full Claude line, the OpenAI Codex and GPT-5.5 family, Gemini, the open-weights frontier cohort (Llama 4, DeepSeek V4 Pro, Qwen 3.5, Mistral Medium 3.5, Kimi K2.6), and arbitrary local-inference endpoints — Ollama, vLLM, llama.cpp.
- MIT-licensed end to end, with no telemetry on customer code by design and no proprietary backend the customer depends on. The agent runs locally; the model call goes wherever the customer routes it; the agent's tool surface respects the customer's filesystem and process boundary.
- Native ACP (Agent Client Protocol) support, which means the same OpenCode agent runtime now drops into Zed, JetBrains IntelliJ, PyCharm, WebStorm, the Zed editor, Devin Desktop, and any other ACP-compatible client without a per-IDE rewrite.
- Air-gapped deployment as a first-class, supported configuration — the agent and the local model can run on infrastructure with no outbound internet, which is the configuration the regulated buyer's procurement asks about on the first call.
Worth flagging clearly: the growth numbers are derived from the project's own and third-party tracker data, are consistent across the consolidated 2026 coverage, and should be read as install-base scale rather than revenue scale (the project does not have a revenue line; the maintainers operate on a sponsorship and consulting model). The structural read does not depend on the project monetizing — it depends on it being installed and used at frontier-platform scale, which the data supports.
Why an open-source agent at the top of the chart changes the procurement shape
For the last two and a half years, the procurement conversation on AI coding agents has run on a single premise that nobody has spent much time defending out loud: that the credible production-grade options were all closed-source, that the open-source alternatives were toys, and that the buyer's choice was which closed vendor's roadmap to inherit rather than whether to inherit any single vendor's roadmap at all. That premise was approximately correct through most of 2024 and the front half of 2025. It is no longer correct in June 2026.
Three shifts that follow when an open-source coding agent reaches the same install-base scale as the closed-source platform leaders.
The lock-in cost structure changes from 'permanent' to 'optional.' The conventional procurement reading of a closed-source AI coding platform — Cursor, Claude Code, Codex, GitHub Copilot Workspace — has been that the lock-in is a feature, not a bug: the deeper the integration with the platform's IDE conventions, the higher the productivity ceiling. That reading is still true on the productivity-ceiling side, but the cost side of the lock-in calculation just got an alternative. A team that adopts OpenCode as the primary surface for a meaningful fraction of workloads — the air-gapped engagements, the regulated-vertical work, the on-prem deployments where the closed platforms aren't legal — now has a credible fallback the rest of the team can also adopt if the platform's pricing, roadmap, or commercial relationship moves in the wrong direction. The lock-in cost stops being a fixed expense and becomes a negotiable input. The buyer that walks into the next renewal cycle with a working OpenCode deployment on a third of the workload has more leverage than the buyer that walks in with nothing.
The air-gapped and regulated-vertical deployment story is no longer a workaround. Through 2025 most of the regulated-buyer conversations about AI coding ended at the same place: the production platform we want to use requires outbound calls to the vendor, our compliance posture doesn't allow that, so we'll wait for the next generation of the vendor's product. The waiting period has been 18 to 24 months for most of the regulated cohort. OpenCode collapses it. The agent runs locally, the model can run locally or against an isolated endpoint inside the customer's perimeter, the tool surface respects the customer's process boundary, and the entire stack is auditable because the source is in the customer's hands. The financial-services, healthcare, government, and defense engagements that were paused on AI coding through 2025 are now in scope for production deployment this quarter — provided the customer pairs the agent with the eval discipline and the senior-review queue that the workload requires.
The model-agnostic routing premise gets a reference implementation. Every honest multi-vendor routing strategy for the last 18 months has assumed the routing layer treats Cursor, Claude Code, Codex, and the open-source agents as peer endpoints with workload-specific selection. The open-source side of that sentence has been aspirational — the open-source options weren't credible production replacements for the workload classes the closed platforms covered well. OpenCode changes that. The routing layer can now point real production traffic at an open-source agent for the workload classes where it's the right answer (cost-sensitive workloads, air-gapped workloads, workloads where the closed platform's pricing is the binding constraint), and the buyer's negotiating leverage on the closed platforms moves accordingly. The vendor that knows the buyer has a credible open-source path has to price as if the buyer might take it.
What changes about the multi-vendor routing strategy
Four shifts that follow when an open-source coding agent is a credible peer endpoint in the routing matrix rather than a long-tail fallback.
The cost-per-successful-task floor moves down on the open-source-eligible workloads. The closed-source platforms charge per seat and per call against a usage envelope. OpenCode running against a customer-owned model endpoint charges only the model's per-token rate. For workloads where the model gap doesn't matter — the bulk-volume tier of routine coding work, large-scale codebase analysis, batch refactors — the open-source path is materially cheaper. The buyer whose FinOps decomposes cost-per-successful-task per workload class can route the cost-sensitive workloads to the open-source agent and reserve the premium platforms for the workloads where the model lead actually matters. The cost dashboard moves; the model-quality dashboard does not.
The eval matrix has to grade open-source-agent-flavored failure modes specifically. OpenCode against an open-weights model (DeepSeek V4 Pro, Llama 4 Maverick, Qwen 3.5) produces a different shape of failure mode than Claude Opus 4.8 in Claude Code or GPT-5.5 in Codex. The eval matrix that grades the platform honestly on the customer's workload needs a column for each provider-and-model pairing, with gold sets that exercise the cases the open-weights side is known to handle worse (the very-long-horizon agentic trajectories, the very-novel-domain reasoning tail) and the cases where it's competitive (the bulk-volume routine work, the well-bounded refactor classes). The buyer whose eval discipline aggregates to we run the published benchmarks and pick the highest score will under-route to open-source for cost-sensitive workloads where it would actually win on the buyer's specific codebase.
The portability layer over MCP, ACP, and the model-agnostic provider matrix is the new platform. A buyer who designs the routing architecture around MCP for tool-and-data connections, ACP for editor-agent integration, and a model-agnostic provider matrix for the LLM endpoint gets a stack where the closed-source platforms, the open-source agents, and the customer's in-house agents all interoperate through the same three protocols. The portability is not a fallback; it's the architecture. The buyer who designs everything platform-native to a single closed vendor's surfaces accepts the lock-in cost. The buyer who designs everything against the three protocols spends a modest engineering tax up front and keeps the optionality for the rest of the platform cycle.
The in-house agent question changes from 'too hard' to 'tractable.' Some workloads — security-sensitive internal automation, domain-specific coding workflows, the long tail of workflows that the off-the-shelf platforms don't cover — genuinely require an in-house agent. Through 2024 and most of 2025, building one of those from primitives was a multi-quarter platform-engineering project. OpenCode, used as the runtime substrate, compresses the build to the customer designs the workload-specific tool surface, the rubrics, the success criteria; the agent runtime is OpenCode; the integration into the customer's stack is ACP. The in-house agent stops being an alternative to buying and starts being a complement to it, scoped to the workloads where the differentiation matters.
What this does not change
Three honest caveats, because the temptation reading 161,000 stars and 7.5M MAU will be to over-rotate to open-source.
It does not eliminate the workload-specific eval discipline. An open-source agent paired with a strong open-weights model can match the closed platforms on a subset of workloads and falls behind on others. Which subset, on the customer's specific codebase, is an empirical question. The eval matrix that grades the open-source path honestly is the same eval matrix that grades the closed platforms honestly — the buyer who skips it will route to the open-source agent on workloads where it underperforms and stay on the closed platforms for workloads where they overpay.
It does not eliminate the senior-review queue. A more affordable, more portable, more auditable agent is still an agent whose hardest failure modes have to be caught by humans whose judgment is calibrated to the workload. The senior-review queue's existence is not contingent on which agent platform is upstream; the queue's calibration has to be tuned to the specific agent's failure-mode shape. The teams that adopt OpenCode and skip the queue calibration will get the cost savings and the incident-review consequences in the same quarter.
It does not collapse the closed-source platforms. Cursor, Claude Code, Codex, and GitHub Copilot Workspace are not going away. The integration depth they offer — the IDE conventions, the agentic primitives, the in-house frontier-tier models, the platform-level effort controls — is real, and for the workloads where it matters the closed platforms remain the right answer. The honest 2026 read is that the AI coding stack is a portfolio of closed-source platforms, open-source agents, and in-house surfaces interoperating through open protocols, not a single-vendor commitment in either direction.
Where Sonnet Code fits
A credible open-source coding agent at the top of the install-base chart is the easy half of the portability story. The hard half is the engineering and human-judgment work that turns we deployed OpenCode for the air-gapped engagement into the routing matrix is honest, the eval discipline is calibrated for each provider-and-model pairing, the in-house agent surfaces extend the runtime where the workload warrants it, and the senior-review queue is calibrated for the open-source-agent-flavored failure modes specifically. AI development at Sonnet Code is the engineering half: designing the routing layer that treats OpenCode, Claude Code, Cursor, Codex, and the in-house surfaces as peer endpoints with workload-specific selection; deploying OpenCode into regulated and air-gapped engagements with the audit, governance, and observability surfaces the customer's compliance posture requires; extending the agent runtime with workload-specific tool surfaces over MCP; and wiring the FinOps attribution at agent-action granularity so the cost-per-successful-task per provider-and-model pairing is a first-class dashboard rather than a reconstruction project. AI training is the human-judgment half: senior engineers and domain experts who author the gold sets that grade each provider-and-model pairing honestly on the customer's codebase, calibrate the senior-review queue for the open-source agent's failure modes specifically (which differ from closed-platform failure modes), author the rubrics that the eval harness runs against, and serve as the senior-judge pool whose calibrated decisions make the routing strategy compound rather than oscillate.
The open-source coding-agent tier just stopped being a long tail and became a credible peer endpoint in every honest routing strategy. The teams that walk into Q3 with the routing matrix extended, the eval discipline calibrated for each provider-and-model pairing, the air-gapped and regulated workloads in scope for production, and the senior-review queue tuned for the new failure-mode shape are the teams that turn the portability premise into a compounding cost-and-capability advantage through the back half of 2026. The teams that treat OpenCode as the cheap fallback for the workloads the real platforms don't want will discover, a renewal cycle later, that the buyer down the road who treated it as the portability anchor is paying meaningfully less for the same quality on the workloads where the closed platforms charge a premium they no longer have to.
