Submit a tool →
LaunchedEditorial Listing

OpenCode

Anomaly · Open-Source AI Coding Agent for the Terminal

Open OpenCode

An open-source AI coding agent built by the team behind SST. Runs in the terminal, desktop app, or as an IDE panel — and works with any of 75+ LLM providers. Uses a multi-agent architecture with Build and Plan modes for controlled or fully autonomous code editing.

PricingFree
Setupmedium
Runs onDesktop
APINo
Open sourceYes
DocsYes
CategoryCoding
Open SourceTerminalAI CodingModel AgnosticCLIMulti-AgentMCP

Best for

Developers who want a terminal-based AI coding agent with no vendor lock-in, the ability to bring any LLM provider, and undo control over agent file changes

Not ideal for

Developers who want deep IDE integration with inline autocomplete and minimal configuration — Cursor or Windsurf provide a more polished out-of-the-box experience

Who it's for

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

Capabilities

  • Build mode (full tool access: file edits, bash commands) and Plan mode (read-only analysis, explicit approval required before any writes)
  • 75+ LLM provider integrations: OpenAI, Anthropic, Google, AWS Bedrock, Azure OpenAI, GitHub Copilot passthrough, GitLab Duo, Groq, DeepSeek, Ollama, LM Studio, and more
  • File snapshot system for step-by-step undo of agent-made changes
  • Three specialized subagents (General, Explore, Scout) for delegated tasks within a session
  • LSP (Language Server Protocol) integration for code intelligence
  • MCP (Model Context Protocol) server support for connecting external tools
  • GitHub Copilot and ChatGPT Plus/Pro subscription passthrough — reuse existing subscriptions
  • Shareable session links for team review and collaboration
  • Multi-session concurrency on the same project
  • Non-interactive scripting mode for single-prompt CLI automation in pipelines

Limitations

  • File snapshot system causes slow indexing and significant disk usage on large repos or projects with many submodules
  • No inline autocomplete or tab-complete suggestions — interaction is prompt-based, not ambient like Copilot
  • Output quality varies significantly by model choice since there is no single optimized provider path
  • IDE integration is a floating panel, not deep editor integration — less seamless than Cursor's native experience
  • Plan mode approval gates add friction for users who prefer fully autonomous execution without manual confirmation

Use cases

  • Refactoring and editing code across multiple files from the terminal without switching to a GUI editor
  • Running AI coding workflows in air-gapped or privacy-sensitive environments using local models via Ollama
  • Reusing an existing GitHub Copilot or ChatGPT Plus subscription as the backing model instead of adding a separate AI tool cost
  • Analyzing and planning architecture changes in read-only Plan mode before committing to any edits
  • Automating repetitive code tasks via non-interactive CLI scripting in CI pipelines

Our take

OpenCode's core bet is that developer tooling should not be locked to a single model provider or IDE vendor. The Build/Plan agent split is well-designed: Plan mode lets you reason about what to change before anything is written, which is genuinely useful on complex refactors where you want to validate the approach first. The file snapshot system means you can safely let the agent run a multi-file edit and undo the whole thing if the output misses the mark. The trade-off is real: OpenCode does not have the polished, zero-configuration feel of Cursor, and it does not provide ambient tab-complete suggestions like Copilot. If you value portability and model flexibility over out-of-the-box experience, 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 need an open-source coding agent they can audit, customize, and run fully air-gapped with local models.

Who should skip it

Developers who want deep IDE-native AI integration with inline autocomplete and a polished out-of-the-box experience — Cursor or Windsurf are better fits for that workflow.

Strengths

  • Fully model-agnostic: connect OpenAI, Anthropic, GitHub Copilot, local Ollama models, and many more providers
  • File snapshot system lets you undo agent file changes step by step — safer than tools with no rollback
  • Build/Plan mode split: Plan mode is read-only, so you can reason through an approach before any writes happen
  • Free and open source under MIT license — no per-seat subscription for the tool itself
  • Reuse existing GitHub Copilot or ChatGPT Plus subscriptions as the backing model
  • MCP server support for extending with external tools and data sources

Weaknesses

  • No inline autocomplete or ambient tab-complete suggestions — interaction is prompt-driven, not always-present like Copilot
  • File snapshot system causes slow indexing and high disk usage on large repos or projects with many submodules
  • Output quality varies significantly by model choice — no single optimized provider path
  • IDE integration is a floating panel added to existing editors, not deep editor-level integration like Cursor
  • Plan mode approval gates add friction for users who prefer faster, fully autonomous execution

OpenCode pricing

OpenCode

Free

  • MIT license — free to install and self-host
  • No per-seat subscription for the tool
  • Bring your own LLM provider API key
  • Local models via Ollama at no API cost

OpenCode Zen

Low cost (see opencode.ai)

  • Curated subscription for pre-tested popular models
  • Simplifies model selection without managing API keys
  • Official paid layer from Anomaly
  • Specific pricing listed on opencode.ai

