LaunchedEditorial Listing

OpenCode

Anomaly · Open-Source AI Coding Agent for Terminal, Desktop & IDE

Open OpenCode

OpenCode is a free, MIT-licensed AI coding agent from Anomaly (the team behind SST) that reads your codebase, edits files, and runs commands from a terminal UI, a desktop app, a browser, or ACP-compatible editors such as Zed. It suits developers who want to choose their own model: providers from the Models.dev catalog, local models, or an existing GitHub Copilot or ChatGPT Plus/Pro subscription. The tradeoff is that the software is free but model usage is not, it takes more setup than an AI editor like Cursor, and the current V2 release still lacks some V1 features.

PricingFree
Setupmedium
Runs onDesktop · API
APIYes
Open sourceYes
DocsYes
CategoryCoding
Open SourceTerminalAI CodingModel-AgnosticCLIMulti-AgentMCP

Best for

Developers who want an open-source coding agent they can run in the terminal, a desktop window, or a browser, with any model provider and undo for agent changes

Not ideal for

Developers who want inline autocomplete and a polished editor with minimal configuration (Cursor fits better), who rely on V1-only features such as session sharing or LSP, or who want to use a Claude Pro/Max subscription

Who it's for

Developers who want a model-agnostic, terminal-first AI coding agent without IDE or vendor lock-in

Capabilities

  • Build agent (tools allowed by default; asks before .env reads or access outside the workspace) and Plan agent (cannot edit normal project files)
  • Ordered allow, ask, and deny permission rules (last match wins) to require approval for edits, commands, or specific paths
  • Terminal UI, desktop app (macOS, Windows, Linux), and a browser UI via one-time opencode pair links, served by a shared background server
  • ACP agent mode (opencode acp) for editors such as Zed
  • Providers from the Models.dev catalog, including OpenAI, Anthropic (API key), Google, Amazon Bedrock, Google Vertex, and Azure
  • Automatic discovery of local Ollama, LM Studio, and vLLM models; other OpenAI-compatible runtimes via a custom provider
  • GitHub Copilot device sign-in and OpenAI Codex device-code sign-in (ChatGPT Plus/Pro)
  • Git-based snapshots with /undo and /redo for agent-made changes
  • General and Explore subagents for delegated research and read-only code search
  • MCP server support (local stdio and remote Streamable HTTP with OAuth)
  • Headless mode (opencode run) for scripts and CI, plus a client SDK (@opencode/client)
  • V1 only: VS Code/Cursor/Windsurf/VSCodium extension, session share links, LSP diagnostics, and the /opencode GitHub comment integration

Limitations

  • The tool is free but models are not: you pay your provider, Zen, or a Go plan unless you run local models
  • In V2 the Build agent runs tools, including shell commands and edits, without asking by default; add ask or deny rules if you want approvals
  • V2 does not yet support session sharing or language servers (LSP), V1 plugins do not run, and only AGENTS.md is read (no CLAUDE.md fallback)
  • No documented Claude Pro/Max login; Claude models need an Anthropic API key or a gateway
  • No inline autocomplete or tab-complete suggestions; interaction is prompt-based
  • Output quality depends heavily on the model you connect
  • Snapshots require a Git repository, skip git-ignored files and untracked files over 2 MiB, and are a convenience rather than a backup
  • V2 does not support Windows package managers; Windows users install standalone binaries (V1 still offers Scoop and Chocolatey)

Use cases

  • Refactoring and editing code across multiple files from the terminal without switching to a GUI editor
  • Keeping inference on local hardware with Ollama, LM Studio, or vLLM for privacy-sensitive code
  • Reusing an existing GitHub Copilot or ChatGPT Plus/Pro subscription as the backing model instead of adding a separate AI tool cost
  • Exploring a codebase and drafting a plan with the Plan agent, which cannot edit project files, before switching to Build
  • Automating code tasks in scripts and CI jobs with opencode run

Our take

