# opencode vs Claude Code: uma comparação honesta

URL: https://agentvera.dev/pt/blog/opencode-vs-claude-code/ · Publicado: 2026-10-28

opencode vs Claude Code: modelos e provedores, preços, licença, agentes e modo de plano, MCP e LSP, AGENTS.md vs CLAUDE.md, permissões e plataformas.

**Resumo:**

- O opencode é um agente com licença MIT que funciona com mais de 75 provedores e modelos locais; o Claude Code é o agente proprietário da Anthropic e só usa modelos Claude.
- O Claude Code é pago por um plano do Claude ou pelo uso da API; o opencode é grátis e você paga o provedor, créditos do OpenCode Zen ou o OpenCode Go (US$ 10 ou 40 por mês).
- O Claude Code pergunta antes de ações arriscadas por padrão, enquanto o opencode libera quase tudo; o opencode lê o AGENTS.md e, se ele não existir, o CLAUDE.md.

opencode vs Claude Code se resume a uma pergunta: você quer um fornecedor ou qualquer fornecedor? O Claude Code é o agente de código da Anthropic. Ele só usa modelos Claude e vem com uma assinatura do Claude. O opencode é um agente de código aberto (MIT) que funciona com mais de 75 provedores e modelos locais, Claude incluído, mas não consegue usar o seu plano Claude Pro ou Max. Os dois leem o repositório, editam arquivos, rodam comandos, suportam MCP e têm um modo de planejamento, então no dia a dia a escolha depende principalmente de modelos, preços e padrões.

Este post compara os dois nos pontos que importam, em outubro de 2026, sem benchmarks inventados. Depois diz qual escolher e como usar os dois sem que um atrapalhe o outro.

## O que eles são

O **Claude Code** é o agente da Anthropic. Rode `claude` na pasta do projeto e converse com ele. Ele também funciona no VS Code (e no Cursor), no JetBrains, num app de desktop, na web e no app do Claude para celular, e todas as superfícies usam o mesmo `CLAUDE.md`, as mesmas configurações e os mesmos servidores MCP. Se você está começando, leia [como usar o Claude Code](/pt/blog/how-to-use-claude-code/ "Como usar o Claude Code: guia para iniciantes").

O **opencode** é um agente de terminal que não depende de nenhuma empresa de IA. O código está no GitHub (`anomalyco/opencode`) com licença MIT. Rode `opencode` na pasta do projeto, conecte um provedor com `/connect` e escolha um modelo com `/models`. Além da TUI, existe um app de desktop (beta) e uma extensão para IDE. O guia passo a passo é [como usar o opencode](/pt/blog/how-to-use-opencode/ "Como usar o opencode: guia passo a passo").

Uma observação sobre versões: o opencode 2 foi lançado com documentação própria, e as duas versões instalam um comando chamado `opencode`. Esta comparação segue a versão 1, que é a instalada pelo pacote npm `opencode-ai`.

## opencode vs Claude Code num relance

| | opencode | Claude Code |
| --- | --- | --- |
| Criador | A equipe do opencode (`anomalyco/opencode`) | Anthropic |
| Licença | MIT, código aberto | Proprietária, sob os Commercial Terms da Anthropic |
| Comando | `opencode` | `claude` |
| Modelos | Mais de 75 provedores (Anthropic, OpenAI, Google, GitHub Copilot, OpenRouter…) e modelos locais | Só modelos Claude |
| Como você paga | Chave de API ou assinatura do seu provedor, créditos do OpenCode Zen ou OpenCode Go | Claude Pro, Max, Team ou Enterprise, créditos de API no Console ou um provedor de nuvem |
| Assinatura do Claude | Não suportada | Sim |
| Planejamento | Agente Plan (Tab alterna Build ↔ Plan) | Modo de plano (`Shift+Tab`) |
| Subagentes | `@general`, `@explore`, agentes próprios em `.opencode/agents/` | Subagentes nativos e próprios em `.claude/agents/` |
| MCP | Sim, chave `mcp` no `opencode.json` ou `opencode mcp add` | Sim, `claude mcp add` ou `/mcp` |
| LSP | Servidores nativos, ligados com `"lsp": true` | Por plugins de inteligência de código |
| Permissões padrão | Quase tudo liberado; pergunta sobre caminhos externos, loops e `.env` | Pergunta antes de edições e comandos (a não ser em modos mais soltos) |
| Instruções do projeto | `AGENTS.md` (alternativa: `CLAUDE.md`) | `CLAUDE.md` (lê `AGENTS.md` quando não há `CLAUDE.md`) |
| Arquivo de configuração | `opencode.json` | `settings.json` |
| Execução não interativa | `opencode run "..."` | `claude -p "..."` |
| Compartilhar sessões | `/share` gera um link | Passar sessões entre superfícies (`/desktop`, Remote Control, `--teleport`) |
| Outras superfícies | App de desktop (beta), extensão de IDE, `opencode web`, `opencode serve`, ACP | App de desktop, VS Code, JetBrains, web, celular, Slack, GitHub Actions |

