OpenCode 2.0: Code Mode, Background Agents & Upgrade

OpenCode is one of the most widely used open-source AI coding agents, and version 2.0 is its biggest change yet. The New Stack's Paul Sawers headlined his 12/10/2026 report "A major overhaul": OpenCode 2.0 puts its terminal, desktop and web apps on one shared service. Third-party write-ups of the release notes fill in the detail, and OpenCode's own changelog documents the weeks since.

Four changes matter most. First, the shared background service: one process that every front end connects to, so a session started in the terminal is the same session you see in the desktop app. Second, Code Mode, a minimal JavaScript interpreter that lets an agent write a short script chaining many tool calls in one round trip. Third, background subagents and shell commands that run while you keep working. Fourth, a rebuilt API and an SDK that make the agent embeddable in your own tools.

The price of these changes is breakage. Plugins written for 1.0 do not run on 2.0, the server API has been replaced and the TUI configuration format has changed. We cover the upgrade path step by step below. If you are comparing agents rather than upgrading one, start with our guide to the best AI coding agents.

How we sourced this: we could not retrieve OpenCode's own 2.0 announcement or the GitHub release notes. This piece relies on The New Stack (headline and byline only were retrievable), DiarioBitcoin's 12/10/2026 report, the explainx.ai upgrade guide, and OpenCode's official changelog for versions 2.0.26 to 2.0.29. We have no benchmark data and have not run version 2.0 ourselves, so we describe design intent, not measured results.

OpenCode is an open-source AI agent harness. You give it instructions in natural language and it investigates code, edits files and runs commands on your behalf. The harness sits between the model and your development environment, brokering tool calls, file operations and command execution. Because the harness is separate from the model, you can swap providers (Claude, GPT, Gemini or a local model) and keep the same working habits. That vendor independence is its main selling point against single-vendor tools.

The tool is made by the Anomaly team and is published as open source. Our review of the AI coding agents productivity study explains why choice of harness can matter as much as choice of model: the loop around the model decides how much work survives review. OpenCode's philosophy is to make that loop programmable.

The release arrives in a crowded week for agent tooling. Google has just published a long unattended coding run with Gemini 4 Argon on the ADK codebase, and open workspaces such as the one we covered in our Buzz explainer treat agents as team members. OpenCode 2.0 is the open-source harness world's answer to the same pressure: agents that run for a long time, in the background, across several surfaces.

The headline architectural change is that OpenCode 2.0 runs a single shared background server automatically. The terminal UI, the web interface and the desktop app are now clients of that server rather than separate programmes each owning their sessions. Sessions are shared across front ends, so you can start a task in the terminal and check it from the desktop app.

What the service enables

• Pairing. A /pair command (or opencode pair) connects other applications to the service. Native apps are reported to be in development.
• Automatic discovery. Scripts using the @opencode/client package can find the local service automatically, which DiarioBitcoin highlights for scheduled tasks.
• A rebuilt API. The team rewrote the earlier API, which had grown unevenly, to cover a wider range of operations. OpenCode can call its own API, for example to create a git worktree. The service is invoked with opencode api and can be exposed to other machines.

The change matters because it removes a long-standing limitation of terminal agents: the work lived and died with the window. With a shared service, a cron job, a desktop app and a terminal can all address the same agent state. It is the same direction as Claude's tooling, which we described in Claude Code cross-session messaging.

Since launch, OpenCode's changelog shows the service model being used for remote work. Version 2.0.27 (12/10/2026) added a confirmation prompt before the first remote pairing, and 2.0.29 (14/10/2026) added remote device pairing from Settings with a QR code or copyable link. A security note: remote pairing exposes an agent that can run commands on your machine, so treat a pairing link like a credential. The --yes flag that skips the confirmation prompt is convenient for scripts and unwise in interactive use.

Code Mode, shipped as @opencode/codemode, is the feature most likely to change how agents feel to use. Today, most agents call tools one at a time: the model asks for a tool, waits for the result, reads it, then asks for the next one. Every call costs a model turn and fills the context window with intermediate output.