Note: The core tool is always free. API costs are billed directly by your chosen LLM provider. OpenCode Zen is Anomaly's managed model subscription option for users who prefer not to manage provider keys.

Technical specs

Modalities

Text, Code, Image (attachment for visual context)

Available models

OpenAI GPT-4o, o3, o4-miniAnthropic Claude Opus, Sonnet, HaikuGoogle GeminiGitHub Copilot (passthrough subscription)DeepSeekGroqOllama local modelsLM StudioAny OpenAI-compatible endpoint

Where OpenCode excels

Multi-file refactoring from the terminal

Build mode edits across multiple files and runs shell commands in sequence — useful for refactors that span a module boundary or require coordinated changes a single-file prompt cannot handle.

Architecture planning before writing code

Plan mode is read-only and requires explicit approval before any file is written. Useful for reasoning through a design decision and reviewing a proposed approach before the agent makes changes.

Air-gapped or privacy-sensitive coding workflows

With Ollama, OpenCode runs entirely on local hardware with no data leaving your machine — practical for environments where sending code to cloud APIs is restricted or prohibited.

Reusing an existing Copilot or ChatGPT subscription

OpenCode supports GitHub Copilot and ChatGPT Plus/Pro as backing models via passthrough — useful if you already subscribe and want to avoid paying separately for another AI coding tool.

OpenCode vs. competitors

OpenCode vs. Cursor

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

OpenCode vs. GitHub Copilot

GitHub Copilot is primarily an inline autocomplete and chat tool tightly integrated with the GitHub ecosystem. OpenCode is a full agentic system that executes multi-step tasks, edits files, and runs shell commands. Copilot is always-present in the editor and easier to start with; OpenCode handles deeper agentic tasks but requires deliberate invocation.

OpenCode vs. Aider

Both are terminal-based and model-agnostic, but Aider is Python-based with a focus on git-diff workflows and stronger git-native operations. OpenCode has a richer TUI, desktop app, IDE panel extensions, a multi-agent system, and MCP support. Choose Aider for a minimal git-focused workflow; choose OpenCode for a richer feature set and broader integration surface.

Frequently asked questions

Is OpenCode free to use?

Yes. The tool itself is free and open source under the MIT license. You pay only for the LLM API provider you connect — or use local models via Ollama at no API cost.

Can OpenCode replace Cursor?

They solve related but different problems. Cursor is a full AI-native IDE with inline suggestions, deep editor integration, and cloud background agents. OpenCode is a terminal-first coding agent that augments your existing editor as a floating panel. If you want a polished AI-first IDE, use Cursor. If you want a flexible, open-source agent that works with any editor and any LLM, OpenCode fits better.

Does OpenCode work with GitHub Copilot?

Yes. OpenCode supports GitHub Copilot as a backing model via subscription passthrough — you can reuse an existing Copilot subscription instead of paying for a separate API key.

What is the difference between Build mode and Plan mode?

Build mode gives the agent full access to edit files and run shell commands. Plan mode is read-only — the agent can analyze code and reason about what to change, but cannot write files or run commands without your explicit approval. Plan mode is useful for reviewing a proposed approach before committing to changes.

Can OpenCode run without an internet connection?

Yes, if you use a local model via Ollama or another local inference server. In that configuration, all inference runs on your own hardware with no network calls to external APIs.

Integrations & fit

VS CodeCursorWindsurfVSCodiumOpenAIAnthropicGoogle GeminiAWS BedrockAzure OpenAIGitHub CopilotGitLab DuoGroqDeepSeekOllamaLM StudioCloudflare AI GatewayMCP servers
Good fit forSolo / individual, Startup / small team
Pricing modelFree· No cost to start
See pricing on OpenCode →

Alternatives to consider

Cursor

Anysphere

VS Code developers who want multi-file AI editing, autonomous background agents, and model flexibility — not a plugin layered on top of an existing editor

Freemium
GitHub Copilot

GitHub (Microsoft)

Developers on GitHub who want AI autocomplete and PR summaries embedded in their existing IDE

Paid
Codeium

Exafunction

Developers wanting free, fast AI autocomplete in their existing IDE without switching tools

Freemium
Windsurf

Codeium

Developers who want an AI agent that can autonomously plan and execute larger coding tasks

Freemium

About OpenCode

OpenCode is a terminal-first coding agent with no account lock-in and no required proprietary model. Connect it to any LLM via 75+ provider integrations — including GitHub Copilot or ChatGPT Plus as a passthrough subscription, or local models via Ollama for fully air-gapped workflows. It uses a multi-agent system: the Build agent has full file-edit and bash access; the Plan agent is read-only for architecture analysis; three specialized subagents (General, Explore, Scout) handle delegated subtasks. A file snapshot system lets you undo agent changes step by step. OpenCode installs as a floating panel inside VS Code, Cursor, and Windsurf via IDE extensions, but it does not replace those editors — it augments them. The main tradeoff versus tools like Cursor is that OpenCode requires more configuration and lacks deep editor-native features like inline autocomplete or tab-complete suggestions.

Are you the founder? Claim this listing →