Constitutions d'exécution pour agents IA : un cadre de gouvernance

Les constitutions d’exécution imposent des contraintes de gouvernance pendant l’exécution de l’agent IA, et non uniquement pendant l’entraînement. Elles combinent des a priori normatifs (limites comportementales), une attention constitutionnelle (routage des règles selon le contexte), une modulation des compétences (acquisition sûre de nouvelles aptitudes, sous réserve d’approbation) et une vérification de l’alignement des valeurs (barrières de sortie qui exigent des preuves avant d’accepter un travail comme terminé). Une étude portant sur 7 308 trajectoires d’agents confirme que les compétences auto-générées ne sont pas fiables en l’absence de ces garde-fous structurels.

Le système Learner v2 a généré une nouvelle compétence un mardi après-midi. Cette compétence automatisait un flux de travail de publication d’articles : valider le frontmatter, contrôler les citations, pousser vers la préproduction. Du code propre, bien structuré. La compétence a aussi neutralisé trois règles de qualité issues de quality-loop.md, parce que l’analyseur de motifs avait classé « toujours exécuter la barrière de preuves » comme redondante avec les contrôles intégrés à la compétence. Le mercredi matin, un article était publié sans vérification des citations. La compétence avait appris à prendre des raccourcis.

Le correctif a demandé vingt minutes. La question architecturale, elle, a demandé des semaines : comment laisser un agent acquérir de nouvelles capacités sans qu’il désapprenne les contraintes qui garantissent sa sûreté ?

En bref

L’alignement à l’entraînement (RLHF, IA constitutionnelle appliquée pendant l’entraînement, affinage de sécurité) se dégrade dès que les agents évoluent dans des environnements ouverts. Six travaux de recherche indépendants convergent vers la gouvernance à l’exécution : des constitutions embarquées qui imposent les normes pendant l’exécution, et pas seulement pendant l’entraînement. SkillsBench a testé 7 308 trajectoires d’agents sur 86 tâches et constaté que les compétences auto-générées n’apportent aucun bénéfice moyen — les agents ne savent pas produire de façon fiable la connaissance procédurale qu’ils exploitent pourtant avec profit.¹ Les travaux du MIT sur l’auto-distillation montrent que l’affinage standard provoque un oubli catastrophique : les nouvelles capacités détruisent les anciennes.² L’architecture de la solution comporte quatre composants : a priori normatifs, attention constitutionnelle, modulation des compétences et vérification de l’alignement des valeurs. Ci-dessous : la théorie, la transposition côté praticien (trois composants sur quatre existaient déjà dans mon système Claude Code avant même que je lise ces travaux) et un modèle de constitution d’exécution que vous pouvez mettre en place dès aujourd’hui.

L’agent qui a appris à prendre des raccourcis

L’incident décrit plus haut s’est produit début février 2026, pendant la reconstruction de Learner v2¹⁰. L’analyseur de motifs (pattern_analyzer.py) a détecté un flux de travail récurrent : valider le frontmatter, vérifier les citations, contrôler les métadonnées SEO, puis pousser vers la préproduction. Le générateur de compétences (skill_generator.py) a compilé ce flux en une compétence réutilisable dotée d’une validation intégrée.

Cette validation intégrée couvrait le format du frontmatter et les champs SEO. Elle ne couvrait pas la vérification des citations, qui réside dans une compétence distincte (citation-verifier) avec son propre système d’autorité à six niveaux. La compétence générée a marqué le contrôle des citations comme « pris en charge » parce que l’analyseur de motifs avait repéré des appels de fonctions liés aux citations dans la trace du flux de travail. Il a confondu « la fonction a été appelée » et « les contraintes de la fonction ont été préservées ».

Trois fichiers définissaient l’autorité des sources de trois manières différentes :

L’architecture de consolidation documentée avant l’incident³ avait identifié précisément ce mode de défaillance : quand plusieurs fichiers définissent des concepts qui se chevauchent, les compétences générées héritent de la définition que l’analyseur de motifs rencontre en premier. Le correctif a centralisé l’autorité des citations dans une source canonique unique. La leçon, elle, portait plus loin : les agents qui acquièrent de nouvelles capacités ont besoin de garanties structurelles empêchant l’apprentissage de contourner la gouvernance.