OpenCode's core bet is that a coding agent should not be tied to one model vendor or one editor. V2 makes that concrete with one background server behind the terminal, desktop, browser, and ACP front ends, and with ordered permission rules. Note the V2 defaults: Build runs tools without asking unless you add ask or deny rules, while Plan cannot edit project files, so it is the safer place to review an approach first. Git-based snapshots let you undo a multi-file edit that misses the mark, but the V2 docs call them a convenience, not a backup, so keep using version control. The trade-off is setup and transition cost: you choose and pay for a model, there is no inline autocomplete, and V2 has not yet ported session sharing, LSP, or V1 plugins. If you value model choice and an open codebase over an out-of-the-box editor, OpenCode fits well. If you want the fastest path to AI-assisted coding with minimal setup, Cursor or Windsurf will serve you better.

Who should use it

Developers who work primarily in the terminal, want to choose their own LLM provider or reuse a Copilot or ChatGPT subscription, or need an open-source coding agent they can audit and run with local models.

Who should skip it

Developers who want IDE-native inline autocomplete and a polished out-of-the-box experience (Cursor or Windsurf fit better), or who mainly want to code with a Claude Pro/Max subscription (Claude Code supports that).

Strengths

  • Model-agnostic: the Models.dev provider catalog, local models, and Copilot or ChatGPT sign-in
  • One background server behind the terminal, desktop, browser, and ACP front ends, so you can switch interfaces without switching tools
  • Git-based snapshots let you undo agent file changes step by step
  • Ordered allow/ask/deny permission rules, and a Plan agent that cannot edit project files
  • Free and open source under the MIT license, with no per-seat fee for the tool
  • Headless mode, client SDK, and MCP support for automation and extension

Weaknesses

  • V2 Build runs tools without approval by default; approvals need explicit permission rules
  • V2 lacks session sharing, LSP, and V1 plugin support so far
  • No inline autocomplete or ambient tab-complete suggestions
  • You pay for model usage separately, and no Claude Pro/Max login is documented
  • Output quality varies significantly by model choice
  • Editor integration is through ACP (V2) or a split-terminal extension (V1), not deep editor-level integration like Cursor

OpenCode pricing

OpenCode

Free

  • MIT license: free to install and run
  • No per-seat fee for the tool
  • Bring your own provider API key or sign in with GitHub Copilot or ChatGPT Plus/Pro
  • Local models via Ollama, LM Studio, or vLLM at no API cost

OpenCode Zen

Pay-as-you-go

  • Curated, tested models behind one account, billed per request with no markup on model prices
  • Prepaid balance in $20 top-ups, plus a card processing fee
  • Auto-reloads $20 when the balance drops below $5 (can be changed or turned off)
  • Some models free for a limited time; some free models may use your data for training

OpenCode Go

$10/month

Billed monthly

  • Subscription for open coding models (Kimi, GLM, Qwen, DeepSeek, MiniMax, and others) plus a few smaller proprietary models
  • Usage limits set as dollar amounts with 5-hour, weekly, and monthly caps
  • Optional fallback to a Zen balance after the limits are reached

OpenCode Go Plus

$40/month

Billed monthly

  • Same model catalog as Go with higher usage limits

Enterprise

Custom (per seat)

  • Per-seat pricing
  • No token charges when you use your own LLM gateway

Note: Separate the software cost from the model cost. The OpenCode software is free (MIT). Model usage is billed by whichever source you connect: your provider's API rates, your existing GitHub Copilot or ChatGPT subscription, Anomaly's pay-as-you-go Zen gateway, or a Go plan ($10 or $40/month). Local models have no per-request cost. Enterprise is priced per seat. Go limits and model data-retention terms vary by model and may change; check opencode.ai/go for current allowances.

Technical specs

Modalities

Text, Code, Image (attachment for visual context)

Available models

OpenAI GPT models (API key, or ChatGPT Plus/Pro via Codex device-code sign-in)Anthropic Claude via API key (no documented Claude Pro/Max login)Google GeminiGitHub Copilot (device sign-in, GitHub.com or GitHub Enterprise)Amazon Bedrock, Google Vertex, and AzureDeepSeekGroqOllama, LM Studio, and vLLM local models (auto-discovered)Other OpenAI-compatible endpoints via a custom provider

Where OpenCode excels

Multi-file refactoring from the terminal

The Build agent edits across multiple files and runs shell commands in sequence, which suits refactors that span a module boundary or need coordinated changes a single-file prompt cannot handle.

Reviewing an approach before writing code

