Devin Desktop ACP : connecter Codex, Claude et OpenCode

Qu’est-ce qu’ACP en 2 minutes ?#

En août 2025, Zed Industries a publié l’Agent Client Protocol sous la forme d’une spécification ouverte. À la fin de 2025, JetBrains avait officiellement rejoint son développement et annoncé en décembre la prise en charge du protocole dans IDE 25.3 RC. L’idée est simple : il existe des dizaines d’éditeurs dotés d’IA et des dizaines d’agents, et auparavant chaque paire éditeur-agent nécessitait sa propre couche d’intégration. ACP standardise cette couche.

On compare souvent ACP pour les agents d’IA à LSP pour les serveurs de langage. Lorsque Microsoft a publié LSP, il n’a plus été nécessaire d’écrire une intégration VS Code distincte pour Python, une autre pour Rust et une autre pour Go. Chaque langage disposait d’un serveur LSP conforme à la norme, et tout éditeur prenant en charge LSP pouvait s’y intégrer.

En juin 2026, la spécification est stable à la version 1. Des SDK officiels ont été publiés pour TypeScript, Python, Rust, Java et Kotlin. Douze produits ont annoncé la prise en charge d’ACP dans des éditeurs : Zed (de façon native et en tant que créateur du protocole), les IDE JetBrains à partir de 2025.3, VS Code, Neovim, Emacs, marimo et cinq autres produits de niche. Devin Desktop, l’éditeur de Cognition, se distingue : lancé le 2 juin 2026, il a fait d’ACP un élément central de son interface dès le départ.

Vous trouverez des informations sur l’utilisation d’Ailoot dans la documentation.

Que faut-il installer avant de commencer ?#

Dans Devin Desktop, l’accès à ACP dépend du forfait. Avec le forfait gratuit Free, l’accès aux agents tiers via ACP est désactivé. La documentation le précise explicitement :

Pro coûte 20 $ par mois. C’est suffisant pour un développeur individuel qui veut essayer une configuration avec trois agents. Max, à 200 $ par mois, n’est nécessaire que si vous exécutez Devin Cloud en continu en arrière-plan. Teams, à 80 $ par équipe plus 40 $ par membre, s’adresse aux groupes qui ont besoin de Spaces partagés.

La principale limite actuelle d’ACP dans Devin Desktop est que l’éditeur ne télécharge pas les agents depuis le registre de lui-même.

Vous devez donc installer manuellement au préalable les trois CLI — Codex, Claude et OpenCode. L’éditeur ne les détectera comme agents connectables qu’une fois les fichiers binaires installés.

La méthode d’installation la plus rapide sur macOS et Linux :

# Codex CLI d’OpenAI
npm install -g @openai/codex

# Claude Code d’Anthropic (l’adaptateur ACP est fourni par l’adaptateur communautaire claude-agent-acp ci-dessous)
npm install -g @anthropic-ai/claude-code

# OpenCode (open source)
curl -fsSL https://opencode.ai/install | bash

Après chaque commande, vérifiez que le binaire est accessible dans PATH :

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

Si une commande ne répond pas, il se peut que npm ait placé le binaire en dehors de PATH ou que curl ait échoué à cause d’un délai d’attente réseau. Inutile de continuer : corrigez d’abord l’installation.

Où Devin Desktop cherche-t-il les agents ?#

Cognition a conservé le chemin Windsurf habituel au lieu de remplacer .windsurf par .devin. C’est pratique : vos anciennes configurations continuent de fonctionner comme avant.

Une entrée pour un agent dans le registre ressemble à ceci :

{
  "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"]
      }
    }
  }
}

Le champ essentiel est path. Il indique l’emplacement du fichier exécutable de la CLI sur votre disque. Si vous l’avez installée via npm, le chemin est généralement ~/.nvm/.../node/.../bin/codex ou /usr/local/bin/codex. Vous pouvez le trouver avec which codex.