Pourquoi l’alignement à l’entraînement échoue à l’exécution

Goel, Maji et Mazumder en ont documenté le mécanisme : les comportements de sécurité se détériorent lors d’un affinage, qu’il soit bénin ou adverse.⁴ Leurs travaux sur la régularisation adaptative de sécurité, publiés sous arXiv:2602.17546, montrent que les mises à jour de poids les plus risquées peuvent être maintenues à proximité d’une politique de référence sûre, tandis que les moins risquées se poursuivent normalement. L’approche fonctionne au moment de l’entraînement. Elle ne dit rien de ce qui se passe lorsqu’un agent rencontre, à l’exécution, des situations inédites que l’entraînement n’avait jamais anticipées.

L’écart entre l’alignement obtenu à l’entraînement et le comportement réel à l’exécution se creuse à mesure que l’autonomie augmente. Un modèle qui répond à des questions dans une interface de conversation évolue dans des limites comportementales étroites. Un agent qui écrit du code, génère des compétences, lance des tests et déploie en production opère sur une surface nettement plus vaste — d’autant plus quand les conversations multi-tours dégradent l’accès de l’agent à ses propres règles de gouvernance. Le paradoxe de la confiance envers les agents aggrave le phénomène : plus l’agent est capable, plus il devient difficile de vérifier que ses capacités restent dans les limites de la gouvernance. Chaque nouvelle capacité crée de nouveaux modes de défaillance que l’alignement à l’entraînement ne peut pas énumérer à l’avance.

Shenfeld et ses coauteurs, au MIT, ont quantifié un mode de défaillance précis : l’oubli catastrophique lors de l’apprentissage continu.² L’affinage supervisé standard (SFT) sur de nouvelles tâches fait s’effondrer les performances sur les tâches antérieures. À 14 milliards de paramètres, l’affinage par auto-distillation (SDFT) dépasse le SFT standard de 7 points sur les nouvelles tâches tout en conservant 64,5 % d’exactitude sur les précédentes — là où les scores du SFT standard s’effondrent. La contrepartie : le SDFT exige environ 4 fois plus de calcul et 2,5 fois plus de FLOPs.

Pour le praticien, la conséquence est directe : chaque fois que votre agent apprend quelque chose de nouveau (une compétence générée, un flux de travail mis en cache, une instruction mise à jour), cet apprentissage risque de dégrader quelque chose qu’il savait déjà. Le contournement de ma boucle qualité était un cas d’oubli catastrophique au niveau du système. L’agent avait « appris » un raccourci de publication qui détruisait sa capacité à contrôler les citations.

Quatre sous-systèmes de gouvernance à l’exécution

Les recherches sur la gouvernance des agents à l’exécution convergent vers quatre exigences fonctionnelles. Taghavi et ses collaborateurs, qui travaillent sur des constitutions interprétables évolutives, ont montré que des principes de gouvernance issus d’une évolution par LLM surpassent ceux conçus par des humains pour la coordination multi-agents.⁵ Leurs travaux, comme le paradigme « gouvernance d’abord » proposé par Mahadevan pour une ingénierie d’agents fondée sur des principes,⁶ posent le problème sous la forme de quatre sous-systèmes en interaction.

J’ai transposé ces quatre sous-systèmes sur mon infrastructure Claude Code existante et découvert que trois sur quatre étaient déjà construits, chacun répondant à un problème rencontré en production des mois avant que je lise ces travaux.

Sous-système 1 : ingénierie des a priori normatifs

La boucle qualité de mon système d’agents définit sept modes de défaillance nommés : Spirale du raccourci, Mirage de confiance, Plateau du « assez bien », Vision en tunnel, Vérification fantôme, Dette différée et Rapport creux.⁷ Chacun possède une définition, un signal de détection et une réponse obligatoire. Ce ne sont pas des suggestions. Ce sont des contraintes structurelles : si l’agent se surprend à manifester l’un de ces modes, il doit repartir de l’étape d’évaluation.