The Plan agent cannot edit normal project files, so you can let it explore the codebase and draft an approach, then switch to Build once you agree with it.

Privacy-sensitive coding workflows

With Ollama, LM Studio, or vLLM, model inference runs on your own hardware, which helps where sending code to cloud APIs is restricted.

Reusing an existing Copilot or ChatGPT subscription

OpenCode can sign in with GitHub Copilot or ChatGPT Plus/Pro, which avoids paying separately for another AI coding tool if you already subscribe.

OpenCode vs. competitors

OpenCode vs. Claude Code

Claude Code is Anthropic's terminal coding agent, built around Claude models and usable with a Claude subscription. OpenCode is also terminal-first but works with many providers and local models; it documents no Claude Pro/Max login, so Claude models in OpenCode need an API key. Choose Claude Code if you are standardizing on Claude; choose OpenCode for provider choice.

OpenCode vs. Cline

Both are open-source and bring-your-own-model. Cline lives mainly in an editor side panel (VS Code and forks, JetBrains) with per-step approvals by default; OpenCode is terminal-first, with desktop, browser, and ACP front ends, and its V2 Build agent runs tools without asking unless you add permission rules. Pick by where you want the agent to run and how much approval you want by default.

OpenCode vs. Cursor

Cursor is a full VS Code fork with deep editor-level integration: inline AI suggestions, multi-file agent edits, and background cloud agents. OpenCode is an agent that works alongside any editor but does not replace it. Cursor provides a more polished, lower-friction experience; OpenCode gives model flexibility and no editor lock-in.

OpenCode vs. GitHub Copilot

GitHub Copilot is primarily an inline autocomplete, chat, and agent tool tightly integrated with GitHub. OpenCode can use a Copilot subscription as its model source, so the two are not mutually exclusive: Copilot handles in-editor suggestions, OpenCode handles terminal-driven multi-step tasks.

OpenCode vs. Aider

Both are terminal-based and model-agnostic, but Aider focuses on git-diff workflows and git-native operations. OpenCode adds desktop and browser front ends, ACP editor support, a multi-agent system, a client SDK, and MCP support. Choose Aider for a minimal git-focused workflow; choose OpenCode for a broader integration surface.

Frequently asked questions

Is OpenCode free to use?

The software is free and open source under the MIT license. Model usage is a separate cost: you pay your LLM provider, reuse a GitHub Copilot or ChatGPT Plus/Pro subscription, buy pay-as-you-go access through OpenCode Zen, or subscribe to OpenCode Go ($10/month) or Go Plus ($40/month). Local models via Ollama, LM Studio, or vLLM have no per-request cost.

Should I use OpenCode Desktop or the terminal version?

Both are front ends to the same OpenCode agent, models, and configuration; the V2 docs describe the desktop app and the terminal UI as using the same client. Use the desktop app if you prefer a separate window to a terminal session. Use the terminal UI if you work over SSH or want to script tasks and CI jobs with opencode run. For access from a browser or another device, opencode pair prints one-time links to the web UI served by your local OpenCode server. V1 notes: the V1 docs recommend WSL on Windows, and the V1 desktop app on Windows needs the Microsoft Edge WebView2 Runtime.

How do I install OpenCode?

For V2, the current default: run curl -fsSL https://opencode.ai/v2/install | bash, or install @opencode/cli from npm, anomalyco/tap/opencode-v2 with Homebrew, or opencode-beta from the AUR; Docker images use versioned tags. V2 does not support Windows package managers, so Windows users download the standalone binary. The desktop app is a download for macOS (Apple Silicon and Intel), Windows, and Linux (.deb, .rpm). V1, which is still maintained, installs with the original opencode.ai/install script, opencode-ai on npm, Scoop, or Chocolatey. After installing, connect a provider with an API key or a supported sign-in.

What changed in OpenCode V2?

V2 introduces a new plugin API, new server and client APIs (the SDK is now @opencode/client), and one global cli.json in place of tui.json. It runs a shared background server for your user account, adds opencode pair for browser access, and auto-discovers local Ollama, LM Studio, and vLLM models. Not yet ported: session sharing, language-server (LSP) support, V1 plugins, and the CLAUDE.md fallback (V2 reads AGENTS.md only). The Plan agent now blocks edits to normal project files, and Build allows tools by default. V1 (1.x) is still maintained.

