Como ligar Codex, Claude Agent e OpenCode ao Devin Desktop através do ACP em 2026

O que é o ACP em 2 minutos?#

Em agosto de 2025, a Zed Industries publicou o Agent Client Protocol como uma especificação aberta. No final de 2025, a JetBrains tinha aderido oficialmente ao seu desenvolvimento e, em dezembro, anunciou suporte no IDE 25.3 RC. A ideia é simples: existem dezenas de editores com IA e dezenas de agentes, e anteriormente cada combinação de editor e agente exigia a sua própria camada de integração. O ACP normaliza a camada entre ambos.

Uma analogia comum é que o ACP está para os agentes de IA como o LSP está para os servidores de linguagem. Quando a Microsoft publicou o LSP, deixou de ser necessário escrever uma integração separada do VS Code para Python, outra para Rust e outra para Go. Cada linguagem executava um servidor LSP de acordo com a norma, e qualquer editor que suportasse LSP podia integrar-se com ele.

Em junho de 2026, a especificação estável na versão 1 contava com SDK oficiais para TypeScript, Python, Rust, Java e Kotlin. Doze produtos anunciaram suporte ACP em editores: Zed (suporte nativo e criador do protocolo), IDE da JetBrains a partir de 2025.3, VS Code, Neovim, Emacs, marimo e mais cinco produtos de nicho. O Devin Desktop, o editor da Cognition, destaca-se: foi lançado a 2 de junho de 2026 e integrou o ACP como parte central da sua interface desde o início.

As informações sobre como trabalhar com o Ailoot estão disponíveis na documentação.

O que deve instalar antes de começar?#

O acesso ao ACP no Devin Desktop depende do plano de subscrição. No plano gratuito Free, o acesso a agentes de terceiros através do ACP está desativado. A documentação afirma-o explicitamente:

O Pro custa $20 por mês. É suficiente para quem trabalha individualmente com programação assistida por IA e quer experimentar uma configuração com três agentes. O Max, a $200 por mês, só é necessário se executar continuamente o Devin Cloud em segundo plano. O Teams, a $80 por equipa mais $40 por membro, destina-se a grupos que precisam de Spaces partilhados.

A principal limitação atual do ACP no Devin Desktop é que o editor não transfere agentes do registo por si só.

Isto significa que tem de instalar manualmente e antecipadamente as três CLI — Codex, Claude e OpenCode. Só depois de instalar os binários é que o editor os deteta como agentes que podem ser ligados.

A forma mais rápida de os instalar no macOS e Linux:

# CLI do Codex da OpenAI
npm install -g @openai/codex

# Claude Code da Anthropic (o adaptador ACP é fornecido pelo adaptador comunitário claude-agent-acp abaixo)
npm install -g @anthropic-ai/claude-code

# OpenCode (código aberto)
curl -fsSL https://opencode.ai/install | bash

Depois de cada comando, confirme que o binário está disponível no PATH:

codex --version
claude --version
opencode --version

Se um comando não responder, o npm poderá ter colocado o binário fora do PATH, ou o curl poderá ter falhado devido a um tempo limite da rede. Não vale a pena continuar; resolva primeiro a instalação.

Onde é que o Devin Desktop procura os agentes?#

A Cognition manteve o caminho familiar do Windsurf em vez de alterar .windsurf para .devin. É conveniente: as configurações antigas continuam a funcionar como antes.

Uma entrada para um único agente no registo tem este aspeto:

{
  "id": "codex-cli",
  "name": "Codex",
  "version": "0.42.0",
  "description": "OpenAI's coding agent",
  "authors": ["OpenAI"],
  "license": "Apache-2.0",
  "distribution": {
    "binary": {
      "darwin-arm64": {
        "path": "/opt/homebrew/bin/codex",
        "args": ["--acp"]
      },
      "darwin-x64": {
        "path": "/usr/local/bin/codex",
        "args": ["--acp"]
      },
      "linux-x64": {
        "path": "/usr/local/bin/codex",
        "args": ["--acp"]
      },
      "win32-x64": {
        "path": "C:\\Program Files\\codex\\codex.exe",
        "args": ["--acp"]
      }
    }
  }
}