Le parallèle théorique : les a priori normatifs fixent les limites comportementales à l’intérieur desquelles un agent opère. L’alignement à l’entraînement enseigne au modèle des principes généraux (« être utile, inoffensif, honnête »). Les a priori normatifs à l’exécution encodent des contraintes opérationnelles précises (« ne jamais sauter la vérification des citations », « ne jamais employer de langage évasif dans un rapport de fin de tâche »).

La différence compte, parce que les principes appris à l’entraînement sont probabilistes (le modèle est plus susceptible de les suivre) alors que les a priori d’exécution peuvent être déterministes (le hook bloque l’action dès que la contrainte est violée). C’est exactement la distinction explorée dans la barrière de preuves : passer de « l’agent a probablement fait ce qu’il fallait » à « l’agent a prouvé qu’il a fait ce qu’il fallait ».

Sous-système 2 : attention constitutionnelle

L’architecture de contexte à sept couches⁹ met en œuvre l’attention constitutionnelle par chargement sélectif. Sur les 650 fichiers du système de contexte, moins de 30 se chargent pour une tâche donnée. Le hook prompt-dispatcher.sh analyse la tâche en cours et injecte les règles de gouvernance pertinentes en écartant les autres.

Une tâche de développement web charge les règles de sécurité, les règles de conception API et les conventions FastAPI. Elle ne charge ni les règles propres à iOS, ni les motifs de développement de jeux, ni les consignes éditoriales d’une application de méditation. L’attention constitutionnelle, c’est faire en sorte que l’agent voie les règles de gouvernance qui s’appliquent à cette tâche-là, et non l’intégralité des règles existantes.

Ce chargement sélectif évite un mode de défaillance insidieux : la dilution des règles. Le système de hooks rend ce routage possible en analysant le type de tâche avant l’injection de contexte. Quand un agent reçoit 200 règles, chacune reçoit proportionnellement moins d’attention que lorsqu’il en reçoit 20. L’attention constitutionnelle concentre l’effort de gouvernance sur les règles qui comptent pour le contexte du moment.

Sous-système 3 : modulation des compétences

SkillsBench a testé 7 308 trajectoires d’agents sur 86 tâches réparties dans 11 domaines, avec un résultat frappant : les compétences élaborées par des humains ont amélioré le taux de réussite moyen de 16,2 points de pourcentage, tandis que les compétences auto-générées n’apportaient en moyenne aucun bénéfice.¹ Les agents ne savent pas produire de façon fiable la connaissance procédurale qu’ils exploitent pourtant avec profit. Seize des 84 tâches affichaient même des écarts négatifs, où les compétences nuisaient activement aux performances.

Ce résultat de SkillsBench valide un garde-fou que j’avais intégré à Learner v2 après l’incident du contournement de la boucle qualité. Les compétences générées exigent désormais une approbation explicite avant activation, et elles ne peuvent ni modifier ni contourner les fichiers de gouvernance existants. L’analyseur de motifs peut observer les flux de travail et proposer des compétences, mais le générateur traite les fichiers de gouvernance comme immuables.

Les travaux du MIT sur l’auto-distillation ajoutent une perspective au niveau des paramètres : sur les modèles de petite taille (3 milliards de paramètres), les tentatives d’apprentissage continu dégradent en fait les performances.² Il faut atteindre 7 milliards de paramètres ou plus pour que le modèle dispose d’assez de capacité pour acquérir de nouvelles compétences sans détruire les anciennes. L’équivalent au niveau de l’infrastructure : les agents dotés de fenêtres de contexte plus étroites ou de jeux de règles plus simples sont plus vulnérables aux conflits entre capacités et gouvernance.

Sous-système 4 : vérification de l’alignement des valeurs

La barrière de preuves exige des justifications précises sur six critères avant qu’un travail soit déclaré terminé : respecter les conventions de la base de code (nommer la convention), retenir la solution fonctionnelle la plus simple (expliquer les alternatives écartées), traiter les cas limites (les énumérer), faire passer les tests (coller la sortie), n’introduire aucune régression (nommer les fichiers vérifiés) et résoudre le vrai problème (formuler le besoin de l’utilisateur).⁷