Can I use my Claude Pro or Max subscription with OpenCode?

OpenCode does not document a Claude Pro/Max login. Its V1 provider docs say Anthropic explicitly prohibits using Claude Pro/Max models in OpenCode and that the plugins enabling it stopped being bundled as of version 1.3.0; the V2 docs and homepage list only GitHub Copilot and ChatGPT Plus/Pro subscription sign-ins. Use an Anthropic API key or a gateway for Claude models.

Can OpenCode replace Cursor?

They solve related but different problems. Cursor is an AI-native editor with inline suggestions and deep editor integration. OpenCode is a coding agent that runs in a terminal, a desktop window, a browser, or an ACP-compatible editor, alongside the editor you already use. If you want a polished AI-first editor, use Cursor. If you want an open-source agent that works with many model providers, OpenCode fits better.

What is the difference between the Build and Plan agents?

In V2, Build is the default coding agent: tools are allowed by default, and it asks only before reading .env files or accessing paths outside the workspace. Plan explores and plans without editing normal project files (it may write OpenCode plan files), and its shell commands follow your permission rules. To require approval for edits or commands, add ask rules to your permissions. In V1, Plan instead asks before every file edit and shell command.

Can OpenCode run without sending code to the cloud?

Yes, if you use a local model through Ollama, LM Studio, or vLLM: inference then runs on your own hardware. OpenCode says it does not store your code or context data. V2 has no session sharing yet; in V1, share links upload the conversation and are public to anyone with the link, so keep sharing in manual or disabled mode for sensitive work.

Integrations & fit

Zed (ACP)VS Code, Cursor, Windsurf, VSCodium (V1 extension)OpenAIAnthropicGoogle GeminiAmazon BedrockGoogle VertexAzureGitHub CopilotGroqDeepSeekOllamaLM StudiovLLMGitHub ActionsMCP servers
Good fit forSolo / individual, Startup / small team
Pricing modelFree· No cost to start
See pricing on OpenCode →

Alternatives to consider

See the best AI coding agents →

About OpenCode

OpenCode V2 (2.0.x, first tagged in September 2026) is the default download on opencode.ai; V1 (1.x) is still maintained, and the V2 docs list three breaking changes: a new plugin API, new server and client APIs, and a single global cli.json in place of tui.json. In V2 a shared background server for your user account powers the terminal UI (TUI) and a web UI you can open from another device with one-time opencode pair links; a desktop app is available for macOS, Windows, and Linux; and opencode acp runs it as an Agent Client Protocol agent inside editors such as Zed. The VS Code, Cursor, Windsurf, and VSCodium extension that installs itself from the integrated terminal is documented for V1 only. Models come from the Models.dev provider catalog with an API key, from local Ollama, LM Studio, or vLLM servers that V2 discovers automatically (other OpenAI-compatible runtimes need a custom provider), from a GitHub Copilot device sign-in, or from OpenAI's Codex device-code sign-in, which the V2 docs label legacy and the homepage presents as ChatGPT Plus/Pro login. OpenCode documents no Claude Pro/Max login: its V1 provider docs say Anthropic prohibits it and the plugins stopped being bundled as of 1.3.0, so plan on an Anthropic API key for Claude models. Two primary agents ship by default. Build allows tools by default and asks only before reading .env files or accessing paths outside the workspace; Plan cannot edit normal project files (it may write OpenCode plan files), and its shell commands follow your permission rules. Permissions are ordered allow, ask, and deny rules where the last match wins, so you can require approval for edits or commands. General and Explore subagents handle delegated research and read-only searches. In a Git repository, snapshots power /undo and /redo of agent changes. V2 also runs headless with opencode run for scripts and CI, exposes a client SDK (@opencode/client), supports local and remote MCP servers, and reads AGENTS.md (not CLAUDE.md). Not yet in V2: session sharing, language-server (LSP) support, V1 plugins, and CLAUDE.md fallback. Anomaly sells optional model access on top: OpenCode Zen (pay-as-you-go at provider prices) and OpenCode Go ($10/month) or Go Plus ($40/month) for open coding models.

Are you the founder? Claim this listing →