Le champ args indique ce que Devin Desktop ajoutera à la commande de lancement. Le drapeau --acp est nécessaire pour démarrer la CLI en mode serveur ACP et communiquer avec l’éditeur via JSON-RPC par stdin/stdout. Sans ce drapeau, la CLI démarre en mode interactif ordinaire et Devin Desktop ne la détecte pas.

Sauvegardez registry.json avant de le modifier. Un fichier JSON mal formé bloque tous les agents ACP :

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

Ouvrez ensuite le fichier dans un éditeur et ajoutez le bloc de l’agent au tableau agents.

Connecter la CLI Codex d’OpenAI#

Première étape : authentifiez-vous. Sans authentification, la CLI ne peut pas appeler l’API :

codex auth login

La commande ouvre un navigateur. Si vous avez ChatGPT Plus ou Team, l’authentification se fait via votre compte et vous n’avez pas besoin d’une clé API distincte. Si vous n’avez pas d’abonnement ChatGPT, une clé API de platform.openai.com vous sera demandée.

Deuxième étape : vérifiez que cela fonctionne en mode ordinaire :

codex run "write hello world in python"

Si vous obtenez une réponse et qu’une entrée apparaît dans ~/.codex/sessions/, la CLI fonctionne correctement. Vous pouvez maintenant la connecter à l’éditeur.

Troisième étape : ajoutez un bloc à ~/.windsurf/acp/registry.json. Utilisez la structure de la section précédente et renseignez path à l’aide de which codex :

which codex
# /opt/homebrew/bin/codex

Quatrième étape : activez l’agent dans l’éditeur. Ouvrez la palette de commandes dans Devin Desktop :

• Cmd+Shift+P sur macOS
• Ctrl+Shift+P sur Windows et Linux

Exécutez cette commande depuis la palette : Devin User Settings. Dans la fenêtre qui s’ouvre, passez à l’onglet Agents. Codex devrait apparaître dans la liste après la modification du registre. Activez le commutateur à côté de son nom.

Après activation, une nouvelle colonne apparaît dans Agent Command Center. Vous pouvez lui attribuer une tâche, que Codex exécutera.

Lors du test décrit ici, Codex a répondu le plus rapidement des trois — environ 8 secondes pour la tâche « ajoute la journalisation à cette fonction ». Claude a mis 16 secondes pour la même tâche, et OpenCode 22.

Codex convient lorsque :

• Vous avez besoin rapidement de code standard, sans long raisonnement
• Vous écrivez des scripts de code de base et voulez effectuer de nombreuses petites modifications à la suite
• Vous travaillez à partir d’une spécification existante et la solution est évidente

Codex convient moins bien lorsque :

• Il s’agit d’une tâche d’architecture complexe avec des compromis : il fait souvent des concessions
• Du code sensible sur le plan juridique nécessite une réponse équilibrée : Claude est un meilleur choix
• Vous avez l’habitude d’affiner les prompts et vos propres règles : les outils de Claude sont plus flexibles

Connecter Claude Agent d’Anthropic#

Anthropic ne publie pas encore son propre binaire ACP sous le nom « Claude Agent ». Devin Desktop utilise le même outil que le Claude Code habituel, mais via une couche intermédiaire : l’adaptateur claude-agent-acp du dépôt du protocole, sous licence Apache 2.0.

Première étape : authentifiez Claude Code :

claude auth login

Si vous avez un abonnement Claude Pro ou Max, l’authentification se fait via votre compte. Sinon, une clé API de console.anthropic.com vous sera demandée.

Deuxième étape : vérifiez-le :

claude "rewrite this function so it returns Result<T, E>"

Si la CLI répond, vous pouvez installer l’adaptateur et le connecter à l’éditeur.

Troisième étape : installez l’adaptateur :

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

Quatrième étape : ajoutez un bloc à registry.json. Le champ path pointe vers le binaire de l’adaptateur, et non vers claude lui-même :

{
  "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": []
      }
    }
  }
}

Cinquième étape : activez-le dans les paramètres de Devin, dans l’onglet Agents.

