Any Model, Any Job: Why CodeMantis Now Supports OpenCode

From Two Agents to Any Model

CodeMantis started as a native interface for a single coding agent: Claude Code. Then we added OpenAI Codex as a first-class second agent, for reasons I wrote about in Why CodeMantis Now Supports Two Coding Agents. The short version: an app that depends on one vendor's pricing decisions is one memo away from breaking its users.

Two agents was a good answer to that problem. But it was still an answer bounded by two subscriptions. Today we are shipping the one that isn't: OpenCode, our third first-class agent. It doesn't add a third vendor to the list — it removes the list entirely. With OpenCode, CodeMantis can drive any model OpenCode supports, from frontier open-weight releases to a model running entirely on your own laptop.

What OpenCode Is

OpenCode is a coding agent we wrap through the Agent Client Protocol (ACP) — the same pluggable AgentAdapterseam that made Codex a one-release addition. Where Claude Code and Codex each authenticate against one vendor's subscription, OpenCode is deliberately vendor-neutral. You point it at a provider, and it reaches whatever model that provider serves:

• OpenRouter — one API key, hundreds of models, from the latest Qwen, DeepSeek, and Llama releases to hosted frontier models.
• A local endpoint — Ollama or LM Studio running on your own hardware. No key, no network, nothing leaving your machine.
• OpenCode Zen — a free, hosted gateway to get started in seconds, or any custom OpenAI-compatible URL.

You pick OpenCode per session, exactly like the others — it just carries an ACP badge in the picker. And then everything you already know keeps working: tool approvals, session history, SpecWriter, the Assistant panel, per-task routing, and even Self-Drive. The agent underneath changed; the interface around it did not.

Flexibility Is the Whole Point

The reason we did this is simple: flexibility. Not every task deserves a frontier model, and not every frontier model is the best at every task. Some work is sensitive enough that it should never leave your machine. Some is cheap enough that a small open model does it perfectly. And sometimes the model you want to try simply isn't sold by Anthropic or OpenAI yet.

Until now, using those models meant leaving your tools behind — copying context into a different app, giving up the activity feed, the spec writer, the approval flow. With OpenCode, they come inside. You can run an open-weight model in the same three-panel window you use for Claude Code, with the same visibility into every file read, edit, and command it runs. The model is a setting; the workflow is constant.

The Same CodeMantis, Now Genuinely Open

“Open” is a word that gets stretched thin, so let me be precise about what it means here. It means you can run CodeMantis against a model that is fully open-weight. It means you can run that model locally— no API key, no telemetry, no request ever leaving your network — and still get the full graphical agent experience. And it means you are not locked to any single vendor's catalog, pricing, or roadmap.

That is the throughline of the whole project. CodeMantis is the interface, not the agent. You bring the intelligence you want; we bring the workspace it runs in. Claude Code, Codex, and OpenCode are three doors into the same room — and with OpenCode, one of those doors opens onto the entire open-model ecosystem.

The Best Model for the Best Job

This is where three agents stops being a list and starts being a strategy. CodeMantis already lets you route different task categories to different agents in Settings › Agents — main chat, SpecWriter, the Assistant panel, and the in-app Help assistant can each point at a different agent. OpenCode simply becomes another option in every one of those dropdowns.

So you might write specs with Claude (strong at long-form reasoning), run hot main-chat iterations on Codex where you have subscription headroom, and send a batch of mechanical refactors to a cheap open model through OpenCode — all in one project, all visible in the same 7-day usage-split card. The best model for the best job, without leaving the app to get there.

What's Next: Multi-Agent Orchestration

Per-task routing is a static map: you decide up front which agent handles which category. The next step is to make that dynamic. We're building multi-agent orchestration — a layer that lets several agents collaborate on a single piece of work.

Picture a frontier model drafting a plan and reviewing the result, while a fast, inexpensive model does the bulk implementation in the middle, and a local model handles anything that must stay on your machine. A mentor agent and a primary agent, a planner and a builder, a reviewer and an author — orchestrated automatically, with the same approval and activity surfaces you already trust. Three interchangeable agents are the raw material this is built from.

What's Next: Automated Cost Optimization

The flip side of “use the best model” is “don't overpay to do it.” Once CodeMantis can move work between a frontier model, a metered API model, and a free local model, it can start doing that on your behalf. We're working on automated cost optimization: routing each step to the cheapest model that can actually do it well, escalating to a stronger model only when the work demands it, and keeping you inside a budget you set.

The goal is to make you cost-aware without making you cost-obsessed. You should be able to say “spend up to this much, prefer local when you can, and reach for a frontier model when it genuinely matters” — and have the environment honor that, task by task. OpenCode is the piece that makes it possible, because a truly cost-aware router needs a free option and an open catalog to route into.

The Open Agentic Coding Environment

Add it up and a picture forms. A native app that launches in seconds and stays out of your way. Three first-class agents, from frontier subscriptions to fully local open models, behind one consistent interface. Per-task routing today; orchestration and cost optimization next. All of it free, fair-source, and built to outlast any single vendor's pricing cycle.

That is what we mean when we say CodeMantis is becoming one of the most powerful, flexible, and genuinely open agentic coding environments available. OpenCode isn't a third logo on a slide. It's the moment CodeMantis stops being about which agent you picked, and starts being about the fact that you never have to.