## Modelos e provedores

Esta é a maior diferença.

O **Claude Code** usa modelos Claude. `/model` alterna entre eles. Você chega a esses modelos direto pela Anthropic ou pelo Amazon Bedrock, Google Cloud ou Microsoft Foundry, mas é sempre Claude.

O **opencode** é construído sobre o AI SDK e o Models.dev, e a documentação fala em suporte a mais de 75 provedores. Dá para usar Claude com uma chave de API da Anthropic, modelos GPT pelo ChatGPT Plus/Pro ou por chave de API, modelos do GitHub Copilot, do OpenRouter e de muitos outros, e modelos locais por qualquer servidor compatível com a OpenAI, como o Ollama. Os modelos são escritos como `provider/model`, e cada agente pode ter o seu:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "agent": {
    "plan": { "model": "anthropic/claude-haiku-4-5" }
  }
}
```

Se você quer planejar com um modelo barato e construir com um forte, ou testar um modelo de pesos abertos na sua própria GPU, o opencode faz isso de fábrica. Se o Claude basta para você, o Claude Code é ajustado exatamente para esses modelos.

## Preços: assinatura ou sua própria chave

O **Claude Code** faz parte dos planos do Claude. Em outubro de 2026, isso significa Pro (US$ 20 por mês, ou US$ 17 por mês no plano anual), Max 5x (US$ 100) e Max 20x (US$ 200), além de assentos Team e Enterprise. O plano Free não inclui o Claude Code. Você também pode dispensar o plano e pagar por token com uma conta do Console. Os planos têm uma janela móvel de 5 horas e um limite semanal.

O **opencode** em si não custa nada. Você paga pelos modelos de uma destas formas:

- **Sua própria chave de API** de qualquer provedor, cobrada por token pelo provedor.
- **Uma assinatura com a qual o opencode consegue fazer login:** GitHub Copilot (alguns modelos exigem um plano maior do Copilot) ou ChatGPT Plus/Pro.
- **OpenCode Zen:** uma seleção de modelos que a equipe do opencode testou com o agente. É pago por uso: você compra créditos e paga por requisição, e cada compra de créditos tem uma taxa de processamento. Alguns modelos estão grátis por tempo limitado.
- **OpenCode Go:** uma assinatura opcional para modelos abertos de código populares, por US$ 10 por mês (Go) ou US$ 40 por mês (Go Plus) em outubro de 2026. Os limites são valores mensais em dólares por modelo, com tetos de 5 horas e semanais.
- **Modelos locais:** nenhuma conta além do seu hardware.

Algo para saber antes de trocar: você **não pode** usar uma assinatura Claude Pro ou Max no opencode. A documentação diz que a Anthropic proíbe isso, e o opencode deixou de incluir os plugins que faziam isso na versão 1.3.0. Modelos Claude no opencode significam chave de API e cobrança por token.

Então, se você já paga o Claude, o Claude Code é o jeito mais barato de usar modelos Claude. Se você já paga o Copilot ou o ChatGPT, ou quer misturar modelos baratos e caros, o opencode aproveita o que você já tem.

## Licença e abertura

O opencode tem licença MIT. Você pode ler o código, fazer um fork e rodá-lo onde quiser sem pedir permissão a ninguém. O repositório do Claude Code no GitHub tem issues, plugins e exemplos, mas o arquivo de licença diz “© Anthropic PBC. All rights reserved” e remete aos Commercial Terms da Anthropic. A instalação é grátis e o uso segue os termos da Anthropic.

Para a maioria dos desenvolvedores individuais, isso pesa menos do que modelos e preço. Para equipes que precisam auditar o agente, corrigi-lo ou construir em cima dele, pode decidir a questão.

## Agentes, subagentes e modo de plano

As duas ferramentas separam “pensar” de “fazer”.

O **opencode** tem dois agentes principais, e o Tab alterna entre eles. O **Build** tem todas as ferramentas. O **Plan** não pode editar o seu código; ele só pode escrever planos em Markdown em `.opencode/plans/`. Dois subagentes vêm de fábrica: `@general` para trabalho em várias etapas e `@explore` para buscas rápidas somente leitura. Você cria os seus como arquivos Markdown em `.opencode/agents/` (ou `~/.config/opencode/agents/`), ou com `opencode agent create`.

O **Claude Code** coloca o planejamento nos modos de permissão: aperte `Shift+Tab` até o modo de plano, em que o Claude pesquisa e escreve um plano, mas não mexe no código até você aprovar. Ele tem subagentes nativos e próprios (arquivos Markdown em `.claude/agents/`) e, além disso, hooks, skills, plugins e checkpoints que você desfaz com `/rewind`. Se você gosta de moldar o comportamento do agente, o Claude Code oferece mais peças.

Uma armadilha do opencode: o Plan não limita comandos de shell sozinho, e um `"edit": "allow"` global também vale para o Plan. Se quiser o Plan bem fechado, defina `agent.plan.permission` diretamente.

## MCP, LSP e compartilhamento

**MCP.** Os dois suportam servidores MCP locais e remotos. O opencode os guarda na chave `mcp` do `opencode.json` (ou adiciona com `opencode mcp add`); o Claude Code usa `claude mcp add` e `/mcp`. Os formatos são diferentes, então quem usa os dois configura cada servidor duas vezes.

**LSP.** O opencode traz servidores de linguagem para TypeScript, Python, Go, Rust, Java, PHP e outras. Eles ficam desligados até você definir `"lsp": true`; aí o servidor certo sobe quando o agente abre um arquivo correspondente. O Claude Code ganha inteligência de código por plugins: um plugin pode trazer um servidor LSP, e a Anthropic publica plugins de servidores de linguagem.

**Compartilhamento.** O opencode tem `/share`, que transforma a conversa atual num link e o copia. O padrão é manual, `"share": "auto"` compartilha cada sessão nova e `"share": "disabled"` desliga isso num projeto. `/unshare` remove o link e os dados compartilhados. O Claude Code aposta em mover a sessão entre superfícies: `/desktop` continua uma sessão de terminal no app de desktop, o Remote Control deixa você seguir pelo celular ou pelo navegador, e `claude --teleport` traz uma sessão da web para o seu terminal.

## Arquivos de configuração: AGENTS.md vs CLAUDE.md

O **opencode** lê o `AGENTS.md` do projeto e o `~/.config/opencode/AGENTS.md` para regras pessoais. Se não houver `AGENTS.md`, ele usa o `CLAUDE.md`, e se não houver `AGENTS.md` global, usa o `~/.claude/CLAUDE.md`. Ele também lê skills de `~/.claude/skills/`. As configurações ficam no `opencode.json`, global em `~/.config/opencode/` e por projeto, e as duas são mescladas. `OPENCODE_DISABLE_CLAUDE_CODE=1` desliga todas as alternativas de `.claude`.

O **Claude Code** lê o `CLAUDE.md` (do projeto, o pessoal `~/.claude/CLAUDE.md` e o `CLAUDE.local.md`, ignorado pelo git) e lê o `AGENTS.md` quando o projeto não tem `CLAUDE.md`. As configurações ficam em `.claude/settings.json` e `~/.claude/settings.json`.

Os dois têm `/init` para escrever uma primeira versão. Se você usa os dois, mantenha as regras de verdade num único `AGENTS.md` e deixe o `CLAUDE.md` como um arquivo curto que o importa com `@AGENTS.md`. [Como escrever CLAUDE.md e AGENTS.md](/pt/blog/claude-md-agents-md/ "Como escrever CLAUDE.md e AGENTS.md") mostra o que colocar nele.

## Permissões

Os padrões são opostos.

O **Claude Code** pergunta primeiro. No modo manual, só as leituras passam sem perguntar; o modo de aceitar edições libera as mudanças em arquivos; o modo auto deixa um classificador revisar cada ação no seu lugar. Você adiciona regras allow, ask e deny com `/permissions`, e `/sandbox` liga um sandbox de Bash no macOS, Linux e WSL2.

O **opencode** confia primeiro. Cada permissão é `allow`, `ask` ou `deny`, e a maioria vem como `allow`. Só três coisas perguntam de fábrica: caminhos fora do projeto (`external_directory`), a mesma chamada de ferramenta repetida três vezes (`doom_loop`) e a leitura de arquivos `.env`. Você restringe com padrões, e vale a última regra que combinar:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "permission": {
    "edit": "ask",
    "bash": { "*": "ask", "git *": "allow", "rm *": "deny" }
  }
}
```

