TL;DR
- Un ADE (Agentic Development Environment) rassemble au même endroit les sessions, les permissions et la relecture des modifications de plusieurs agents de code, quel que soit leur fournisseur.
- ACP (Agent Client Protocol) standardise le dialogue entre un ADE et un agent : JSON-RPC 2.0 sur stdio, avec des méthodes et des notifications pour ouvrir une session, envoyer un message, suivre l’avancement et demander une permission. Chaque côté annonce ses capacités à l’ouverture.
- ACP n’est pas la seule voie : un ADE peut aussi passer par le SDK d’un agent, son serveur d’application ou un terminal. IntelliJ IDEA 2026.3 l’adopte, et des adaptateurs existent pour Claude et Codex : ACP semble devenir un standard de fait.
🪟 Cinq agents, cinq terminaux
Il est 15 h 40. Cinq terminaux occupent l’écran, avec un agent à l’œuvre dans chacun. Le premier vient de boucler une refonte. Le deuxième attend un accord pour exécuter les tests. Le troisième a posé une question dix minutes plus tôt. On tape vite une réponse, on valide, et le message atterrit dans la mauvaise fenêtre : un autre agent prend ce « oui » distrait pour un feu vert.
Aucune erreur, aucun message. Reste à reconstituer ce que cet agent a modifié sur la foi de ce « oui ».
Piloter un unique agent en ligne de commande reste fluide. Cinq agents en parallèle, issus de trois fournisseurs et répartis sur autant de fenêtres, demandent un autre travail : suivre qui fait quoi.
Chaque session impose sa conversation, son interface, ses permissions et son abonnement. En passant de l’une à l’autre toutes les quelques minutes, on se demande où en était celle-ci, de quelle session sort cette modification, à quel agent s’adresse la réponse. On relit un fil pour retrouver le contexte, et l’attention se disperse entre les sessions.
Ce confort d’un espace unifié, un IDE l’apportait déjà avant les agents : le code, les diffs, les branches et les pull requests y vivent ensemble, sans saut d’outil permanent. Avec des agents, la liste s’allonge : centraliser leurs sessions, leurs permissions, leurs worktrees et la relecture fine ligne par ligne. L’objectif est une expérience simplifiée, gérée depuis un seul endroit.
C’est ce qu’on appelle un ADE, un Agentic Development Environment. Quand je clique sur « envoyer », que se passe-t-il réellement entre l’ADE et l’agent ? Qui lance qui, qui parle à qui, et qui a le droit d’écrire sur mon disque ?
🧩 La stack : Orca, trois agents
Ce que je demande à un ADE tient en une phrase : garder mon environnement, choisir mon agent. Claude aujourd’hui, Codex demain, un autre agent pour comparer, sans réapprendre chaque fois à naviguer dans les conversations et les modifications. Ma pile du moment repose sur Orca, un ADE qui lance les agents côte à côte, chacun dans son propre worktree. J’y utilise trois agents, avec quatre fournisseurs de modèles, dont deux derrière une passerelle LiteLLM locale.

Ce changement d’agent repose sur un contrat commun entre éditeur et agent de code : l’Agent Client Protocol, ACP. Son objectif ressemble à celui de LSP : éviter une intégration complète pour chaque couple éditeur-agent. Chaque agent garde ses capacités et ses réglages propres.
Le sigle prête à confusion, et deux autres protocoles répondent à d’autres besoins :
| Protocole | Ce qu’il relie |
|---|---|
| Agent Client Protocol (ACP) | un éditeur ou un ADE et un agent de code |
| Agent Communication Protocol, de BeeAI, conçu chez IBM | des agents entre eux ; son site l’indique intégré à A2A, sous la Linux Foundation |
| MCP, par son architecture client-serveur | une application IA et des outils, des ressources, des prompts |
Dans ma stack, ACP relie l’ADE à l’agent, et MCP peut relier cet agent à des services externes.
🔌 Ce que le client et l’agent se disent
Un message envoyé depuis l’ADE ne suffit pas à décrire le travail d’un agent. Il faut ouvrir une conversation, recevoir son avancement, pouvoir l’arrêter et lui demander une autorisation. La spécification ACP répartit ces échanges entre deux rôles :
- le client, éditeur ou ADE, gère l’interface, l’environnement de travail et l’accès aux ressources ;
- l’agent est le programme qui s’appuie sur l’IA générative pour modifier le code. Il tourne généralement comme sous-processus du client.