O campo principal é path. É aqui que se encontra no disco o ficheiro executável da CLI. Se instalou através do npm, o caminho é normalmente ~/.nvm/.../node/.../bin/codex ou /usr/local/bin/codex. Pode encontrá-lo com which codex.

O campo args especifica o que o Devin Desktop acrescenta ao comando de arranque. A opção --acp é necessária para iniciar a CLI em modo de servidor ACP e comunicar com o editor através de JSON-RPC por stdin/stdout. Sem esta opção, a CLI arranca no modo interativo normal e o Devin Desktop não a deteta.

Faça uma cópia de segurança de registry.json antes de o editar. Um ficheiro JSON malformado bloqueia todos os agentes ACP:

cp ~/.windsurf/acp/registry.json ~/.windsurf/acp/registry.json.backup

Depois, abra o ficheiro num editor e adicione o bloco do agente à matriz agents.

Ligar a CLI do OpenAI Codex#

Primeiro passo: autentique-se. Sem autenticação, a CLI não consegue chamar a API:

codex auth login

O comando abre um navegador. Se tiver ChatGPT Plus ou Team, a autenticação é feita através da sua conta e não precisa de uma chave de API separada. Se não tiver uma subscrição do ChatGPT, ser-lhe-á pedida uma chave de API de platform.openai.com.

Segundo passo: confirme que funciona no modo normal:

codex run "escreve olá mundo em python"

Se receber uma resposta e surgir uma entrada em ~/.codex/sessions/, a CLI está a funcionar corretamente. Agora pode ligá-la ao editor.

Terceiro passo: adicione um bloco a ~/.windsurf/acp/registry.json. Use a estrutura da secção anterior e preencha path com o resultado de which codex:

which codex
# /opt/homebrew/bin/codex

Quarto passo: ative o agente no editor. Abra a paleta de comandos no Devin Desktop:

• Cmd+Shift+P no macOS
• Ctrl+Shift+P no Windows e Linux

Execute este comando na paleta: Devin User Settings. Na janela que se abre, mude para o separador Agents. O Codex deverá aparecer na lista depois de editar o registo. Ative o botão ao lado do agente.

Depois da ativação, surge uma nova coluna no Agent Command Center. Pode atribuir-lhe uma tarefa, que o Codex irá concluir.

No teste descrito aqui, o Codex respondeu mais depressa do que os outros dois — cerca de 8 segundos para a tarefa “adiciona registo a esta função”. O Claude demorou 16 segundos na mesma tarefa e o OpenCode demorou 22.

O Codex é adequado quando:

• Precisa de código convencional rapidamente, sem raciocínio prolongado
• Está a criar estruturas de base através de scripts e quer fazer muitas pequenas alterações seguidas
• Está a trabalhar a partir de uma especificação existente e a solução é óbvia

O Codex é uma má escolha quando:

• A tarefa de arquitetura é complexa e envolve compromissos: muitas vezes faz as coisas à pressa
• O código é juridicamente sensível e exige uma resposta ponderada: o Claude é uma escolha melhor
• Está habituado a afinar instruções e a usar as suas próprias regras: as ferramentas do Claude são mais flexíveis

Ligar o Claude Agent da Anthropic#

A Anthropic ainda não disponibiliza o seu próprio binário ACP com o nome “Claude Agent”. O Devin Desktop usa o mesmo que o Claude Code normal, mas através de uma camada de compatibilidade: o adaptador claude-agent-acp do repositório do protocolo, licenciado ao abrigo da Apache 2.0.

Primeiro passo: autentique o Claude Code:

claude auth login

Se tiver uma subscrição Claude Pro ou Max, a autenticação é feita através da sua conta. Caso contrário, ser-lhe-á pedida uma chave de API de console.anthropic.com.

Segundo passo: confirme:

claude "reescreve esta função para que devolva Result<T, E>"

Se a CLI responder, pode instalar o adaptador e ligá-lo ao editor.

Terceiro passo: instale o adaptador:

npm install -g @agentclientprotocol/claude-agent-acp

Quarto passo: adicione um bloco a registry.json. O campo path aponta para o binário do adaptador, não para o próprio claude:

{
  "id": "claude-agent",
  "name": "Claude Agent",
  "version": "0.4.0",
  "description": "Anthropic's coding agent (community ACP adapter)",
  "authors": ["Anthropic", "ACP community"],
  "license": "Apache-2.0",
  "distribution": {
    "binary": {
      "darwin-arm64": {
        "path": "/opt/homebrew/bin/claude-agent-acp",
        "args": []
      }
    }
  }
}

Quinto passo: ative-o nas Definições do Devin, no separador Agents.

Nos testes descritos aqui, o Claude Agent lidou melhor com as tarefas maiores. Na tarefa “divide este componente de 600 linhas em três ficheiros, preservando todas as importações e testes”, o Codex esqueceu-se duas vezes de que o componente era apresentado em três locais. O Claude detetou tudo à primeira.

O Claude Agent tem as mesmas desvantagens que o Claude Code:

• É mais lento do que o Codex em tarefas simples
• Custa mais por chamada se usar a API em vez de uma subscrição

Quer uma configuração em que vários agentes de IA trabalhem na sua tarefa, em vez de se tornarem um zoo de binários? Ligá-los é a parte técnica. Mais importante é saber distribuir o contexto entre eles para que cada agente saiba o que os outros já fizeram. Isso faz parte da engenharia de contexto: um dos três elementos do sistema — uma cópia de IA sua, o Segundo Cérebro do projeto e a engenharia de contexto para cada tarefa. Depois disso, o protocolo usado pelos agentes para comunicar é irrelevante; trabalham da mesma forma.

Ligar o OpenCode: uma alternativa gratuita#

O OpenCode começou como uma alternativa de código aberto ao Claude Code no início de 2026. Em junho, o seu repositório já tinha acumulado mais de 30 000 estrelas, a documentação estava traduzida para uma dúzia de idiomas e havia configurações predefinidas para Ollama e vLLM.

Instale-o com o script:

curl -fsSL https://opencode.ai/install | bash

Confirme:

opencode --version

Em seguida, configure o modelo que o OpenCode irá usar. Para o executar totalmente local, inicie o Ollama e configure o OpenCode para o utilizar:

opencode config set provider ollama
opencode config set base_url http://localhost:11434
opencode config set model qwen3.5-coder:32b

Encontrar guias de ferramentas na documentação do Ailoot

Depois, adicione um bloco a registry.json:

{
  "id": "opencode",
  "name": "OpenCode",
  "version": "0.18.1",
  "description": "Open source coding agent",
  "authors": ["OpenCode community"],
  "license": "MIT",
  "distribution": {
    "binary": {
      "darwin-arm64": {
        "path": "/usr/local/bin/opencode",
        "args": ["acp"]
      }
    }
  }
}

Ative-o nas Definições do Devin. Feito.

Nos testes descritos aqui, o OpenCode com Qwen 3.5 Coder respondeu consideravelmente mais devagar do que o Codex e o Claude — uma média de 22–25 segundos por tarefa, contra 8–16 dos concorrentes. Por outro lado, não custa nada e nenhuma equipa por detrás dele pode revogar o seu acesso.

O OpenCode é adequado quando:

• Tem uma GPU local e quer executar tarefas de programação offline

• Está a trabalhar num projeto de aprendizagem e ainda não quer gastar dinheiro numa API

• Quer comparar o atraso dos modelos de código aberto em relação aos modelos fechados

O OpenCode é uma má escolha quando:

• Precisa de qualidade próxima da do Claude; os modelos de código aberto ainda não a alcançaram
• Tem tarefas arquitetónicas grandes com um contexto de 50K+ tokens; os modelos locais perdem frequentemente o fio à meada
• A velocidade é fundamental; mesmo numa 4090, o OpenCode é mais lento do que o Codex na nuvem

Spaces: partilhar contexto entre agentes#

Anteriormente, cada agente no Windsurf tinha a sua própria sessão. Iniciava o Cascade e depois o Codex, e eles não sabiam da existência um do outro. A Cognition resolveu este problema com os Spaces.

Dentro de um Space, os agentes podem ver:

• Alterações a ficheiros feitas por outros agentes
• O histórico das tarefas e decisões recentes
• Contexto partilhado das instruções (por exemplo, o seu CLAUDE.md ou AGENTS.md)
• Pull requests em curso e os respetivos comentários

Para criar um Space:

1. Abra o Agent Command Center (o botão na barra superior do Devin Desktop)
2. Clique em “New Space” no canto superior direito
3. Associe uma pasta de projeto ao Space
4. Adicione os agentes de que precisa entre os que estão ativados nas Definições

Um fluxo de trabalho para uma configuração com três agentes:

1. Codex escreve o primeiro rascunho da implementação no Space
2. Claude Agent vê o trabalho do Codex e revê o código, refatorando-o e simplificando as partes complicadas
3. OpenCode escreve testes para a versão final

Os três usam o mesmo AGENTS.md (um ficheiro com as regras partilhadas do projeto) e o mesmo ficheiro de tarefa. Não precisa de repetir o contexto.

Testes realizados em três projetos mostraram duas coisas. Em primeiro lugar, o tempo entre o início de uma tarefa e a conclusão de um PR diminuiu cerca de um terço, porque os agentes não precisavam de repetir informações uns aos outros. Em segundo lugar, foi necessária mais intervenção manual porque, por vezes, o Codex e o Claude puxavam o código em direções diferentes. É útil redigir o AGENTS.md com precisão.

Se ainda não tiver o seu próprio AGENTS.md, consulte o guia como usar AGENTS.md e CLAUDE.md em conjunto: descreve um único ficheiro de instruções que os três agentes leem.

Quando deve executar cada agente?#

Padrão 1. Uma funcionalidade convencional em 30 minutos

CRUD para uma nova tabela, um formulário com dois campos ou uma página simples para um site. Escolha o Codex. Ele escreve-a em 5 minutos e pode revê-la e lançá-la. O Claude demoraria demasiado a pensar nesta tarefa. O OpenCode não seria suficientemente rápido.

Padrão 2. Uma tarefa arquitetónica com compromissos

Precisa de decidir se deve extrair esta parte para um serviço separado ou mantê-la no monólito. Ou escolher entre Redux e Zustand para um projeto existente. Escolha o Claude. Consegue ponderar os argumentos. O Codex dará uma “solução” sem discussão, que provavelmente estará errada.

Padrão 3. Cobertura de testes para código já escrito

Depois de um dos agentes escrever código, mude para o Claude ou o OpenCode para criar testes. O Codex tem pouca sensibilidade para perceber que casos extremos são importantes. O Claude é melhor do que os outros a testar lógica de negócio complexa, enquanto o OpenCode é bom a escrever testes de integração da API.

Padrão 4. Desenvolvimento local offline

Um avião, um comboio, uma casa de campo sem Internet. O Codex e o Claude não funcionarão — requerem uma API. O OpenCode com Ollama e um modelo local é a única opção. A qualidade é inferior, mas ainda pode escrever código.

Padrão 5. Comparar três respostas

Quando não tem a certeza de qual é a abordagem correta, atribua a mesma tarefa aos três agentes através dos Spaces. Compare as três respostas e escolha a melhor ou combine-as. Custa mais tokens, mas compensa em tarefas críticas.

Neste exemplo, 60% das tarefas são atribuídas ao Codex (rapidez), 30% ao Claude (qualidade) e 10% ao OpenCode (offline). Uma vez por semana, neste exemplo, os três são iniciados em Spaces para uma tarefa difícil, de modo a comparar as propostas.

Planos do Devin Desktop e subscrições dos agentes#

Depois de pagar pelo Devin Desktop, cada agente ACP precisa da sua própria subscrição:

• Codex — ChatGPT Plus ou Team ($20 ou mais), ou uma chave de API da OpenAI com pagamento conforme o uso
• Claude Agent — Claude Pro ($20) ou Max, ou uma chave de API da Anthropic.
• OpenCode — gratuito ao usar um modelo local através do Ollama.

O mínimo ético é não partilhar uma conta entre várias pessoas; cada conta está registada em nome de uma pessoa.

Em junho de 2026, as subscrições básicas para uma configuração com os três agentes custam cerca de $60 por mês: Devin Pro ($20), ChatGPT Plus ($20) e Claude Pro ($20). Se reduzir a configuração ao Codex e ao OpenCode, sem o Claude, custa $40.

Em que difere o ACP do MCP?#

As pessoas confundem-nos frequentemente porque ambos são “protocolos para agentes” e ambos usam JSON-RPC. A diferença está no que ligam.