Nenhum padrão torna um agente seguro para ficar sozinho na sua máquina principal. Para trabalho sem supervisão, dê a ele pelo menos um git worktree, e um contêiner se ele puder rodar comandos arbitrários.

## Plataformas

| | opencode | Claude Code |
| --- | --- | --- |
| macOS, Linux | Script de instalação, npm, tap do Homebrew | Instalador nativo, Homebrew, apt/dnf/apk |
| Windows | Chocolatey, Scoop, npm; WSL recomendado | Instalador nativo (PowerShell, CMD), WinGet, WSL |
| App de desktop | Beta para macOS, Windows e Linux | macOS e Windows; beta para Linux no Ubuntu/Debian |
| IDE | Extensão para VS Code, Cursor, Windsurf, VSCodium | Extensão para VS Code (e Cursor), plugin para JetBrains |
| Navegador | `opencode web` serve uma interface web | claude.ai/code |

## Qual escolher?

- **Você já paga o Claude, ou quer modo de plano, hooks, skills e plugins com modelos Claude:** escolha o Claude Code. É o único jeito de usar o seu plano do Claude, e ele é feito em torno desses modelos.
- **Você quer escolher o modelo, usar modelos locais ou um código aberto MIT:** escolha o opencode. Ele também serve para quem já paga o Copilot ou o ChatGPT.
- **O que mais importa é o custo:** o opencode com um modelo barato, o OpenCode Go ou um modelo local pode sair bem mais barato. O Claude Code no Pro é previsível se o que você quer é Claude.
- **Você quer padrões seguros sem ajustar nada:** o Claude Code pergunta primeiro. O opencode pode ser tão rígido quanto, mas as regras ficam por sua conta.
- **Você quer uma segunda opinião em mudanças importantes:** use os dois. O Claude Code escreve e o opencode com outro modelo revisa, ou o contrário.