Stdio est le seul transport défini à ce jour, tandis qu’un transport distant est en cours de spécification. Comme MCP, ACP repose sur JSON-RPC 2.0 : ses messages sont des méthodes, qui attendent une réponse, ou des notifications, qui n’en attendent aucune.
Du client vers l’agent :
| Message | Type | Ce qu’il permet |
|---|---|---|
initialize | méthode | négocier la version du protocole et les capacités |
session/new, session/load | méthode | ouvrir une conversation ou en reprendre une |
session/prompt | méthode | envoyer un message ; recevoir à la fin du tour une réponse avec son motif d’arrêt |
session/cancel | notification | interrompre le tour en cours |
De l’agent vers le client :
| Message | Type | Ce qu’il permet |
|---|---|---|
session/update | notification | notifier l’avancement : texte, appels d’outil, plans, commandes disponibles |
session/request_permission | méthode | demander l’accord de l’utilisateur pour un appel d’outil |
fs/*, terminal/* | méthodes | lire ou écrire des fichiers, lancer des commandes, si le client annonce ces capacités |
La négociation engage les deux côtés : chacun annonce ses capacités lors de la phase initialize. Avant d’appeler une méthode optionnelle, l’agent doit vérifier que le client sait la traiter.
Les outils restent exécutés par l’agent. Celui-ci sollicite le client pour une permission et peut lui déléguer les fichiers ou le terminal si les capacités annoncées le permettent.
L’exemple d’Orca et d’OpenCode
Orca est mon ADE au quotidien pour piloter OpenCode via ACP. Pour voir ce qu’il transmet à l’agent et ce qu’il accepte en retour, j’ai lu son client ACP et placé un proxy entre Orca et opencode acp.
Orca démarre opencode acp en sous-processus et communique avec lui en JSON-RPC sur stdin et stdout. Derrière OpenCode, ma passerelle locale LiteLLM sert Kimi K3 et GLM 5.3 : pour Orca, le seul interlocuteur reste OpenCode.
Le client ouvre la session avec initialize, dans lequel il annonce ses capacités : ni lecture ni écriture de fichiers, pas de terminal, et seulement l’élicitation, qui permet à l’agent de demander des informations structurées à l’utilisateur par un formulaire.
{"fs":{"readTextFile":false,"writeTextFile":false},"terminal":false,"elicitation":{"form":{}}}La spécification oblige l’agent à contrôler ces capacités avant toute méthode liée au système de fichiers ou au terminal. OpenCode gère donc lui-même la lecture, l’écriture et les terminaux :

Au fil du tour, Orca :
- convertit les notifications
session/updateen chronologie : texte, réflexions, appels d’outil, plans et consommation de jetons ; - harmonise les sorties d’OpenCode : le résultat d’une commande (
rawOutput.metadata) est recopié dansstdoutetexitCode, et une erreurprovider.rate-limitouprovider.quotadevient un arrêtrate_limit, avec l’heure de reprise si elle est connue.
Un client ACP minimal tient en quelques lignes de TypeScript.
// 1. Lancer l’agent en sous-processus : il parle JSON-RPC sur stdin et stdout
const agent = Bun.spawn(["opencode", "acp"], { stdin: "pipe", stdout: "pipe" });
// Envoyer une requête : un objet JSON par ligne sur stdin
const send = (id: number, method: string, params: object) => {
agent.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
agent.stdin.flush();
};
// 2. Négocier : le client annonce qu’il ne fournit ni fichiers ni terminal
send(1, "initialize", {
protocolVersion: 1,
clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
});L’agent répond à initialize, en annonçant ses capacités (reprise de session, images, contexte intégré) et sa méthode d’authentification :
{"jsonrpc":"2.0","id":1,"result":{"protocolVersion":1,"agentCapabilities":{"loadSession":true,"promptCapabilities":{"embeddedContext":true,"image":true}},"agentInfo":{"name":"OpenCode"},"authMethods":[{"id":"opencode-login","name":"Login with opencode"}]}}S’en suit la lecture des messages de l’agent, une ligne JSON à la fois.
let reste = "";
for await (const bloc of agent.stdout.pipeThrough(new TextDecoderStream())) {
const lignes = (reste + bloc).split("\n");
reste = lignes.pop() ?? ""; // la dernière ligne peut être incomplète
for (const ligne of lignes) {
if (ligne === "") continue; // ignorer les lignes vides
const msg = JSON.parse(ligne);
console.log(msg.method ?? `réponse ${msg.id}`, msg.params?.update?.sessionUpdate ?? "");
// Une réponse reprend l’id de sa requête (JSON-RPC) : il indique l’étape atteinte
const id = msg.method ? undefined : msg.id;
// 4. Réponse à initialize (id 1) : ouvrir une session dans le dossier courant
if (id === 1) send(2, "session/new", { cwd: process.cwd(), mcpServers: [] });
// 5. Réponse à session/new (id 2) : envoyer la demande à l’agent
if (id === 2) {
send(3, "session/prompt", {
sessionId: msg.result.sessionId,
prompt: [{ type: "text", text: "Ajoute une fonction `soustraire` à `src/calc.ts` et lance `bun test`" }],
});
}
// 6. Réponse à session/prompt (id 3) : le tour est terminé, on arrête l’agent
if (id === 3) agent.kill();
}
}En deuxième étape, l’appel à session/new nous fournit l’identifiant de session que le client reprend dans ses requêtes suivantes :
{"jsonrpc":"2.0","id":2,"result":{"sessionId":"ses_e395…"}}Pendant le tour, l’agent envoie des notifications session/update:
- notifie un appel d’outil d’édition, au statut
pending.
{"jsonrpc":"2.0","method":"session/update","params":{"sessionId":"ses_e395…","update":{"sessionUpdate":"tool_call","toolCallId":"call_40ed…","kind":"edit","status":"pending","title":"edit"}}}- donne l’usage du contexte : 27 218 jetons utilisés sur une fenêtre de 200 000.
{"jsonrpc":"2.0","method":"session/update","params":{"sessionId":"ses_e395…","update":{"sessionUpdate":"usage_update","used":27218,"size":200000}}}Le tour se termine par la réponse à session/prompt, qui porte le motif d’arrêt :
{"jsonrpc":"2.0","id":3,"result":{"stopReason":"end_turn"}}Pour construire le côté agent, ACP from scratch, de k33g, déroule le protocole pas à pas, de initialize à session/cancel, et montre comment Mini Me, son agent de code écrit en Go, tient le rôle de l’agent.
🧭 ACP n’est pas l’unique voie de pilotage d’Orca
Dans Orca, la voie de pilotage dépend de l’agent. Son code indique comment Claude Code et Codex sont pilotés.
- Claude Code passe par le SDK Claude Agent.
- Codex passe par
codex app-server, l’interface qu’OpenAI présente pour alimenter des clients riches, comme son extension VS Code. - OpenCode passe par ACP, comme vu plus haut.

Pour Claude Code, Orca appelle query(), une fonction du SDK, qui lance le binaire installé sur la machine et renvoie les messages au fil du tour. Orca fournit le moyen de lancer le processus, et une fonction pour les demandes d’autorisation :
const session = query({
prompt: inbox.messages,
options: {
pathToClaudeCodeExecutable: launch.pathToClaudeCodeExecutable,
spawnClaudeCodeProcess: spawner.spawn,
canUseTool: handlers.canUseTool,
},
})
for await (const message of session) handlers.onMessage?.(message)Pour Codex, Orca parle directement à un processus codex app-server persistant, en JSON-RPC sur stdio, comme avec ACP. Il commence par s’identifier, puis conduit les tours de conversation et les approbations sur ce même processus :
await connection.request('initialize', {
clientInfo: { name: 'orca_desktop', title: 'Orca', version: '0.0.0' },
capabilities: { experimentalApi: true },
})
connection.notify('initialized')Ce initialize porte le même nom que celui d’ACP, avec d’autres champs. OpenAI demande à chaque client de s’identifier par clientInfo.name.
🌱 Un standard en émergence : ACP dans IntelliJ IDEA 2026.3
IntelliJ IDEA 2026.3, sortie le 5 novembre 2026, fournit Air in IDEs, un plugin que JetBrains présente comme une expérimentation, et qui parle ACP aux agents compatibles comme le fait Orca.
Air rassemble les agents et leurs sessions dans l’IDE. Chaque session permet de suivre l’activité de l’agent et de relire ses modifications, et plusieurs sessions peuvent tourner en parallèle. Air repère les agents déjà installés sur la machine et propose un registre ACP, celui de JetBrains par défaut. Un agent hors catalogue se déclare dans ~/.jetbrains/acp.json, avec le chemin de son exécutable et ses arguments de démarrage.

Air propose deux surfaces, et certains agents tournent dans l’une comme dans l’autre :
- en surface chat, Air parle ACP aux agents compatibles, et passe par une intégration SDK pour Claude Agent ;
- en surface terminal, l’agent tourne dans son propre terminal.
ACP semble devenir un standard de fait entre éditeurs et agents. Les adaptateurs Claude et Codex, IntelliJ et Devin Desktop lui donnent un terrain concret.
📌 Take away
- ADE : un seul endroit pour les sessions, les permissions et la relecture des modifications de plusieurs agents de code ;
- ACP : un dialogue standard entre un ADE et un agent, en JSON-RPC 2.0 sur stdio, avec des méthodes et des notifications ;
- Capacités : chaque côté les annonce à
initialize, et l’agent n’utilise les fichiers et le terminal du client que si celui-ci les annonce ; - Autres voies : un ADE peut piloter un agent par son SDK (Claude Code), son serveur d’application (
codex app-serverpour Codex) ou un terminal, ACP restant la voie d’OpenCode ; - Adoption : IntelliJ IDEA 2026.3 et Devin Desktop le prennent en charge, et des adaptateurs existent pour Claude et Codex : ACP semble devenir un standard de fait.
🎓 Aller plus loin avec Claude Code
Vous voulez piloter vos agents de code avec MCP, les hooks et des sous-agents ? En une journée, la formation Coder avec Claude Code - Avancé de TechTown couvre :
- la connexion de Claude Code à des sources externes via MCP ;
- l’automatisation de contrôles avec les hooks ;
- l’organisation de l’environnement en plugins réutilisables ;
- l’orchestration de sous-agents et le SDD.