Blackboard

Aussi appelé : architecture blackboard (tableau noir), espace de travail partagé, coordination par état partagé, tableau de tâches, tuple space, stigmergie (quand le support partagé est un environnement)

Intention

Les agents spécialisés ne se parlent jamais. Ils lisent et écrivent dans un seul espace de travail partagé et structuré, et un composant de contrôle (ou les agents eux-mêmes) regarde ce que contient cet espace pour décider qui contribue ensuite. La solution se construit à partir des entrées accumulées, et non d'une séquence fixe ou d'une conversation.

Problème

Une équipe data construit un assistant au-dessus du data lake d'un observatoire, soit environ 1 500 fichiers : journaux d'observation, télémétrie des instruments et notes d'étalonnage. Une analyste demande : « Quelles observations de 2019 ont le bruit le plus élevé, et quel lien y a-t-il entre le bruit et la température de l'instrument ? » Aucun agent ne peut lire tous les fichiers, alors l'équipe confie chaque groupe de fichiers à son propre agent fichiers. Ce scénario est adapté du cadre de découverte de données étudié par Salemi et al. (Google Cloud AI Research et UMass Amherst).

La première version place un superviseur devant les agents fichiers. Il découpe la question, décide quel agent doit répondre à chaque partie et relaie chaque résultat. Elle casse de plusieurs façons, et de plus en plus à mesure que le data lake grossit :

Une question arrive à un superviseur qui doit choisir l'un de quatre assistants ; il envoie une question sur la température à l'agent des journaux d'observation, qui ne détient pas ces données. Question bruit / température Superviseur aiguille chaque sous-question doit savoir qui détient quoi relaie chaque résultat Journaux d'observation interrogé sur la température Télémétrie instruments Notes d'étalonnage Recherche web
Le superviseur est le seul chemin entre la question et les données : c'est donc l'idée qu'il se fait de ce que détient chaque assistant qui décide si le bon assistant sera un jour interrogé.

Solution

Placez l'état du problème dans un stockage partagé et structuré : le blackboard (tableau). Il comporte des sections (demandes, preuves, hypothèses, critiques, décisions, solution) et des entrées typées, chacune avec un id, un auteur, un statut et des liens vers les entrées qui l'appuient. Les spécialistes lisent la partie du tableau qui les concerne et écrivent de nouvelles entrées. Après chaque tour, un composant de contrôle examine le tableau et choisit qui agit ensuite : l'ordre découle de ce qui figure sur le tableau, et non d'un plan écrit à l'avance.

  1. Amorcer. Le harnais écrit sur le tableau la question de l'analyste, ainsi que les décisions que tout rédacteur doit respecter : heures en UTC, bruit mesuré comme RMS du fond.
  2. Choisir et agir. L'unité de contrôle ne voit encore aucune preuve et sélectionne l'agent analyste, qui publie deux demandes sans nommer de destinataire : « bruit par observation de 2019 » et « série temporelle de température pour 2019 ». Au tour suivant, le contrôleur sélectionne les deux agents fichiers. Chacun écrit des entrées de preuve avec les chemins des fichiers et un petit échantillon.
  3. Réagir à ce qui est apparu. La preuve de l'agent télémétrie signale que ses horodatages sont en heure locale. L'analyste joint les preuves, convertit les heures et écrit l'hypothèse hyp-0012 (« le bruit culmine sur les acquisitions de mars 2019 de l'instrument B ») avec des liens supports vers les ids des preuves.
  4. Relire. Le contrôleur voit une hypothèse non relue et sélectionne le critique. Celui-ci écrit une critique qui cite hyp-0012 : deux acquisitions manquent dans la jointure. L'analyste écrit une nouvelle version qui remplace l'ancienne.
  5. Nettoyer et s'arrêter. Un nettoyeur retire les entrées remplacées de ce que voient les agents. Le décideur trouve une hypothèse acceptée sans critique ouverte, écrit la section solution, et l'exécution se termine.

La décision sur le déroulement se répartit en trois. Le contenu du tableau détermine ce qui est possible, le composant de contrôle décide de ce qui se passe ensuite, et chaque agent décide de ce qu'il écrit. Personne ne fixe l'ordre global à l'avance. C'est ce qui distingue ce pattern d'un Supervisor, qui doit connaître la compétence de chaque worker et relaie toute l'information, et d'un Group Chat, où le support partagé est une transcription ordonnée dans le temps que chaque agent lit en entier. Un blackboard est organisé par contenu : les entrées peuvent être mises à jour, remplacées ou retirées, et un agent ne lit que sa partie.