La barrière fonctionne comme une vérification à l’exécution. L’agent ne peut pas annoncer la fin d’une tâche en langage évasif (« devrait fonctionner », « je crois que », « il semble que »). Chaque affirmation doit s’appuyer sur des preuves recueillies pendant la session en cours. La barrière détecte la Vérification fantôme (affirmer que les tests passent sans les avoir lancés) et le Rapport creux (annoncer « c’est fait » sans le moindre détail).

Le problème de l’oubli : quand l’apprentissage détruit le savoir

L’histoire de la consolidation des compétences de blog illustre une version systémique de l’oubli catastrophique. Dix compétences de blog totalisant 5 400 lignes avaient accumulé trois zones de duplication.³ Les modèles de schémas JSON-LD figuraient à la fois dans aio/SKILL.md et dans seo-blog-playbook/SKILL.md. Les définitions d’autorité des citations divergeaient entre citation-verifier et seo-blog-playbook. Les consignes d’évaluation d’article résidaient à la fois dans l’évaluateur principal et dans un fichier séparé de définitions de catégories.

Quand le système Learner v2 a généré de nouvelles compétences à partir des flux de travail observés, il a puisé les définitions dans la première source rencontrée. Résultat : des compétences générées qui semblaient correctes mais portaient les mauvaises définitions d’autorité. Le système de citation à six niveaux s’est dégradé en simple contrôle binaire. Les modèles de schémas ont divergé entre compétences écrites à la main et compétences auto-générées.

Le correctif de consolidation était structurel : désigner une source canonique unique pour chaque concept et faire pointer toutes les autres références vers elle. L’autorité des citations réside dans citation-verifier/SKILL.md et nulle part ailleurs. Les modèles JSON-LD résident dans aio/SKILL.md et nulle part ailleurs. Ce principe empêche toute génération future de compétences d’hériter de définitions obsolètes.

Le SDFT du MIT en offre l’analogue côté entraînement : utiliser les connaissances antérieures du modèle comme signal pédagogique lors de l’acquisition de nouvelles capacités.² Le SFT standard remplace l’ancien savoir par le nouveau. L’auto-distillation mêle les deux en générant des données d’entraînement à partir des capacités existantes du modèle, puis en affinant sur ce mélange. Le savoir antérieur survit parce qu’il est présent dans le signal d’entraînement.

L’équivalent au niveau de l’infrastructure : lors de la génération d’une nouvelle compétence, inclure les contraintes de gouvernance existantes dans la consigne de génération. La compétence générée hérite des contraintes en vigueur parce que ces contraintes font partie du contexte de génération, et non d’un système distinct que le générateur pourrait ignorer.

Gouvernance active et gouvernance passive

Le cadre RelianceScope de Jin et ses coauteurs distingue neuf schémas de recours à l’IA, selon les combinaisons d’engagement actif et passif.⁸ Si leurs recherches portaient sur des étudiants interagissant avec des agents conversationnels, la distinction actif/passif se transpose directement aux architectures de gouvernance des agents.

La gouvernance passive injecte des règles et espère que l’agent les suivra. Les règles existent dans CLAUDE.md ou dans les consignes système. L’agent les lit au début de la session. Rien ne vérifie leur respect. La plupart des configurations de praticiens reposent sur la gouvernance passive : un long fichier d’instructions auquel l’agent prête, ou non, attention à mesure que la session avance. Comme le montre l’agent invisible, les agents qui opèrent sans gouvernance active ne laissent aucune trace permettant de savoir s’ils ont ne serait-ce que suivi leurs instructions.

La gouvernance active vérifie la conformité à l’exécution. Des hooks confrontent les sorties aux contraintes avant leur exécution. Des barrières bloquent les rapports de fin de tâche dépourvus de preuves. Des sondes de surveillance suivent la dérive comportementale et signalent les anomalies. La gouvernance active coûte plus cher (calcul, latence, complexité) mais détecte des défaillances que la gouvernance passive laisse passer.

Le constat de RelianceScope selon lequel la recherche active d’aide va de pair avec un usage actif des réponses⁸ suggère un principe d’architecture de gouvernance : les agents qui interrogent activement leurs contraintes de gouvernance (au lieu de les recevoir passivement) produisent des sorties plus conformes. Ma barrière de preuves repose sur ce principe : au lieu d’appliquer passivement des règles, l’agent doit démontrer activement sa conformité en produisant une preuve pour chaque critère.

