Plus facile à lire avec un fond crème, une teinte, plus de contraste ou un texte plus grand ? Choisissez vos couleurs et votre texte, une fois pour toutes les pages.

Leçon gratuite

Le protocole A2A entre agents

Après cette leçon: Je peux lire une Agent Card et décider si j’envoie une tâche à cet agent.

Leçon de 70 min13 commandesLab agent de code IA : utiliser opencode pour expliquer et corriger du code, et vérifier son travail

Un agent venu d’une autre équipe

Votre équipe d’agents prépare une journée portes ouvertes. Il lui faut des salles libres, et un autre service fait déjà tourner un agent qui connaît l’emploi du temps.

Votre code ne peut pas importer le sien, et vous ne voyez pas ce qu’il contient. Il vous faut une façon convenue de lui demander ce qu’il sait faire, puis de lui confier un travail.

À la fin de cette leçon

Remarque

Je peux lire une Agent Card et décider si j’envoie une tâche à cet agent.

Mots-clés

MotCe que ça veut direExemple
A2Aun protocole ouvert pour qu’un agent confie une tâche à un autre
Agent Cardun fichier JSON où un agent se décrit
Compétenceun travail que la carte dit que l’agent sait faire
Tâcheun travail envoyé à un agent, avec un état
Artefactce que rend une tâche terminée
JSON-RPCune façon d’appeler une méthode en envoyant du JSON"method": "message/send"

Les cellules que les étudiants remplissent restent vides dans cet aperçu.

A2A est une langue commune entre agents

Google a annoncé le protocole Agent2Agent en 2025, puis l’a confié à la Linux Foundation. Il est ouvert : toute équipe peut s’y conformer.

Il passe par HTTP tout simple. Un agent client envoie une tâche en JSON-RPC 2.0, et l’agent distant peut renvoyer des mises à jour en événements envoyés par le serveur. Aucun des deux ne voit le code, les consignes ou les outils de l’autre.

Une Agent Card dit ce qu’un agent propose

Un agent A2A publie une carte à une adresse fixe de son serveur, /.well-known/agent-card.json. La carte donne son nom et sa version, l’adresse où envoyer les tâches et ses compétences, chacune avec des tags.

Elle dit aussi comment un appelant doit prouver qui il est. Le client lit la carte avant d’envoyer quoi que ce soit.

Écrire le faux agent, partie 1

Commande
docker exec -w /home/node/project agent sh -c "printf '%s\n' 'const http = require(\"http\");' 'const CARTE = {' '  protocolVersion: \"0.3.0\",' '  name: \"Agent emploi du temps\",' '  description: \"Répond aux questions sur l’emploi du temps d’une école.\",' '  url: \"http://localhost:4100/a2a\",' '  version: \"1.0.0\",' '  capabilities: { streaming: true },' '  defaultInputModes: [\"text/plain\"],' '  defaultOutputModes: [\"text/plain\"],' '  securitySchemes: { cleClasse: { type: \"http\", scheme: \"bearer\" } },' '  security: [{ cleClasse: [] }],' '  skills: [' '    { id: \"salles-libres\", name: \"Salles libres\", description: \"Liste les salles libres à une heure.\", tags: [\"salles\", \"emploi-du-temps\"] },' '    { id: \"conflits\", name: \"Conflits\", description: \"Trouve deux cours dans une même salle.\", tags: [\"emploi-du-temps\"] },' '  ],' '};' > agent.js"

Affichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.

Écrire le faux agent, partie 2

Commande
docker exec -w /home/node/project agent sh -c "printf '%s\n' 'const REPONSE = \"Libres lundi à 14 h : B12 et C3.\";' 'function tache(id, etat, texte) {' '  const t = { kind: \"task\", id: id, contextId: \"ctx-1\", status: { state: etat } };' '  if (texte) t.artifacts = [{ artifactId: \"a-1\", name: \"reponse\", parts: [{ kind: \"text\", text: texte }] }];' '  return t;' '}' 'function dit(appel) { return appel.params.message.parts[0].text; }' 'function envoyer(appel) {' '  if (dit(appel).includes(\"conflit\")) return tache(\"task-9\", \"failed\", \"\");' '  return tache(\"task-7\", \"completed\", REPONSE);' '}' >> agent.js"

Affichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.

Écrire le faux agent, partie 3

Commande
docker exec -w /home/node/project agent sh -c "printf '%s\n' 'function flux(appel, res) {' '  res.setHeader(\"content-type\", \"text/event-stream\");' '  const evenements = [' '    { kind: \"status-update\", taskId: \"task-8\", status: { state: \"submitted\" }, final: false },' '    { kind: \"status-update\", taskId: \"task-8\", status: { state: \"working\" }, final: false },' '    { kind: \"artifact-update\", taskId: \"task-8\", artifact: { artifactId: \"a-1\", parts: [{ kind: \"text\", text: REPONSE }] } },' '    { kind: \"status-update\", taskId: \"task-8\", status: { state: \"completed\" }, final: true },' '  ];' '  evenements.forEach(function (e) {' '    res.write(\"data: \" + JSON.stringify({ jsonrpc: \"2.0\", id: appel.id, result: e }) + \"\n\n\");' '  });' '  res.end();' '}' >> agent.js"

Affichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.

Écrire le faux agent, partie 4

Commande
docker exec -w /home/node/project agent sh -c "printf '%s\n' 'function rpc(res, corps) {' '  const appel = JSON.parse(corps);' '  if (appel.method === \"message/stream\") return flux(appel, res);' '  res.setHeader(\"content-type\", \"application/json\");' '  const sortie = { jsonrpc: \"2.0\", id: appel.id };' '  if (appel.method === \"message/send\") sortie.result = envoyer(appel);' '  else sortie.error = { code: -32601, message: \"Method not found\" };' '  res.end(JSON.stringify(sortie));' '}' >> agent.js"

Affichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.

Écrire le faux agent, partie 5

Commande
docker exec -w /home/node/project agent sh -c "printf '%s\n' 'function demarrer(port) {' '  const serveur = http.createServer(function (req, res) {' '    if (req.method === \"GET\" && req.url === \"/.well-known/agent-card.json\") {' '      res.setHeader(\"content-type\", \"application/json\");' '      return res.end(JSON.stringify(CARTE));' '    }' '    if ((req.headers.authorization === \"Bearer cle-classe\") === false) {' '      res.statusCode = 401;' '      return res.end();' '    }' '    let corps = \"\";' '    req.on(\"data\", function (c) { corps += c; });' '    req.on(\"end\", function () { rpc(res, corps); });' '  });' '  return new Promise(function (ok) { serveur.listen(port, function () { ok(serveur); }); });' '}' 'module.exports = { demarrer };' >> agent.js"

Affichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.

Écrire le lecteur de carte

Commande
docker exec -w /home/node/project agent sh -c "printf '%s\n' 'const { demarrer } = require(\"./agent\");' 'async function main() {' '  const serveur = await demarrer(4100);' '  const res = await fetch(\"http://localhost:4100/.well-known/agent-card.json\");' '  const carte = await res.json();' '  console.log(\"Nom : \" + carte.name + \", version \" + carte.version);' '  console.log(\"Envoyer les tâches à : \" + carte.url);' '  console.log(\"Diffuse les mises à jour : \" + carte.capabilities.streaming);' '  carte.skills.forEach(function (s) {' '    console.log(\"Compétence \" + s.id + \" : \" + s.description + \" Tags : \" + s.tags.join(\", \"));' '  });' '  const schemas = Object.values(carte.securitySchemes).map(function (s) { return s.scheme; });' '  console.log(\"Demande aux appelants : \" + schemas.join(\", \"));' '  serveur.close();' '}' 'main();' > carte.js"

Affichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.

Récupérer et lire l’Agent Card

Commande
docker exec -w /home/node/project agent node carte.js

Affichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.

Une tâche passe par des états

Le client envoie un message avec message/send. L’agent répond par une tâche : un id, un état et, une fois finie, des artefacts.

Une tâche commence submitted, passe working, et peut s’arrêter sur input-required pour demander une précision. Elle finit completed, failed, canceled ou rejected. Avec message/stream, chaque changement arrive comme un événement, et le dernier est marqué final.

Écrire l’envoyeur de tâches, partie 1

Commande
docker exec -w /home/node/project agent sh -c "printf '%s\n' 'const { demarrer } = require(\"./agent\");' 'function appeler(methode, texte, cle) {' '  const entetes = { \"content-type\": \"application/json\" };' '  if (cle) entetes.authorization = \"Bearer \" + cle;' '  const message = { role: \"user\", messageId: \"m-1\", parts: [{ kind: \"text\", text: texte }] };' '  const corps = { jsonrpc: \"2.0\", id: 1, method: methode, params: { message: message } };' '  return fetch(\"http://localhost:4100/a2a\", { method: \"POST\", headers: entetes, body: JSON.stringify(corps) });' '}' 'function ligne(e) {' '  const quoi = e.status ? e.status.state : \"artefact \" + e.artifact.parts[0].text;' '  return \"Événement \" + e.kind + \" : \" + quoi + (e.final ? \" (final)\" : \"\");' '}' > tache.js"

Affichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.

Écrire l’envoyeur de tâches, partie 2

Commande
docker exec -w /home/node/project agent sh -c "printf '%s\n' 'async function main() {' '  const serveur = await demarrer(4100);' '  const envoi = await (await appeler(\"message/send\", \"Quelles salles sont libres lundi à 14 h ?\", \"cle-classe\")).json();' '  console.log(\"Tâche \" + envoi.result.id + \" : \" + envoi.result.status.state);' '  console.log(\"Artefact : \" + envoi.result.artifacts[0].parts[0].text);' '  const texte = await (await appeler(\"message/stream\", \"La même, en flux.\", \"cle-classe\")).text();' '  texte.split(\"\n\n\").filter(Boolean).forEach(function (morceau) {' '    console.log(ligne(JSON.parse(morceau.slice(6)).result));' '  });' '  const bizarre = await (await appeler(\"tasks/chanter\", \"Bonjour\", \"cle-classe\")).json();' '  console.log(\"Méthode inconnue : erreur \" + bizarre.error.code);' '  console.log(\"Sans clé : HTTP \" + (await appeler(\"message/send\", \"Bonjour\", \"\")).status);' '  serveur.close();' '}' 'main();' >> tache.js"

Affichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.

Envoyer une tâche et suivre un flux

Commande
docker exec -w /home/node/project agent node tache.js

Affichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.

Ce qu’affiche le Run

LigneCe qui s’est passé
Tâche task-7 : completedmessage/send a attendu la fin
Artefact : Libres lundi à 14 h : B12 et C3.La réponse rendue par la tâche
Événement status-update : submitted, puis workingLe flux annonce chaque état
Événement artifact-update : artefact Libres lundi…La réponse arrive dans le flux
Événement status-update : completed (final)Plus rien ne viendra
Méthode inconnue : erreur -32601Le code JSON-RPC d’une méthode qui n’existe pas
Sans clé : HTTP 401L’agent refuse un appelant sans jeton

Les cellules que les étudiants remplissent restent vides dans cet aperçu.

A2A et MCP ont des rôles distincts

MCPA2A
RelieUn agent à des outils et des donnéesUn agent à un autre agent
L’autre côtéFait ce qu’on lui dit, pas à pasPlanifie son propre travail, parfois longtemps
Vous voyezChaque appel d’outil et son résultatSeulement la tâche, ses états et ses artefacts
EnsembleL’agent distant peut utiliser MCP en interneVotre agent délègue tout le travail

Les cellules que les étudiants remplissent restent vides dans cet aperçu.

Une carte est une annonce, pas une preuve

N’importe qui peut publier une carte qui annonce n’importe quelle compétence. Gardez donc une liste des hôtes de confiance, et n’appelez jamais un hôte qui n’y figure pas.

Testez ensuite une compétence annoncée avec une tâche dont vous connaissez la réponse. Le schéma de sécurité de la carte dit quoi envoyer. L’agent distant doit quand même vérifier, à chaque tâche, si cet appelant a le droit de demander.

Écrire le contrôle de confiance, partie 1

Commande
docker exec -w /home/node/project agent sh -c "printf '%s\n' 'const { demarrer } = require(\"./agent\");' 'const AUTORISES = [\"localhost:4100\"];' 'const AUTRE = { name: \"Agent serviable\", url: \"https://agents.example.net/a2a\", skills: [{ id: \"tout\" }] };' 'function hote(url) { return url.split(\"/\")[2]; }' 'async function tester(carte, texte) {' '  const message = { role: \"user\", messageId: \"m-2\", parts: [{ kind: \"text\", text: texte }] };' '  const corps = { jsonrpc: \"2.0\", id: 2, method: \"message/send\", params: { message: message } };' '  const entetes = { \"content-type\": \"application/json\", authorization: \"Bearer cle-classe\" };' '  const res = await fetch(carte.url, { method: \"POST\", headers: entetes, body: JSON.stringify(corps) });' '  return (await res.json()).result.status.state;' '}' > confiance.js"

Affichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.

Écrire le contrôle de confiance, partie 2

Commande
docker exec -w /home/node/project agent sh -c "printf '%s\n' 'async function main() {' '  const serveur = await demarrer(4100);' '  const notre = await (await fetch(\"http://localhost:4100/.well-known/agent-card.json\")).json();' '  [notre, AUTRE].forEach(function (c) {' '    const connu = AUTORISES.includes(hote(c.url));' '    console.log(c.name + \" sur \" + hote(c.url) + \" : \" + (connu ? \"dans la liste autorisée\" : \"hors de la liste, jamais appelé\"));' '  });' '  console.log(\"La carte annonce : \" + notre.skills.map(function (s) { return s.id; }).join(\", \"));' '  console.log(\"Test salles-libres : \" + await tester(notre, \"Quelles salles sont libres lundi à 14 h ?\"));' '  console.log(\"Test conflits : \" + await tester(notre, \"Trouvez un conflit en salle B12.\"));' '  serveur.close();' '}' 'main();' >> confiance.js"

Affichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.

Tester les compétences annoncées par une carte

Commande
docker exec -w /home/node/project agent node confiance.js

Affichée ici, non exécutée. Appuyez sur Démarrer le labo pour la saisir dans le terminal de votre propre labo.

Une erreur fréquente

Attention

Beaucoup prennent une Agent Card pour la preuve de ce que sait faire un agent. Une carte, c’est l’agent qui se décrit lui-même. Ici, elle annonce les conflits, et pourtant une tâche sur un conflit revient failed. Ne vous fiez à une compétence qu’après un test connu réussi, et seulement depuis un hôte que vous avez choisi.

À propos de ce labo et de sa source: Lab agent de code IA : utiliser opencode pour expliquer et corriger du code, et vérifier son travail

Vous enseignez à une classe ? Proposez ce module à vos étudiants avec un guide de l'enseignant, des devoirs corrigés et un laboratoire pour chaque étudiant.