Dans les tests décrits ici, Claude Agent a mieux géré les tâches les plus importantes. Pour la tâche « divise ce composant de 600 lignes en trois fichiers, en préservant tous les imports et les tests », Codex a oublié deux fois que le composant était affiché à trois endroits. Claude a tout repéré dès le premier essai.

Claude Agent présente les mêmes inconvénients que Claude Code :

• Il est plus lent que Codex pour les tâches simples
• Chaque appel coûte plus cher si vous utilisez l’API au lieu d’un abonnement

Vous voulez que plusieurs agents d’IA travaillent sur votre tâche, sans que cela tourne au zoo de binaires ? Les connecter est la partie technique. Le plus important est de savoir répartir le contexte entre eux afin que chaque agent sache ce que les autres ont déjà fait. C’est le rôle de l’ingénierie du contexte : l’un des trois éléments du système — un clone IA de vous, le Second Brain du projet et l’ingénierie du contexte pour chaque tâche. Ensuite, le protocole utilisé par vos agents pour communiquer n’a plus d’importance : ils fonctionnent de la même manière.

Connecter OpenCode : une alternative gratuite#

OpenCode a débuté comme une alternative open source à Claude Code au début de 2026. En juin, son dépôt avait accumulé plus de 30 000 étoiles, sa documentation avait été traduite en une douzaine de langues et des préréglages prêts à l’emploi étaient disponibles pour Ollama et vLLM.

Installez-le avec le script :

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

Vérifiez :

opencode --version

Configurez ensuite le modèle qu’utilisera OpenCode. Pour l’exécuter entièrement en local, lancez Ollama et indiquez-le à OpenCode :

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

Trouver des guides sur les outils dans la documentation Ailoot

Ajoutez ensuite un bloc à 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"]
      }
    }
  }
}

Activez-le dans les paramètres de Devin. C’est fait.

Dans les tests décrits ici, OpenCode avec Qwen 3.5 Coder répondait nettement plus lentement que Codex et Claude — en moyenne 22–25 secondes par tâche, contre 8–16 pour ses concurrents. En revanche, il ne coûte rien, et aucune équipe ne peut vous retirer votre accès.

OpenCode convient lorsque :

• Vous avez un GPU local et voulez effectuer des tâches de programmation hors ligne

• Vous travaillez sur un projet d’apprentissage et n’êtes pas prêt à payer une API

• Vous voulez comparer le retard des modèles open source par rapport aux modèles fermés

OpenCode convient moins bien lorsque :

• Vous avez besoin d’une qualité proche de celle de Claude ; les modèles open source n’ont pas encore rattrapé leur retard
• Vous effectuez de grandes tâches d’architecture avec un contexte de 50K+ tokens ; les modèles locaux perdent souvent le fil
• La vitesse est cruciale ; même sur une 4090, OpenCode est plus lent que Codex dans le cloud

Spaces : partager le contexte entre agents#

Auparavant, chaque agent dans Windsurf avait sa propre session. On lançait Cascade, puis Codex, et ils ne savaient rien l’un de l’autre. Cognition a résolu ce problème avec les Spaces.

Dans un Space, les agents peuvent voir :

• Les modifications apportées aux fichiers par d’autres agents
• L’historique des tâches et décisions récentes
• Le contexte partagé des prompts (par exemple, votre CLAUDE.md ou AGENTS.md)
• Les demandes de fusion en cours et leurs commentaires

Pour créer un Space :

1. Ouvrez Agent Command Center (le bouton dans la barre supérieure de Devin Desktop)
2. Cliquez sur « New Space » dans le coin supérieur droit
3. Associez un dossier de projet au Space
4. Ajoutez les agents nécessaires parmi ceux qui sont activés dans les paramètres

Voici une méthode de travail pour une configuration à trois agents :

1. Codex rédige la première version de l’implémentation dans le Space
2. Claude Agent voit le travail de Codex et examine le code, refactorise et nettoie les parties complexes
3. OpenCode écrit les tests de la version finale

Tous trois utilisent le même AGENTS.md (un fichier partagé de règles du projet) et le même fichier de tâche. Il n’est pas nécessaire de répéter le contexte.