O teste honesto é o de sempre: dê aos dois a mesma tarefa real no seu repositório, como um bug com um teste falhando, e compare os diffs. Mantenha suas regras no `AGENTS.md` e trocar depois não vai custar nada. Se você também está avaliando o agente da OpenAI, veja [Claude Code vs Codex](/pt/blog/claude-code-vs-codex/ "Claude Code vs Codex: uma comparação honesta").

## opencode e Claude Code lado a lado no AgentVera

Muita gente acaba ficando com os dois: o Claude Code no plano do Claude e o opencode para outros modelos. O atrito é conhecido: dois terminais, duas configurações de MCP e dois agentes que podem editar o mesmo arquivo.

O AgentVera é um app de desktop para macOS, Windows e Linux que abre o opencode e o Claude Code (e outros 16 agentes de CLI) em terminais reais, com as suas próprias instalações e logins:

- **Uma grade.** Os dois agentes ficam na mesma grade, cada um no seu próprio git worktree, então um não mexe nos arquivos do outro.
- **Seus provedores.** Todo provedor que você conectou no opencode, modelos locais incluídos, aparece na lista de modelos do AgentVera. Seu login do Claude funciona como está.
- **MCP uma vez só.** Um servidor que você adiciona no [gerenciador de MCP](/pt/features/mcp-manager/ "Gerenciador de MCP") se conecta aos dois, e o seu `opencode.json` fica intacto.
- **Revisão.** A [revisão de código automática](/pt/features/code-review/ "Revisão de código automática") confere o código quando um turno termina, e com os fluxos (Pro e Team) a resposta de um agente vai automaticamente para o outro.