MCP — Model Context Protocol, da Anthropic, liga um agente a fontes de dados e ferramentas. Através de um servidor MCP, um agente pode ver a sua base de dados, ler ficheiros, chamar a API do GitHub e aceder ao Notion. Analisa os dados de entrada e decide que ferramenta usar.

ACP — Agent Client Protocol, da Zed e da JetBrains, liga um editor a um agente. Através do ACP, um IDE passa ao agente o código que selecionou, os ficheiros que abriu e o comando executado a partir da paleta. Em resposta, recebe edições de ficheiros, pedidos de confirmação e o progresso da tarefa.

Um agente comunica com o editor através do ACP e com as suas ferramentas através do MCP. A arquitetura é a seguinte:

┌─────────────────┐
│ Devin Desktop   │ ← editor
└────────┬────────┘
         │ ACP (Apache 2.0, JSON-RPC através de stdio)
┌────────▼────────┐
│ Claude Agent    │ ← agente
└────────┬────────┘
         │ MCP (Anthropic, JSON-RPC através de HTTP ou stdio)
┌────────▼────────┐
│ MCP server      │ ← ferramenta (base de dados, ficheiros, API)
└─────────────────┘

Para saber mais sobre MCP, consulte o guia separado Servidores MCP para Claude Code, com exemplos de ligação de sete servidores prontos a usar.

O que não funciona em junho de 2026?#

Três limitações relevantes foram identificadas durante duas semanas de testes:

O registo não transfere agentes. Como referido no início deste guia, o Devin Desktop espera que instale manualmente os binários CLI. Um script de instalação resolve este problema, mas muitos guias esquecem-se de o mencionar.

Nem todas as funcionalidades do editor são disponibilizadas a todos os agentes. Atualmente, a edição de vários ficheiros numa única transação só funciona plenamente com o Devin Local. O Codex e o Claude através do ACP recebem comandos de edição um ficheiro de cada vez. Isto não interfere com a maioria das tarefas, mas, para refatorações que abranjam 5+ ficheiros numa operação, terá de voltar ao Devin Local.

Conflitos durante o trabalho em paralelo. Se dois agentes editarem o mesmo ficheiro ao mesmo tempo num Space, o último a gravar sobrepõe-se à versão do outro. O Devin Desktop ainda não mostra uma comparação das diferenças do conflito. A solução é atribuir um ficheiro diferente a cada agente na tarefa, ou trabalhar através de um PR e resolver manualmente os conflitos de integração.

A JetBrains refere limitações beta semelhantes na sua implementação ACP no IDE 25.3 RC:

É o mesmo procedimento que no Devin Desktop: instalar manualmente a CLI e ligá-la no editor.

Qual é o futuro do ecossistema?#

Atualmente, o ACP é uma das principais normas, mas não é a única. Há três em desenvolvimento paralelo:

• MCP (Anthropic) — agente e ferramenta. Já é a norma de facto.
• A2A (Google, abril de 2025) — agente e agente. Comunicação entre agentes independentes sem um coordenador central.
• ACP (Zed, JetBrains, final de 2025) — editor e agente.

Espera-se que, nos próximos meses, o Cursor e o Replit Agent integrem também o ACP nas suas interfaces. Atualmente, usam API proprietárias. Quando dois grandes intervenientes adotarem o ACP, a norma tornar-se-á comum. Então, “o seu próprio agente em qualquer editor” passará a ser uma prática corrente.

Para quem programa com assistência de IA, isto significa duas coisas. Primeiro, não precisa de instalar cinco aplicações diferentes para experimentar novos modelos. Segundo, se um fornecedor alterar amanhã o seu modelo de preços ou encerrar o serviço, pode transferir o agente para qualquer editor ACP e continuar a trabalhar.

Configurar um trio de agentes é a parte técnica. Compreender como as escolhas técnicas afetam o seu produto é uma competência diferente. A tarefa principal é criar um sistema em que a IA reproduza a sua forma de pensar (uma cópia de IA sua), se lembre do contexto do projeto (um Segundo Cérebro) e leia as regras da tarefa (engenharia de contexto). Estes três elementos formam um sistema funcional. Depois disso, pode mudar de ferramentas numa noite.

Conheça o Ailoot.