Tests across three projects showed two things. Premièrement, le délai entre le lancement d’une tâche et la création d’une demande de fusion terminée a diminué d’environ un tiers, car les agents n’avaient pas à se répéter les informations. Deuxièmement, davantage d’interventions manuelles étaient nécessaires, car Codex et Claude orientaient parfois le code dans des directions différentes. Il est utile de rédiger AGENTS.md avec précision.

Si vous n’avez pas encore votre propre AGENTS.md, consultez le guide Comment utiliser AGENTS.md et CLAUDE.md ensemble : il décrit un fichier d’instructions unique que les trois agents lisent.

Quand utiliser chaque agent ?#

Scénario 1. Une fonctionnalité standard en 30 minutes

Le CRUD d’une nouvelle table, un formulaire avec deux champs, une page web simple. Choisissez Codex. Il l’écrira en 5 minutes, et vous pourrez vérifier le résultat et le livrer. Claude réfléchira trop longtemps. OpenCode ne sera pas assez rapide.

Scénario 2. Une tâche d’architecture avec des compromis

Vous devez décider s’il faut extraire cette partie dans un service distinct ou la garder dans le monolithe. Ou choisir entre Redux et Zustand pour un projet existant. Choisissez Claude. Il peut peser le pour et le contre. Codex vous donnera une « solution » sans discussion, qui sera très probablement erronée.

Scénario 3. Couverture de tests pour du code déjà écrit

Après qu’un agent a écrit du code, passez à Claude ou OpenCode pour les tests. Codex évalue mal les cas limites qui comptent. Claude est meilleur que les autres pour tester une logique métier complexe, tandis qu’OpenCode est efficace pour écrire des tests d’intégration d’API.

Scénario 4. Développement local hors ligne

Un avion, un train, une datcha sans Internet. Codex et Claude ne fonctionneront pas : ils nécessitent une API. OpenCode avec Ollama et un modèle local est la seule option. La qualité est moindre, mais vous pouvez tout de même écrire du code.

Scénario 5. Comparer trois réponses

Si vous ne savez pas quelle approche convient, donnez la même tâche aux trois agents via Spaces. Comparez leurs réponses et choisissez la meilleure, ou combinez-les. Cela coûte plus de tokens, mais c’est rentable pour les tâches critiques.

Dans le rythme de travail décrit ici, 60 % des tâches sont confiées à Codex (rapidité), 30 % à Claude (qualité) et 10 % à OpenCode (hors ligne). Une fois par semaine dans cet exemple, les trois sont lancés dans Spaces sur une tâche difficile afin de comparer leurs propositions.

Forfaits Devin Desktop et abonnements aux agents#

Une fois Devin Desktop payant, chaque agent ACP nécessite son propre abonnement :

• Codex — ChatGPT Plus ou Team (à partir de 20 $), ou une clé API OpenAI avec paiement à l’usage
• Claude Agent — Claude Pro (20 $) ou Max, ou une clé API Anthropic.
• OpenCode — gratuit avec un modèle local via Ollama.

Le minimum éthique consiste à ne pas partager un compte entre plusieurs personnes ; un compte est enregistré au nom d’une seule personne.

En juin 2026, les abonnements de base pour une configuration avec les trois agents reviennent à environ 60 $ par mois : Devin Pro (20 $), ChatGPT Plus (20 $) et Claude Pro (20 $). Si vous réduisez la configuration à Codex et OpenCode sans Claude, elle coûte 40 $.

Quelle est la différence entre ACP et MCP ?#

On les confond souvent, car toutes deux sont des « protocoles pour agents » et utilisent JSON-RPC. La différence tient à ce qu’elles connectent.

MCP — Model Context Protocol, créé par Anthropic, connecte un agent à des sources de données et à des outils. Via un serveur MCP, un agent peut consulter votre base de données, lire des fichiers, appeler l’API GitHub et accéder à Notion. Il analyse les données d’entrée et décide quel outil utiliser.

