Switching between proprietary coding subscriptions every time a model vendor changes rate limits, pricing tiers, or data-retention terms creates unnecessary friction inside production engineering teams. One task calls for a frontier reasoning model to audit a distributed migration, the next needs a low-latency model for repetitive unit test fixes, and a regulated client repository requires a fully offline local model. Across enterprise engagements in Kling Digital AI solutions, removing single-vendor lock-in at the developer workflow layer has become a top architectural requirement.
OpenCode is a lightweight, MIT-licensed open-source terminal coding agent maintained at anomalyco/opencode that runs directly on your own machine without tying you to any single AI vendor. Backed by over 228,000 GitHub stars, it combines a decoupled client-server engine, automatic Language Server Protocol (LSP) context grounding, 75+ LLM providers, and native Model Context Protocol (MCP) support.
Important
- Zero Vendor Lock-In: Route sessions across 75+ LLM providers via the Models.dev registry, including Anthropic, OpenAI, Google, AWS Bedrock, Groq, OpenRouter, existing coding subscriptions, and local Ollama or LM Studio runtimes.
- Automatic LSP Code Intelligence: Rather than blindly stuffing raw files into context, OpenCode connects directly to workspace Language Servers to query exact symbol definitions, type signatures, and compiler diagnostics.
- Decoupled Headless Core & V2 Permissions: The same TypeScript/Bun backend drives the terminal TUI, desktop app, IDE extensions, and remote
opencode servedaemons while enforcing orderedallow/ask/denypermission rules.
Decoupled Client-Server Architecture, Bun Runtime, and OpenTUI
First-generation terminal coding assistants packed prompt streaming, tool execution, and terminal rendering into a single blocking process. Under heavy multi-file sessions, that coupling led to sluggish redraws, dropped state when an SSH tunnel reset, and poor reuse across form factors. OpenCode resolves this with a modular TypeScript monorepo (@opencode/cli, @opencode/protocol, @opencode/client) powered by Bun for fast dependency resolution, script execution, and workspace orchestration.
At the center sits a headless client-server core backed by local SQLite storage for session history, tool transcripts, and file-change tracking. The presentation layer stays cleanly separated:
- Reactive Terminal UI (OpenTUI + SolidJS): Built using SolidJS alongside
@opentui/coreand@opentui/solid, the TUI delivers responsive keyboard-driven editing, Vim-style keybindings, split panes, and parallel session management inside modern terminal emulators such as WezTerm, Alacritty, Ghostty, and Kitty. - Desktop App and IDE Extensions: Because session logic and MCP orchestration live inside the headless core, OpenCode exposes identical behavior across its cross-platform Desktop application (macOS, Windows, Linux) and editor extensions without duplicating agent state.
- Remote Daemon Attachment: Running
opencode serveoropencode webon a high-memory build workstation or private cloud VM lets engineers connect from any lightweight laptop viaopencode attach. Source trees stay on the host workstation while the local terminal renders the live session smoothly.
Automatic LSP Grounding vs. Brute-Force Prompt Stuffing
Most coding agent failures in real-world codebases stem from degraded context rather than weak reasoning. Agents that rely solely on recursive grep calls burn tens of thousands of input tokens reading unrelated wrappers, still miss transitive type definitions, and hallucinate outdated method signatures.
OpenCode eliminates that guesswork through automatic LSP discovery. When you launch a session inside a TypeScript, Python, Go, or Rust workspace, OpenCode detects and initializes the active Language Server automatically. During planning and editing loops, it queries the LSP directly for structured compiler intelligence:
- Exact Symbol Resolution: Jumping straight to canonical definitions and workspace-wide references without scanning every directory linearly.
- Real-Time Type Signatures: Inspecting resolved interfaces and third-party dependency contracts accurately before writing a single patch line.
- Immediate Diagnostic Feedback: Capturing compiler errors, missing imports, and strict type mismatches the moment a file changes so the agent self-corrects before handing control back to the engineer.
When your team also needs to inspect undocumented third-party APIs or binary interfaces before implementing typed wrappers locally, pairing OpenCode's LSP precision with MCP tooling covered in our REA (Reverse Engineer Anything) MCP architecture and setup guide bridges reverse engineering directly into daily repository workflows.
Multi-Provider Routing (75+ Models) and Plan vs. Build Agents
OpenCode treats models as swappable infrastructure rather than an unbreakable bundle. Through its integrated Models.dev provider registry, engineers can configure more than 75 LLM providers—spanning Anthropic Claude, OpenAI GPT, Google Gemini, AWS Bedrock, Groq, OpenRouter, and air-gapped local servers running Ollama or LM Studio. Credentials are stored locally via opencode auth login (in ~/.local/share/opencode/auth.json) or injected dynamically from environment variables and .env files, and developers can also authenticate through existing coding subscriptions such as GitHub Copilot or ChatGPT plans.
Separating Architecture from Execution with Plan and Build Modes
One subtle habit separates disciplined agentic engineering from chaotic diff cleanup: never let an agent modify files before validating its architectural assumptions. OpenCode ships with two dedicated primary agent profiles that you switch between instantly with Tab inside the TUI or explicitly via --agent plan on the CLI:
planAgent: Optimized for read-only codebase exploration, dependency mapping, schema impact analysis, and explicit task breakdown before touching disk.buildAgent: Configured with tighter temperature settings for deterministic edits, incremental verification, and diagnostic cleanup once the plan is approved.
Installation, MCP Servers, and V2 Ordered Permission Matrix
Installing OpenCode takes seconds across macOS, Linux, and cross-platform Node environments without pulling heavy container images upfront:
# Quick install script (macOS / Linux)
curl -fsSL https://opencode.ai/v2/install | bash
# Alternative: Homebrew (macOS / Linux)
brew install anomalyco/tap/opencode-v2
# Alternative: Cross-platform npm install
npm i -g @opencode/cli@latest
# Authenticate provider credentials and run headless daemon mode
opencode auth login
opencode serve --port 4096
# Attach from another terminal or workstation
opencode attach http://127.0.0.1:4096
Checking a project-level opencode.jsonc (or opencode.json) file into Git standardizes default agents, MCP server endpoints, and shell execution boundaries across the whole team. Note two critical V2 schema details that prevent silent configuration fallbacks: MCP definitions belong under mcp.servers (not mcpServers), and security rules belong in a root-level ordered permissions array where the last matching rule wins:
{
"$schema": "https://opencode.ai/config.json",
"default_agent": "plan",
"model": "anthropic/claude-sonnet-4-5",
"agent": {
"plan": {
"temperature": 0.4,
"description": "Read-only architectural analysis and implementation planning."
},
"build": {
"temperature": 0.15,
"description": "Deterministic code editing and patch application agent."
}
},
"mcp": {
"servers": {
"filesystem": {
"type": "local",
"command": ["npx", "-y", "@modelcontextprotocol/server-filesystem", "./src"],
"enabled": true
},
"internal-knowledge": {
"type": "remote",
"url": "https://mcp.internal.example/sse",
"headers": {
"Authorization": "Bearer ${INTERNAL_MCP_TOKEN}"
},
"enabled": true
}
}
},
"permissions": [
{ "action": "shell", "resource": "*", "effect": "ask" },
{ "action": "shell", "resource": "git status *", "effect": "allow" },
{ "action": "shell", "resource": "git diff *", "effect": "allow" },
{ "action": "shell", "resource": "npm test *", "effect": "allow" },
{ "action": "shell", "resource": "git push *", "effect": "deny" }
]
}
Warning
OpenCode executes directly in your local shell environment rather than inside an ephemeral container sandbox. Because the V2 permissions array follows last-match-wins semantics, always place a catch-all "ask" rule first, whitelist only safe read-only or test commands afterward, and terminate the array with explicit "deny" rules for git push *, production deployment scripts, and destructive shell commands.
Engineering Comparison: OpenCode vs. OpenHands, Goose, and Proprietary Agents
As documented in our November 2026 open-source AI agent ecosystem trends analysis, mature engineering organizations rarely standardize on a single agent paradigm. Choosing between OpenCode, OpenHands, and Goose comes down to execution isolation, form factor, and how interactively you supervise code edits.
| Evaluation Dimension | OpenCode | OpenHands | Goose | Proprietary CLI / IDE Agents |
|---|---|---|---|---|
| Execution Form Factor | Lightweight TUI, desktop app, IDE extensions, and remote serve/attach | Web canvas, CLI, and modular Python/TS Software Agent SDK | Rust desktop app, CLI, REST/SSE daemon (goosed), and GDK | Single-vendor CLI or proprietary IDE plugin |
| Workspace Isolation | Direct host execution guarded by V2 ordered permissions matrix | Default Docker/Kubernetes ephemeral sandbox containers | Local host execution with TLS + secret-key protected daemon API | Vendor cloud sandbox or host confirmation dialogs |
| Context & Tooling Core | Automatic LSP grounding (types, symbols, diagnostics) + local/remote MCP | EventStream architecture, multi-file edits, autonomous test suites | 70+ open MCP extensions and portable YAML Recipes + scheduler | Proprietary indexing and closed tool wrappers |
| Model Flexibility | 75+ providers via Models.dev, local Ollama/LM Studio, subscriptions | Provider-agnostic (cloud APIs & local LLMs) + custom microagents | 15+ providers (Anthropic, OpenAI, Google, Bedrock, Ollama) | Typically single-family models or restricted endpoints |
| License & Governance | MIT License (anomalyco/opencode) | MIT License (OpenHands/OpenHands) | Apache-2.0 (Linux Foundation AAIF — aaif-goose/goose) | Commercial closed-source license |
| Best-Fit Workload | Fast keyboard-first pair coding, precise LSP refactors, low overhead | Delegated multi-file changes with automated container test loops | Cross-functional desktop + CLI workflows and embedded API agents | Turnkey single-vendor enterprise seat deployments |
OpenCode shines whenever an engineer wants instant startup, sharp LSP-verified refactoring, and full keyboard velocity inside their native terminal. When a task requires handing off an entire issue to run untrusted package installs, modify dozens of files, and iterate autonomously over integration tests inside an isolated container, pair it with the patterns in our OpenHands sandboxed autonomous software agent guide. If your organization needs one Apache-2.0 Rust runtime serving a native Desktop UI for broader staff, a shell CLI, and an embeddable HTTP/SSE API with shareable YAML recipes, explore our Goose desktop, CLI, and API coding agent guide.
Enterprise Rollout Checklist for Engineering Leaders
Moving OpenCode from individual developer experimentation to a governed team standard requires five concrete engineering controls:
- Commit Sanitized
opencode.jsoncDefaults: Pin"default_agent": "plan"in every repository so engineers review architectural intent before file writes occur, and enforce non-negotiabledenyrules for push and migration scripts. - Centralize Provider Routing: Point sensitive repositories to an internal LLM gateway or self-hosted Ollama cluster instead of scattering raw personal API keys across laptops.
- Pin MCP Dependencies and Least-Privilege Scopes: Lock exact package versions for stdio MCP tools rather than pulling floating
latesttags, and restrict remote MCP gateways to read-only service tokens whenever write access is unnecessary. - Pre-Install Language Servers in DevContainers: Ensure TypeScript, Go, Python, or Rust LSP binaries ship inside your standard DevContainer image so OpenCode delivers full symbol accuracy on day one.
- Measure Real Engineering Signals: Track pull-request revision cycles, static-analysis pass rates, and build-break frequency rather than raw lines of generated code.
Tip
For fast onboarding onto complex legacy monorepos, deploy a shared read-only opencode serve instance locked to plan mode on an internal engineering box. New hires can attach via opencode attach and run LSP-grounded architectural walkthroughs across unfamiliar modules with zero risk of mutating local branches.
If you are designing vendor-neutral agentic developer workflows, custom MCP servers, or zero-trust AI engineering pipelines alongside custom software development, reach out to the Kling Digital architecture team via our contact page.