Analogie

Une équipe d'enquêteurs travaille sur une affaire autour d'un mur d'indices. Personne ne distribue les tâches une par une. Quand la spécialiste des empreintes épingle une correspondance, la personne qui connaît les déplacements du suspect la voit et ajoute une chronologie à côté. La responsable regarde le mur et dit qui doit examiner quoi ensuite. Le mur est le blackboard, chaque spécialiste est une source de connaissance, et le coup d'œil de la responsable sur le mur est le composant de contrôle.

L'analogie ne tient plus sur la concurrence. Des enquêteurs dans une même pièce voient leurs collègues tendre la main vers la même photo. Des agents qui tournent en parallèle, non : le tableau a besoin de réservations explicites, de versions ou de règles de propriété pour éviter que deux d'entre eux ne s'écrasent mutuellement.

Structure

Un tableau à sections occupe le centre ; des agents spécialisés de part et d'autre le lisent et l'écrivent ; une unité de contrôle au-dessus lit le tableau et active les agents ; un décideur en dessous écrit la solution. état du tableau active active Unité de contrôle lit le tableau, sélectionne Blackboard tâche + décisions demandes preuves hypothèses critiques solution Agent fichiers groupe journaux Agent fichiers groupe télémétrie Recherche web sources publiques Analyste écrit les hypothèses Critique repère les failles Maintenance nettoyage, conflits Décideur assez ? écrit la solution 1 2 3 4 5
Lignes à double pointe : un agent lit la partie du tableau dont il a besoin et y écrit des entrées. La ligne pointillée est l'état du tableau que lit l'unité de contrôle ; les lignes d'accent sont ses activations, qui atteignent chaque agent d'une colonne. Aucune ligne ne relie deux agents.
  1. Blackboard. Le stockage partagé : tâche, décisions, demandes ouvertes, preuves, hypothèses, critiques et solution finale. Chaque entrée a un id, un type, un auteur, un statut (proposée, acceptée, rejetée, remplacée) et des liens vers ce qui l'appuie. Le schéma est le contrat entre les agents et la décision de conception la plus importante.
  2. Unité de contrôle. Lit le tableau à chaque tour et sélectionne le plus petit ensemble utile d'agents. Ce peut être un LLM (bMAS), des règles ou des abonnements à des types d'entrées (MetaGPT), ou rien du tout, les agents se portant volontaires ou réservant eux-mêmes le travail.
  3. Spécialistes (sources de connaissance). Chacun a une expertise étroite, une condition qui dit quand il est pertinent, et un type d'entrée qu'il écrit. Ici : un agent fichiers par groupe de données, un agent de recherche web, un analyste qui exécute du code, et un critique. Ils ne s'appellent jamais entre eux.
  4. Maintenance. Un nettoyeur retire les entrées redondantes et remplacées de ce que voient les agents, et un résolveur de conflits fait réconcilier les entrées contradictoires. Sans cela, le tableau grossit à chaque tour.
  5. Décideur. Juge si le tableau contient une réponse suffisante et écrit la section solution. Des vérifications dans le code (plafond de tours, prédicat d'objectif comme « tous les tests passent ») le complètent.

Générateur de prompt

Décrivez la tâche, les sections du tableau et le contrat de chaque spécialiste (ce qu'il lit, quand il est pertinent, ce qu'il écrit). Le générateur vous fournit un format d'entrée pour le tableau, un prompt de contrôle (une unité de contrôle LLM, ou un demandeur qui publie sur le tableau pour des volontaires), un prompt de spécialiste à remplir pour chaque agent, et un prompt de décideur. Utilisez-les dans un framework de graphe où un nœud routeur lit l'état partagé, ou dans votre propre boucle autour d'un stockage.

Sections du tableau une ligne par section
Spécialistes une ligne par agent
Qui décide de qui agit ensuite

Prompt généré

Le texte surligné vient du formulaire. Le texte [entre crochets] reste à remplir.

La vue du tableau compte plus que les prompts

Injecter le tableau entier dans le prompt de chaque agent est le principal coût en tokens du pattern. Donnez à chaque agent une vue limitée à la tâche, aux décisions et aux seules sections et statuts dont il a besoin. Dans l'étude d'ablation de bMAS, se contenter de marquer les entrées redondantes au lieu de les retirer du prompt a fait baisser la précision : ce que voient les agents compte davantage que ce qui est stocké.

Quand l'utiliser

À utiliser quand

À éviter quand

Mise en œuvre

  1. Vérifiez que vous en avez besoin. Choisissez un blackboard quand les contributions sont opportunistes, que les spécialistes sont nombreux ou inconnus à l'avance, ou que l'état du problème est trop gros pour tenir dans une seule fenêtre de contexte. Sinon, utilisez une chaîne, un plan ou un superviseur.
  2. Concevez le schéma. Sections, types d'entrées, statuts, champs obligatoires et qui peut écrire où. Gardez content en langage naturel, mais faites de id, author, status, supports et supersedes des champs machine, et ajoutez une section decisions que tout rédacteur doit respecter.
  3. Choisissez un stockage avec la concurrence dont vous avez besoin. Un état en mémoire pour une seule exécution, une base de données ou un stockage clé-valeur versionné pour des agents concurrents, git quand l'état partagé est du code. Préférez JSON au Markdown libre pour les listes structurées : Anthropic a constaté que le modèle réécrit moins souvent du JSON à mauvais escient.
  4. Écrivez le contrat de chaque agent. Ce qu'il lit (sections et filtres), quand il est pertinent, quel type d'entrée il écrit, et ce à quoi il ne doit jamais toucher. S'il est en désaccord avec une entrée, il écrit une critique qui cite son id au lieu de la modifier.
  5. Choisissez le schéma de contrôle. Une unité de contrôle LLM, des abonnements à base de règles sur les types d'entrées, des volontaires qui jugent eux-mêmes de leur pertinence, ou l'auto-attribution avec verrous. Assurez-vous que le contrôleur voit les réservations ouvertes.
  6. Gérez les conflits d'écriture. Donnez à chaque rédacteur ses propres clés, utilisez des reducers qui fusionnent les mises à jour concurrentes, faites du compare-and-set sur un numéro de version, ou partitionnez la propriété. Une réservation doit avoir un propriétaire, un horodatage et une expiration, pour qu'un processus de nettoyage puisse la récupérer après un plantage.
  7. Ajoutez la maintenance. Détection des conflits, remplacement, retrait des entrées redondantes et compaction des anciens tours en une seule entrée de résumé.
  8. Définissez la terminaison et des budgets stricts. Combinez un décideur, un prédicat d'objectif, la détection d'un état stable (rien de déclenché pendant un tour), des plafonds de tours et de tokens, et un compteur de stagnation (tours sans nouvelle entrée acceptée).
  9. Journalisez chaque écriture comme un événement. Enregistrez l'horodatage, l'agent, l'opération, l'id de l'entrée, les versions avant et après, et chaque décision de contrôle avec sa raison, pour pouvoir rejouer l'évolution du tableau.

Peu de frameworks proposent quelque chose qui s'appelle « blackboard ». La plupart offrent un état partagé, qui ne devient un blackboard que lorsque quelque chose lit son contenu pour décider qui agit ensuite.

Support dans les frameworks (vérifiez la documentation actuelle avant usage)
FrameworkStockage partagéD'où vient le contrôle
LangGraphÉtat typé de StateGraph ; des reducers comme Annotated[list, operator.add] fusionnent les écritures parallèles. Sans reducer, les écritures ultérieures écrasent les précédentes, et deux écritures parallèles dans un même superstep lèvent INVALID_CONCURRENT_GRAPH_UPDATE.Un nœud routeur qui lit l'état et renvoie Command(goto=...), ou des arêtes conditionnelles
Google ADKÉtat de session ; output_key enregistre la réponse d'un agent, {key} la lit dans l'instruction d'un autre agent. Les préfixes user:, app:, temp: fixent la portée.Un agent coordinateur ou personnalisé qui lit l'état et choisit un sous-agent
MetaGPTUn pool de messages partagé ; les rôles publient des documents structurés et s'abonnent aux types dont ils ont besoinLes abonnements, dans un ordre de SOP largement fixe
Claude Code agent teamsUne liste de tâches partagée (en attente, en cours, terminée, avec dépendances) plus une boîte aux lettres par agentLe lead attribue les tâches, ou les coéquipiers se les attribuent eux-mêmes avec verrouillage de fichiers
LettaDes blocs de mémoire attachés à plusieurs agents ; écritures concurrentes : la dernière l'emporteVotre propre code
CrewAIUne Memory unifiée partagée par la crew quand memory=TrueLe processus de la crew (séquentiel ou hiérarchique) : une mémoire partagée plutôt qu'un tableau contrôlé
AWS StrandsUn contexte partagé transmis le long d'un Swarm : tâche, historique des agents, connaissances apportéesDes handoffs : un blackboard léger à l'intérieur d'un Swarm
Fichiers et gitUn dépôt avec du code, des notes, des fichiers de progression et des fichiers de verrouLes agents s'attribuent eux-mêmes les tâches

Mise en garde. Les agent teams de Claude Code sont expérimentales et désactivées par défaut, et leur mécanisme d'attribution peut changer. CrewAI a remplacé ses mémoires séparées à court terme, à long terme et d'entités par une seule classe Memory : les tutoriels plus anciens sont donc dépassés. Attendez-vous à ce que d'autres détails de ce tableau évoluent.

Variantes

Blackboard classique

Hearsay-II, un système de compréhension de la parole des années 1970, organisait le tableau en niveaux d'abstraction, des segments sonores jusqu'aux phrases, les hypothèses d'un niveau étant liées à celles du niveau inférieur qui les appuient. Un ordonnanceur notait les sources de connaissance déclenchées et exécutait la meilleure. BB1 est allé plus loin en plaçant les décisions de contrôle sur un tableau de contrôle distinct, pour que le système puisse raisonner sur sa propre stratégie. (Les noms des niveaux de Hearsay-II proviennent de résumés secondaires ; l'article original n'a pas été lu directement.)

Unité de contrôle LLM

bMAS (Han et Zhang, 2025) utilise le tableau comme seul canal, avec un espace public et des espaces privés pour de petits débats. Des rôles prédéfinis (planificateur, critique, décideur, résolveur de conflits, nettoyeur) travaillent aux côtés d'experts générés pour chaque question, et un LLM choisit qui agit à chaque tour, jusqu'à 4 tours. Si le plafond est atteint sans décision, chaque agent répond à partir du tableau et la réponse la plus proche des autres l'emporte.

Tableau de demandes avec volontaires

Dans le système de Salemi et al., un agent principal qui exécute une boucle ReAct publie des demandes d'aide sans nommer de destinataire. Chaque assistant décide si ses fichiers sont pertinents, et les réponses vont sur un tableau de réponses privé propre à cette demande, de sorte que les assistants ne s'influencent pas. Le demandeur traite les réponses comme l'observation de son action « demander de l'aide ». Personne n'a besoin d'une carte de qui sait quoi.

Tableau de tâches en auto-attribution

Aucun ordonnanceur. Dans l'expérience de compilateur C d'Anthropic, chaque agent synchronisait un dépôt git partagé, prenait la prochaine tâche évidente, la réservait en écrivant un fichier dans current_tasks/, et la libérait après le merge. Un push rejeté signifiait qu'un autre agent avait gagné la course. Les agent teams de Claude Code utilisent une liste de tâches partagée de la même façon.

Pool publication–abonnement

Les agents déclarent les types d'entrées qui les intéressent et sont déclenchés quand l'une d'elles apparaît. MetaGPT fonctionne ainsi, même si son ordre reste surtout fixé par une procédure opérationnelle standard (SOP). Aucun LLM n'est nécessaire dans la boucle de contrôle.

Blackboards légers : état partagé et clés de session

L'état de LangGraph, les clés de session d'ADK et les blocs de mémoire partagés de Letta sont des stockages. Ils ne deviennent un blackboard que lorsqu'un routeur lit leur contenu pour choisir le prochain agent. Quand l'ordre vient d'arêtes fixes, vous avez un pipeline qui partage des variables.

Stigmergie et tuple spaces

La stigmergie est une coordination par les traces laissées dans un environnement partagé, comme les pistes de phéromones des fourmis qui s'évaporent avec le temps. L'évaporation correspond à l'expiration des entrées de faible valeur. Le tuple space de Linda offre une API de tableau minimale : out écrit un tuple, in en prend un qui correspond, rd lit sans retirer. Un in destructif est une réservation atomique, ce qu'imitent les fichiers de verrou. Les « swarms » des frameworks désignent des handoffs, un autre mécanisme, traité dans Swarm / Handoffs.

Avantages et inconvénients

Avantages

  • Le demandeur n'a pas besoin de savoir qui peut aider. Ajouter un spécialiste ne touche aucun autre agent.
  • L'ordre suit le problème : un agent agit quand apparaît quelque chose qu'il peut améliorer.
  • Les résultats partiels sont adressables par section et par id, avec auteur et provenance, au lieu d'être enfouis dans une transcription.
  • Les agents sont découplés dans le temps et l'espace : un lecteur peut venir plus tard, même dans une autre session ou un autre processus.
  • En découverte de données, Salemi et al. rapportent une amélioration relative de 13 à 57 % du taux de réussite de bout en bout par rapport à la meilleure référence (une conception maître–esclave), pour un temps d'exécution réel comparable (132 à 145 secondes selon les systèmes).
  • Les variantes distribuées n'ont pas de point de défaillance unique central. Dans l'expérience de compilateur publiée par Anthropic, 16 agents se coordonnaient uniquement par un dépôt git et des fichiers de verrou.

Inconvénients

  • Coût en tokens : le tableau est injecté dans de nombreux prompts. Salemi et al. ont mesuré environ 1,8 fois le coût d'une conception maître–esclave par question.
  • Les gains sur les benchmarks de raisonnement sont faibles : bMAS devançait ChatEval d'environ 1,1 point en moyenne (81,68 contre 80,56), dans la marge de bruit sur des jeux de test d'à peine 198 questions, et son code n'a pas été publié.
  • Les rédacteurs concurrents ont besoin de reducers, de versions ou de verrous, et les verrous n'empêchent pas les conflits sémantiques.
  • Un ordre émergent est plus difficile à prévoir, à tester et à borner qu'un pipeline fixe.
  • Le schéma partagé est une dépendance de chaque agent ; le modifier les touche tous.
  • Pas de dernière étape naturelle : la terminaison doit être conçue.

Modes de défaillance

Tableau qui enfle

Les prompts grossissent à chaque tour, le coût augmente et les agents perdent le fil.

Parade : un nettoyeur qui retire les entrées redondantes de la vue, des vues par agent, la compaction des anciens tours en une seule entrée de résumé, et une expiration pour les entrées de faible valeur.

Mises à jour perdues

Deux agents mettent à jour la même entrée et l'une des modifications disparaît sans bruit.

Parade : des reducers, du compare-and-set sur une version par entrée, un journal en ajout seul avec une vue calculée, ou un propriétaire unique par zone.

Travail en double et points chauds

Plusieurs agents résolvent le même sous-problème. Dans l'expérience du compilateur, une fois les tests presque tous au vert, tous les agents ont convergé vers le même échec de build du noyau Linux et ont écrasé les correctifs les uns des autres.

Parade : des réservations avec bail, visibles par le contrôleur. Surtout, partitionnez le travail pour que les réservations soient naturellement disjointes : la solution, dans ce cas, a été de compiler la plupart des fichiers du noyau avec GCC comme référence et seulement un sous-ensemble avec le nouveau compilateur, pour que les agents tombent sur des bugs différents.

Réservations orphelines

Un agent planté laisse une réservation indéfiniment. Un agent du compilateur a lancé pkill -9 bash et a mis fin à sa propre boucle.

Parade : propriétaire, horodatage et expiration dans chaque réservation, et un processus de nettoyage qui récupère les anciennes.

Contradictions et décisions implicites incompatibles

Le tableau contient des hypothèses incompatibles, ou des morceaux écrits par différents agents ne s'emboîtent pas (unités, interfaces, style). La réponse finale en choisit un arbitrairement.

Parade : des champs status et supersedes explicites, un résolveur de conflits (bMAS envoie les deux auteurs dans un espace privé pour trancher), une section de décisions que lit tout rédacteur, et un rédacteur final unique.

Propagation d'entrées hallucinées

Un agent écrit un fait faux et les autres s'appuient dessus.

Parade : exigez des liens supports vers des preuves, faites intervenir un critique, et utilisez des tests ou d'autres vérificateurs comme vérité de référence quand il en existe.

Effet moutonnier

Les agents recopient l'entrée la plus visible au lieu de réfléchir de façon indépendante.

Parade : des tableaux de réponses privés pour que les assistants ne voient pas les réponses des autres, et des premiers jets indépendants.

Absence de terminaison

Les agents continuent d'ajouter des entrées marginales.

Parade : un décideur, un prédicat d'objectif, la détection d'un état stable, des plafonds de tours et de tokens, et un compteur de stagnation.

Le contrôleur ne choisit jamais le bon agent

Un spécialiste n'est jamais sélectionné, et ses données n'arrivent donc jamais sur le tableau.

Parade : des descriptions de rôle claires, la possibilité pour les agents de se proposer eux-mêmes, et un audit des agents « jamais sélectionnés » dans les journaux.

Injection de prompt par le tableau

Un texte copié depuis une page web ou un fichier par un agent est lu comme une instruction par un autre.

Parade : traitez les entrées comme des données, marquez celles qui contiennent du contenu externe, et limitez les types d'entrées qui peuvent déclencher des actions.

Dérive du schéma

Les agents inventent des champs ou réécrivent la structure.

Parade : validez chaque écriture par rapport au schéma et gardez les listes structurées en JSON.

Liens avec les autres patterns

Pour aller plus loin