Everyone wants a coding agent now.
Not a chatbot that explains code.
An actual agent that can read your repo, edit files, run commands, use tools, and keep moving while you supervise.
Claude Code and OpenCode are two of the most interesting takes on that idea.
Claude Code is the polished Anthropic-native route.
OpenCode is the open-source route for people who want more model choice, more control, and a setup they can tweak.
And that difference matters more than it looks.
What is OpenCode
ℹ️ Open-source coding agent with model and tool control
OpenCode is an open-source coding agent for developers who want more control over their AI coding setup.
It runs in the terminal, IDE, and desktop, and lets you bring your own model instead of locking you into one provider. Claude, GPT, Gemini, local models, and 75+ other providers are supported. That is probably the biggest reason people care about it.
It also comes with the things you expect from a serious coding agent now: LSP support, multi-session workflows, project memory through AGENTS.md, MCP tools, custom agents, plugins, and editor support, and maybe a bunch more.
So the pitch is not just “AI in your terminal.”
That undersells it.
OpenCode is closer to a coding-agent workbench. You bring the model, the provider, the editor, the agents, and the workflow. OpenCode gives you the open layer that ties it all together.
Not everyone needs that level of control.
But some developers absolutely do.
💁 OpenCode is for developers who want to tweak every single detail of their coding agent.
That is what makes it interesting next to Claude Code.
What is Claude Code
ℹ️ Anthropic’s polished coding agent for your terminal.
Claude Code is Anthropic’s coding agent that lives in your terminal.
The idea is pretty same here, it can read your codebase, edit files, run commands, handle Git stuff, and all through prompts.
The big difference is that Claude Code is built around Claude.
That sounds obvious, but it matters.
You are not coming here to mix and match ten different model providers. You are coming here because you trust Anthropic’s models, and you want the cleanest experience around them.
Claude Code also comes with a lot of serious agent features: project memory through CLAUDE.md, slash commands, permissions, hooks, MCP, plugins, custom subagents, and IDE integrations.
Claude Code is closer to a Claude-native coding environment. The model, the agent loop, the tool use, the permissions, and the workflow all come from the same Anthropic-shaped box.
Less DIY.
But there is also a small shift happening.
Some developers are starting to move from Claude Code to OpenCode or OpenAI’s Codex for one simple reason: usage limits.
Claude Code is great, but when you are deep in a coding session, hitting limits feels brutal. And for heavier users, even the $200 Claude Max plan does not always feel like enough.
That is why OpenCode and Codex are tempting. Also read: Claude Code vs. Codex: Detailed breakdown
When Claude hits the wall, people still need a way to keep shipping.
💁 If you're an Anthropic fanboy, and don't care about other models, stick to Claude Code.
High Level Architecture
ℹ️ How both the agents work
At a high level, both OpenCode and Claude Code follow the same basic agent loop.
You give it a task.
It looks at the repo.
It decides what files, commands, or tools it needs.
It takes an action.
Then it reads the result and keeps going.
ℹ️ This is the highest-level architecture of a coding agent. A few details change from tool to tool.
That loop is the boring part.
The interesting part is everything around it.
Here is a tiny example of that loop in practice.
I gave Claude Code and OpenCode the same small task in a demo word-count repo:
Add a
--jsonflag to a word-count CLI, update the tests, and run them.
The interesting part is not the feature. It is watching both agents go through the same shape: understand the repo, plan the change, edit the files, and run the tests.
Claude Code wraps that loop in Anthropic’s own product system. You get Claude, project memory through CLAUDE.md, permissions, hooks, MCP, plugins, Claude skills, and subagents in one single setup.
OpenCode takes a more open route. It gives you the agent runtime, but lets you bring different models, providers, agents, tools, and workflows. Its docs split agents into primary agents and subagents, and let you configure specialized assistants with custom prompts, models, and tool access.
So architecturally, the difference is not that one is an agent and the other is not.
They both are.
The real difference is who controls the harness around the agent.
Claude Code gives you Anthropic’s harness.
OpenCode gives you a harness you can inspect, and configure.
Context, memory and tool use
Both Claude Code and OpenCode are doing the same basic thing: they build a giant prompt, stuff it with repo context, tool definitions, memory files, recent messages, and tool results, then ask the model what to do next.
The difference is how much of that system you control.
Claude Code is more vertically integrated here. It is built around Anthropic models, so it can take advantage of Anthropic-specific stuff like prompt caching, native tool calls, and Claude’s own long-context behavior.
That matters.
Tool definitions, system prompts, and CLAUDE.md can be cached between turns, which makes long coding sessions cheaper and faster than they would be if Claude had to re-read everything from scratch every single time.
OpenCode takes a different route.
It does not assume one model or one provider. Instead, it reads the model’s context limit from the provider metadata and builds the session around that. So the same OpenCode setup can run with Claude, GPT, Gemini, Qwen, local models, or whatever else you plug in.
That flexibility is the whole point.
But it also means OpenCode has to normalize all the weird provider differences: tool call IDs, cache support, model limits, and tool-calling parts.
Claude Code gets to optimize deeply for Claude.
OpenCode has to work with everyone.
Memory works the same way.
Claude Code uses CLAUDE.md as the main project memory file. It can also load nested CLAUDE.md files, user-level memory, and auto-memory. So it feels more like the agent has a built-in memory system.
OpenCode uses AGENTS.md.
That is more portable. You can commit it to the repo, share it with the team, and use it as a general agent instruction file instead of something tied to one vendor. OpenCode can even fall back to CLAUDE.md, which makes migration easier.
At some point, every agent runs out of context.
Claude Code handles this by compacting the conversation. Older tool outputs are cleared first, then the session gets summarized if needed. That is why Claude Code has commands like /context and /compact.
OpenCode is a bit more explicit. It checks whether the session is close to the model’s context limit, keeps a buffer for output, and then prunes old tool outputs before doing a full summary. The important bit is that OpenCode stores the raw history in SQLite, so pruning does not mean the data is gone forever.
Tool use follows the same pattern.
Claude Code gives you a polished default toolbelt: read, write, edit, grep, glob, bash, web fetch, todo tracking, MCP, hooks, skills, and subagents.
OpenCode gives you a smaller but more configurable tool system: read, write, edit, patch, bash, grep, glob, web fetch, task, todo, skills, MCP, custom tools, and experimental LSP support.
The difference is who controls the tool layer.
Subagents and task delegation
Subagents are basically how coding agents avoid stuffing everything into one giant conversation.
Instead of making the main agent do every task itself, it can delegate a smaller job to another agent with its own context window, prompt, tools, and permissions.
Claude Code and OpenCode both follow the same basic pattern here.
The parent agent calls a Task or task tool.
A child agent spins up.
It does the work in isolation.
Then it returns one final message back to the parent.
Main Agent
|
| calls Task / task
v
Subagent
- own context window
- own prompt
- own tools
- own permissions
|
| returns final result only
v
Main Agent continues...That part is important. The parent usually does not see the full subagent conversation. It gets the result, not the whole reasoning.
Claude Code has the more polished version of this.
It ships with built-in agents like Explore, Plan, and general-purpose. Explore is mostly read-only and useful for repo research. Plan helps gather context during planning. general-purpose is for broader work.
You can also define custom agents in .claude/agents/ with YAML frontmatter for things like tools, model, permissionMode, maxTurns, skills.
That means you can do stuff like:
Use a fast Haiku-style agent for repo search.
Use a stronger model for code review.
OpenCode has a similar shape, but it is more transparent.
It has primary agents and subagents. Primary agents handle the main chat, while subagents are called through the task tool or @ mentions.
Custom agents can live in .opencode/agents/*.md or inside opencode.json, with fields like mode, model, temperature, steps, prompt, and permission.
The interesting part is that OpenCode stores subagents as real child sessions in SQLite. So delegation is not just a hidden prompt trick. It is represented in the session model with its own messages, permissions, and snapshots.
That fits OpenCode’s whole philosophy.
Claude Code gives you a cleaner subagent experience.
OpenCode gives you a more inspectable one.
Permissions, safety, and control
This is where the two are very different.
Claude Code is more conservative by default. It has permission modes, allow/ask/deny rules, hooks, and sandboxing around Bash.
So you can allow boring commands like tests, deny obvious footguns like .env reads or curl | sh, and ask before anything risky.
The important part is that Claude Code has multiple safety layers.
Permissions decide what Claude is allowed to do.
Something like:
{
"permissions": {
"allow": ["Bash(npm run test *)", "Bash(git status *)"],
"deny": ["Read(./.env)", "Read(./secrets/**)", "Bash(curl *)"]
}
}Hooks can intercept tool calls before or after they run and sandboxing gives Bash an OS-level boundary.
OpenCode is simpler.
Most of the control lives in one permission object inside opencode.json. You can set rules for bash, edit, read, task, webfetch, and other tools from the same place.
That is clean, but OpenCode is also more permissive by default. You are expected to configure the rules yourself.
Something like:
{
"permission": {
"*": "ask",
"bash": {
"*": "ask",
"git status *": "allow",
"git push *": "deny",
"rm *": "deny"
},
"edit": {
"*": "deny",
"packages/web/src/**/*.tsx": "ask"
}
}
}It does have some smart checks, especially for Bash. OpenCode parses shell commands with tree-sitter (the same thing you have inside NeoVim), so it can detect risky commands like rm, mv, chmod, or paths outside the project more carefully than plain string matching.
But there is no native sandbox like Claude Code.
The bigger OpenCode power feature is plugins. Plugins can intercept tool execution, add custom tools, and change agent behavior.
That makes OpenCode way more hackable.
What the Claude Code leak tells us
The interesting part of the leak is what it showed about coding agents.
A lot of Claude magic is in the harness around the model: context management, tool descriptions, prompt caching, permissions, compaction, subagents, and the agent loop.
OpenCode does pretty much the same. It is not trying to clone some impossible model-level feature. It is trying to build a different harness around similar idea.
OpenCode’s advantage is that the harness is open, inspectable, and replaceable.
Another thing that's clear is that the future is not just about better models, but the system around them.
Better context control.
Better tool boundaries.
Better memory.
Better permissions.
That is why this comparison is even interesting. Claude Code and OpenCode are not just two CLIs. They are two different answers to the same question:
❓ How much of the agent stack should be final, and how much should developers be able to control?
So, which should you pick?
There is no clever answer here.
Pick Claude Code if you want the cleanest Claude-native coding agent experience.
Pick OpenCode if you want more control.
Personally, I still love Claude Code.
I really do.
Anthropic models are banger, especially for coding. The problem is that the limits have started to piss me off. When you are deep in a coding session and the limit hits, it completely breaks the flow.
But there is some relief now.
On May 6, Anthropic announced a new compute partnership with SpaceX and doubled Claude Code’s 5-hour limits for Pro, Max, Team, and seat-based Enterprise users. They also removed peak-time limits for Pro and Max users.
That makes Claude Code a lot easier to recommend again.
I am personally still mostly stuck with Claude Code because the experience is just that good.
But I use OpenCode when I want to try newer models like Kimi, OpenAI models, or local models. That is where OpenCode makes more sense to me. And by no means, it is to say that you can't use Anthropic models in OpenCode, you can, and that makes it even better.
Final thoughts
Claude Code and OpenCode are both useful, but for different reasons.
Claude Code is the one I’d pick if I just want the agent to work without thinking too much about setup. It feels cleaner, and better for getting into a repo quickly.
OpenCode is more for when you want control. Different models, different providers, more ways to shape the workflow around how you actually code.
I wouldn’t overthink it.
If you hate setup and love Anthropic, use Claude Code.
If you want more flexibility and less vendor lock-in, use OpenCode.
That’s really the whole comparison.