Code Mode replaces that with a minimal JavaScript interpreter. The agent writes a short script that chains several tool calls in one round trip. MCP servers and OpenAPI endpoints become callable functions inside the script. DiarioBitcoin's example pulls bugs from GitHub into Linear in a single pass. All MCP servers are opted in by default.

Why it could help

• Fewer round trips. A loop over fifty issues is one script rather than fifty model turns.
• Less context bloat. Intermediate data stays inside the script and only the summary returns to the model.
• Lower cost. Fewer turns means fewer billed tokens when you pay per token.

The creator we embedded above describes it as chaining hundreds, even a thousand, tools in a single pass. We have not seen that figure in any primary source, so treat it as the creator's characterisation. The sources we could verify state the goals as less tool-call overhead and less context bloat, and explainx.ai is explicit that these are design goals rather than measured results.

The risks

Letting a model write and run scripts that call every connected tool is powerful and risky. With all MCP servers enabled by default, a script can reach tools you connected months ago and forgot. The security question is the one we raised in our coverage of AI agent security: an agent that can compose actions can compose them badly. Review which MCP servers are connected, disable the ones you do not need for a given project, and keep permission prompts on for anything that writes or deletes. Version 2.0.28 added a per-project auto-accept for permissions (toggled with mod+shift+a); use it only in projects where the blast radius is small.

Version 2.0.27 added built-in worktree tools for Code Mode, letting scripts create, list and remove git worktrees. That pairs naturally with parallel agents: each task gets its own worktree, so two agents never edit the same checkout.

The second headline feature is asynchronous work. In 2.0, subagents and shell commands can run in the background while you keep prompting. The shell tool can run commands asynchronously and notify the agent when they finish, and Ctrl+B moves a running foreground task to the background. Background subagents can be delegated automatically or manually, and can use a different model from the main agent.

A German-language source notes that background subagents first appeared earlier, in the 1.15 series in May 2026, so 2.0 builds on that rather than inventing it. What is new is the combination with the shared service: a background job is no longer tied to one terminal window.

The builder-and-reviewer pattern

The video above shows a pattern worth copying: one model builds while another reviews. Because background subagents can use a different model, you can pair a fast, cheap model for drafting with a stronger one for review, or vice versa. This echoes what Google's engineers found in the Argon experiment: the agent that explores is not the one that should decide what ships. If you want a free model to try in either role, OpenCode's changelog lists StepFun Step 5 Preview among its free models as of version 2.0.26.

Plan mode versus build mode

The creator also highlights the plan and build split, previewing what the agent intends to do before it edits files. It is a small feature with a large effect on trust, and it is consistent with the plan-first modes we covered in Manus plan mode and the Antigravity 2 plan review.

OpenCode 2.0 rebuilds more than 80 of its own features as internal plugins. TUI plugins move from experimental to stable, and all plugins support hot reloading, so a new plugin can be used in the same session without a restart. The creator in our embedded video describes the agent adding its own add-ons mid-conversation; that is a plausible consequence of hot reloading, but we could not confirm it in a primary source.

The SDK, @opencode/sdk, uses the same code that powers the CLI. That allows trimmed custom builds that run on servers or in Durable Objects. An optional Effect-based API is still in development. For teams, the SDK is the route to embedding an OpenCode-style agent in internal tools, which parallels the TypeScript plugin model in Claude Code mods and the hooks system in Claude Code function hooks.

The trade-off is compatibility. Making plugins first-class changed their interfaces, which is why 1.0 plugins do not work in 2.0. If you rely on community plugins, check each one for a 2.0 release before you upgrade.

OpenCode's official changelog lists point releases from 2.0.26 to 2.0.29 between 08/10/2026 and 14/10/2026. The pace is fast: four releases in a week. The list below is taken directly from that page.

The changelog labels no breaking changes in this range, but it does list behaviour changes you should know about: the default streamed-chunk timeout rose from 5 to 15 minutes; opencode pair --remote now asks for confirmation (use --yes or -y to skip); projects whose directories no longer exist are hidden automatically and return if reopened; the VS Code extension stopped passing the removed --port argument to the V2 CLI; and Azure connections no longer query resources at startup and ask for the resource name instead.