ACP — Agent Client Protocol, créé par Zed et JetBrains, connecte un éditeur à un agent. Via ACP, un IDE transmet à l’agent le code que vous avez sélectionné, les fichiers que vous avez ouverts et la commande lancée depuis la palette. En retour, il reçoit des modifications de fichiers, des demandes de confirmation et l’avancement de la tâche.

Un agent communique avec l’éditeur via ACP et avec ses outils via MCP. La pile ressemble à ceci :

┌─────────────────┐
│ Devin Desktop   │ ← éditeur
└────────┬────────┘
         │ ACP (Apache 2.0, JSON-RPC sur stdio)
┌────────▼────────┐
│ Claude Agent    │ ← agent
└────────┬────────┘
         │ MCP (Anthropic, JSON-RPC sur HTTP ou stdio)
┌────────▼────────┐
│ MCP server      │ ← outil (base de données, fichiers, API)
└─────────────────┘

Pour en savoir plus sur MCP, consultez le guide distinct Serveurs MCP pour Claude Code, qui contient des exemples de connexion de sept serveurs prêts à l’emploi.

Qu’est-ce qui ne fonctionne pas en juin 2026 ?#

Voici trois limites notables relevées au cours de deux semaines de tests :

Le registre ne télécharge pas les agents. Comme indiqué au début de ce guide, Devin Desktop attend de vous que vous installiez manuellement les binaires CLI. Un script d’installation permet de contourner ce problème, mais les guides omettent souvent de le préciser.

Toutes les fonctionnalités de l’éditeur ne sont pas transmises à chaque agent. La modification de plusieurs fichiers au sein d’une seule transaction ne fonctionne actuellement pleinement qu’avec Devin Local. Codex et Claude via ACP reçoivent les commandes de modification fichier par fichier. Cela ne gêne pas la plupart des tâches, mais pour les refactorisations portant sur 5 fichiers ou plus en une seule opération, vous devez revenir à Devin Local.

Conflits lors du travail en parallèle. Si deux agents modifient simultanément le même fichier dans un Space, celui qui écrit en dernier remplace la version de l’autre. Devin Desktop n’affiche pas encore de comparaison des conflits. La solution consiste à attribuer un fichier différent à chaque agent dans la tâche, ou à travailler via une demande de fusion et à résoudre manuellement les conflits de fusion.

JetBrains signale des limites bêta similaires dans son implémentation d’ACP dans IDE 25.3 RC :

C’est le même principe que dans Devin Desktop : installez la CLI manuellement et connectez-la dans l’éditeur.

Quel avenir pour l’écosystème ?#

ACP est actuellement l’une des principales normes, mais ce n’est pas la seule. Trois normes se développent en parallèle :

• MCP (Anthropic) — agent vers outil. Déjà la norme de fait.
• A2A (Google, avril 2025) — agent vers agent. Communication entre agents indépendants sans coordinateur central.
• ACP (Zed, JetBrains, fin 2025) — éditeur vers agent.

Dans les prochains mois, Cursor et Replit Agent devraient également intégrer ACP à leurs interfaces. Pour l’instant, ils utilisent des API propriétaires. Lorsque deux acteurs majeurs adoptent ACP, la norme se généralise. « Votre propre agent dans n’importe quel éditeur » devient alors la norme de travail.

Pour un développeur qui code avec l’IA, cela signifie deux choses. Premièrement, vous n’avez pas besoin d’installer cinq applications différentes pour essayer de nouveaux modèles. Deuxièmement, si un fournisseur modifie demain son modèle tarifaire ou cesse ses activités, vous pouvez déplacer son agent vers n’importe quel éditeur ACP et continuer à travailler.

Configurer un trio d’agents est la partie technique. Comprendre comment les choix techniques influencent votre produit relève d’une autre compétence. L’essentiel est de construire un système où l’IA reproduit votre façon de penser (un clone IA), mémorise le contexte du projet (un Second Brain) et lit les règles de la tâche (l’ingénierie du contexte). Ces trois éléments forment un système opérationnel. Après cela, vous pouvez changer d’outils en une soirée.

Découvrez Ailoot.