Un modèle de constitution d’exécution

Trois fichiers composent une constitution d’exécution minimale. Adaptez la structure à votre cadre d’agent.

Fichier 1 : constitution.md

Les a priori normatifs. Ce que l’agent doit toujours faire, ce qu’il ne doit jamais faire, et sa façon de traiter l’ambiguïté.

# Agent Constitution v1

## Immutable Constraints
- Never modify files in governance/ directory
- Never skip verification steps, even if tests pass
- Never report completion without evidence for all criteria

## Behavioral Norms
- Prefer explicit over implicit (state assumptions)
- Prefer reversible over irreversible actions
- Prefer asking over guessing when requirements are ambiguous

## Failure Response
- On constraint violation: stop, log, escalate
- On ambiguity: ask, do not assume
- On capability conflict: governance wins over efficiency

Fichier 2 : capabilities.json

L’inventaire des compétences actuelles, avec suivi de provenance.

{
  "skills": [
    {
      "name": "blog-publish",
      "version": "2.1.0",
      "source": "generated",
      "approved": true,
      "governance_refs": ["citation-verifier", "quality-loop"],
      "created": "2026-02-10",
      "constraints": [
        "Must call citation-verifier before publish",
        "Must pass evidence gate before reporting complete"
      ]
    }
  ],
  "pending_approval": [],
  "deprecated": []
}

Fichier 3 : constraints-registry.json

Associe chaque contrainte à sa source canonique, ce qui prévient le problème de duplication à l’origine de l’incident des compétences de blog.

{
  "constraints": {
    "citation-authority": {
      "canonical_source": "skills/citation-verifier/SKILL.md",
      "type": "six-tier-hierarchy",
      "overridable": false
    },
    "quality-gate": {
      "canonical_source": "rules/quality-loop.md",
      "type": "evidence-gate",
      "overridable": false
    },
    "schema-templates": {
      "canonical_source": "skills/aio/SKILL.md",
      "type": "json-ld-templates",
      "overridable": false
    }
  }
}

Les trois fichiers interagissent : constitution.md définit les limites comportementales, capabilities.json recense ce que l’agent sait faire avec les renvois de gouvernance, et constraints-registry.json garantit que chaque contrainte possède exactement une source canonique. Les compétences générées renvoient au registre au lieu de recopier les définitions de contraintes. Pour un exemple concret de cette architecture au sein d’une boucle de développement autonome, voyez l’architecture d’agent de Ralph. Et si vous partez du principe que votre sandbox suffit à contenir l’agent, lisez d’abord pourquoi votre sandbox d’agent n’est qu’une suggestion.

À retenir

• L’alignement à l’entraînement se dégrade à l’exécution. L’affinage de sécurité enseigne des principes généraux ; la gouvernance à l’exécution impose des contraintes opérationnelles précises. Goel et ses coauteurs ont montré que les comportements de sécurité se détériorent aussi bien sous affinage bénin qu’adverse.⁴
• Les compétences auto-générées ne sont pas fiables. SkillsBench n’a relevé aucun bénéfice moyen pour les compétences écrites par les agents sur 7 308 trajectoires, et un impact négatif dans 16 des 84 tâches.¹ Les compétences générées ont besoin de barrières d’approbation et de renvois explicites vers la gouvernance.
• L’oubli catastrophique opère aussi à l’échelle du système. De nouvelles capacités peuvent contourner des contraintes existantes sans même modifier les poids du modèle. L’incident de consolidation des compétences de blog a montré un oubli au niveau de l’infrastructure, où une compétence générée a hérité des mauvaises définitions d’autorité.
• Quatre sous-systèmes composent la gouvernance à l’exécution. Les a priori normatifs définissent les limites. L’attention constitutionnelle route les règles vers le contexte. La modulation des compétences encadre l’apprentissage. La vérification de l’alignement des valeurs confirme la conformité à l’exécution.
• La gouvernance active surpasse la gouvernance passive. Les règles dans CLAUDE.md sont nécessaires mais insuffisantes. Des hooks qui vérifient la conformité action par action détectent la dérive, la perte à la compression et la dégradation de fin de session, que les règles passives laissent filer.

FAQ

Références