The automatic-continuation feature is a quiet but practical fix. When a response hits an output limit, OpenCode now continues rather than stopping, preserving partial output. Long-output models, such as those we covered in the Gemini 4 Argon launch review with its 1 million token output ceiling, are exactly where this matters.

The explainx.ai upgrade guide lays out a seven-step path. We recommend following it in order and not skipping the backup.

1. Update to the latest 1.x release. Version 1.19.0 (11/10/2026) is described as the bridge release to 2.0.
2. Back up your config directory and custom plugins. Copy them somewhere outside the project.
3. Run opencode upgrade --major.
4. Review the migration guide and the resulting diff before accepting changes.
5. Reinstall or rewrite plugins. 1.0 plugins do not work in 2.0.
6. Update scripts that call the old server API, which has been replaced.
7. Convert TUI config from tui.json to the new JSON format.

Two further notes from the 1.19.0 release: updates are no longer installed automatically, and the terminal UI has a new /update command. The video above also warns viewers about an upgrade caveat, so read the migration guide even if you are an experienced user. If you run OpenCode in CI or on a team server, upgrade a single machine first and run your normal tasks before rolling the change out.

These are suggestions, not tested results. We have not benchmarked them.

• Overnight refactor with a reviewer. Start a long refactor in the background with one model and a second background subagent on a stronger model reviewing each commit. Compare with the discipline in Google's Argon ADK experiment: write rules down, measure before editing and keep a human to say no.
• Issue triage in one script. Use Code Mode to read new issues, label them and open tasks in your tracker in a single pass, as in the GitHub-to-Linear example.
• One worktree per task. Use the worktree tools so parallel agents never share a checkout.
• Scheduled maintenance. Use @opencode/client from a cron job to run dependency updates through the shared service, then review the diff each morning.
• Remote check-ins. Pair a phone or second machine to watch a long run, with the security caveat above.

If your work is not coding at all, a general agent may suit you better; see our guides to Hermes Agent and OpenClaw 2.0.

Against Claude Code. Claude Code is tightly integrated with Anthropic models and offers hooks, plugins and cross-session messaging. OpenCode's edge is provider freedom and an open-source licence, while Claude Code's is polish and first-party model integration. Code Mode is OpenCode's answer to the tool-call overhead that every agent shares.

Against Google Antigravity. Antigravity, covered in our Antigravity 2 review, ties you to Google's models and subscription tiers but offers persistent goals through /goal mode. OpenCode is model-agnostic and can use Gemini through Vertex, as its recent releases show.

Against workspaces such as Buzz. Tools like Buzz put agents in a chat workspace. OpenCode focuses on the developer's own machine and now exposes a service that other tools can build on.

For a broader ranking, see best AI coding agents.

• No primary release notes. We could not retrieve OpenCode's own 2.0 announcement or the GitHub release page. Details come from secondary reports, so check the official notes before acting.
• The New Stack article was only partly readable. We could confirm its headline, author and date but not its body.
• No benchmarks. Claims about less overhead and less context bloat are design goals. We found no independent measurements.
• Licensing unconfirmed. We have not confirmed the licence of every 2.0 package.
• Rollout confusion. The New Stack reportedly noted that the drawn-out rollout confused developers about whether 2.0 was stable. The frequent 2.0.x releases suggest the product is still moving quickly.
• Broad defaults. With all MCP servers enabled by default for Code Mode, review your connections before running unattended jobs.
• Creator claims. Statements in the embedded video, such as chaining a thousand tools, are the creator's own and unverified here.

OpenCode 2.0 is a sensible, ambitious step: it turns a terminal tool into a service, gives agents a cheaper way to use tools and lets work continue while you do something else. If you already use OpenCode, the upgrade is worth doing, but do it deliberately, with a backup, a plugin check and a read of the migration guide. If you are choosing a first agent, the case for OpenCode rests on openness and model choice rather than on any measured speed-up.

The wider pattern is the one to watch. Agents are moving from windows to services, from one call per turn to scripts, and from foreground to background. The teams that get the most from that shift will be the ones that pair it with the unglamorous disciplines in this week's other big agent story: clear rules, measurement and human review.