A grade, os worktrees, a revisão de código e o gerenciador de MCP estão no plano gratuito. [Baixe o AgentVera](/pt/download/ "Baixar o AgentVera") e abra um agente do opencode ao lado de um agente do Claude Code para comparar os dois no seu próprio código.

## Perguntas frequentes

**O opencode é melhor que o Claude Code?** Nenhum ganha em tudo. O opencode dá qualquer modelo e um código aberto com licença MIT. O Claude Code dá os modelos Claude com uma assinatura do Claude, além de hooks, skills, plugins e checkpoints. Dê aos dois a mesma tarefa real no seu repositório e compare os diffs.

**Posso usar minha assinatura Claude Pro ou Max no opencode?** Não. Em outubro de 2026, a documentação do opencode diz que a Anthropic proíbe o uso do Claude Pro/Max por plugins de terceiros, e o opencode deixou de incluí-los na versão 1.3.0. Você ainda pode usar modelos Claude no opencode com uma chave de API da Anthropic, cobrada por token.

**O opencode é grátis?** A ferramenta é grátis e tem licença MIT. Você paga pelos modelos: uma chave de API de qualquer provedor, uma assinatura compatível como GitHub Copilot ou ChatGPT Plus/Pro, créditos do OpenCode Zen ou um plano OpenCode Go de US$ 10 ou 40 por mês. Modelos locais só custam o seu hardware.

**O opencode lê o CLAUDE.md?** Sim, como alternativa. O opencode lê primeiro o AGENTS.md e só usa o CLAUDE.md quando não há AGENTS.md; ele também recorre ao ~/.claude/CLAUDE.md e lê skills de ~/.claude/skills/. O Claude Code, por sua vez, lê o AGENTS.md quando não há CLAUDE.md.

**Qual é mais seguro por padrão?** O Claude Code pergunta antes de edições e comandos, a menos que você escolha um modo mais solto. O opencode libera quase tudo por padrão e só pergunta sobre caminhos fora do projeto, chamadas idênticas repetidas e arquivos .env. Aperte o opencode com regras ask e deny e rode qualquer um dos dois num worktree ou contêiner quando ficar sem supervisão.

**Posso rodar o opencode e o Claude Code no mesmo projeto?** Sim. Dê a cada um o seu próprio git worktree para que não editem os mesmos arquivos. O AgentVera abre as duas CLIs lado a lado em uma grade, cada uma no seu worktree, com os seus próprios logins.

---

**Sobre o AgentVera.** AgentVera é um app desktop para macOS, Windows e Linux, desenvolvido pela Solviera Teknoloji. Ele roda 18 agentes de programação com IA (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) lado a lado, por projeto, em terminais reais com as instalações e logins de CLI do próprio usuário. O plano gratuito tem agentes ilimitados. Baixar: https://agentvera.dev/pt/download/ · Preços: https://agentvera.dev/pt/pricing/