Architecte de Boucle d'Agent (Ingénierie de Boucle)

Que fait Architecte de Boucle d'Agent (Ingénierie de Boucle) ?

Aperçu

Architecte de Boucle d'Agent est une norme d'exécution et un modèle de conception pour orchestrer des workflows multi-agents complexes et en plusieurs étapes via des itérations en boucle fermée avec mémoire persistante et suivi d'état.

Au lieu de traiter les exécutions d'agents comme des requêtes uniques ou des pipelines linéaires, la Boucle d'Agent impose un cycle de vie itératif où les sous-agents se spécialisent, vérifient leur travail via des portes objectives et apprennent systématiquement d'une exécution à l'autre.

Les Deux Règles d'Or de la Boucle

1. Aucune Exécution Sans Apprentissage Préalable : Avant de proposer ou d'implémenter une solution, les agents doivent exécuter la phase Apprendre en consultant les modèles positifs et négatifs existants dans la mémoire.
2. Aucune Finalisation Sans Compression : Un cycle n'est pas terminé lorsque du code ou du contenu est écrit ; il se conclut uniquement après que la phase Compresser a distillé le résultat dans la mémoire et mis à jour l'état.

flowchart TD
    Start([Tâche Initiée]) --> Learn[1. APPRENDRE : Ingérer .loop-memory/]
    Learn --> Plan[2. PLANIFIER : Décomposition des Étapes & etapas.json]
    Plan --> Exec[3. EXÉCUTER : Sous-agents Spécialisés Dispatchés]
    Exec --> Verify{4. VÉRIFIER : Portes Objectives Passées ?}
    Verify -- Non : Régression / Pivot --> Learn
    Verify -- Oui --> Compress[5. COMPRESSER : Distiller la Mémoire & Mettre à Jour l'État]
    Compress --> Done([Boucle Terminée])

---

Les 5 Phases de la Boucle

Chaque cycle de boucle avance strictement à travers cinq phases :

Phase 1 : Apprendre (Ingestion Pré-vol)

• Vérification obligatoire : Les sous-agents doivent lire :
  • .loop-memory/positive-cases/ (modèles gagnants, correctifs validés, angles de copie à fort taux de conversion, modèles de prompt optimaux).
  • .loop-memory/negative-cases/ (anti-modèles, hypothèses échouées, régressions de cas limites, approches interdites).
• Objectif : Empêcher les agents de répéter des erreurs précédemment documentées et forcer la réutilisation de modèles éprouvés.

Phase 2 : Planifier & Orchestrer (Initialisation de l'État)

• Décomposer l'objectif en étapes discrètes et ordonnées.
• Initialiser ou mettre à jour etapas.json avec le statut de l'étape, les sous-agents assignés, les entrées, les sorties et les critères d'acceptation.
• Assigner des rôles de sous-agents dédiés correspondant aux exigences du domaine.

Phase 3 : Exécuter (Dispatch de Sous-agents Spécialisés)

• Exécuter les sous-agents séquentiellement ou en parallèle en fonction des dépendances des étapes.
• Les sous-agents travaillent dans un contexte isolé, en transmettant des artefacts ou des diffs concis plutôt que des historiques de conversation complets.

Phase 4 : Vérifier & Évaluer (Portes d'Acceptation Objectives)

• Valider la sortie de l'exécution par rapport à des critères explicites, automatisés ou déterministes (par exemple, résultats de tests unitaires/intégration, linting, vérification des citations, conformité tonale).
• Si la vérification échoue :
  • Documenter l'échec en tant que modèle négatif intermédiaire.
  • Revenir à Apprendre/Planifier avec le retour d'échec.
• Si la vérification réussit : passer à Compresser.

Phase 5 : Compresser (Distillation de Mémoire Post-vol)

• Distillation Positive : Extraire le modèle exact, le template, le fragment de prompt ou le correctif de code qui a réussi et l'écrire dans .loop-memory/positive-cases/CASE-<ID>.md.
• Distillation Négative : Documenter les impasses, les hypothèses rejetées et les régressions dans .loop-memory/negative-cases/CASE-<ID>.md.
• Finalisation de l'État : Mettre à jour etapas.json avec les horodatages de fin, les artefacts finaux et les métriques d'exécution.

---

Structure de Répertoire et Architecture Mémoire

Chaque projet fonctionnant avec le modèle de Boucle adhère à la structure racine ou d'espace de travail suivante :

<project-root>/
├── .loop-memory/
│   ├── positive-cases/
│   │   ├── CASE-001-fix-auth-race-condition.md
│   │   └── CASE-002-high-conversion-cold-hook.md
│   └── negative-cases/
│       ├── CASE-001-failed-jwt-in-localstorage.md
│       └── CASE-002-clickbait-hook-bounce.md
├── etapas.json
├── references/
│   └── domain-examples.md
└── SKILL.md

Schéma de Cas Mémoire (.loop-memory/*/CASE-*.md)

Chaque fichier de cas doit suivre ce modèle markdown standardisé :

# Cas : [Titre Descriptif Court]
- **Date :** AAAA-MM-JJ
- **Domaine :** [Ingénierie | Rédaction | Ventes | Recherche]
- **Type :** [Positif | Négatif]
- **Déclencheur / Contexte :** [Situation exacte, message d'erreur ou objectif du prompt]

## Modèle / Technique
[Description détaillée de ce qui a fonctionné ou pourquoi cela a échoué]

## Artefact Concret / Extrait de Code / Prompt
```[langage]
[Collez l'extrait concret, le modèle ou le diff ici]

Enseignement & Heuristique

• À faire : [Règle actionnable pour les futurs agents]
• À ne pas faire : [Ce qui doit être évité]

### Schéma `etapas.json`

Le fichier `etapas.json` suit la progression actuelle du cycle de vie :

```json
{
  "project": "agent-loop-project",
  "loop_version": "2.0.0",
  "updated_at": "2026-11-06T21:00:00Z",
  "current_stage": "fix",
  "stages": [
    {
      "id": "reproduce",
      "role": "Sous-agent de Reproduction QA",
      "status": "completed",
      "input": "Rapport de bug #402",
      "output": "tests/repro_spec.ts",
      "memory_consulted": ["CASE-001-fix-auth-race-condition.md"]
    },
    {
      "id": "fix",
      "role": "Sous-agent Ingénieur de Correctif Principal",
      "status": "in_progress",
      "input": "tests/repro_spec.ts",
      "output": null,
      "memory_consulted": []
    }
  ],
  "metrics": {
    "total_cycles": 1,
    "positive_patterns_harvested": 0,
    "negative_patterns_avoided": 1
  }
}

---

Archétypes de Domaine Intégrés

L'Architecte de Boucle d'Agent inclut 4 pipelines de domaine éprouvés. Pour des instructions complètes étape par étape et des prompts pour chaque archétype, voir domain-examples.md.

1. Correction de Bugs & Ingénierie

• Pipeline : Reproduire -> Cause Racine -> Corriger -> Tester -> Documenter
• Vérification Apprendre : Ingérer les correctifs antérieurs pour les sous-systèmes connexes ; éviter les régressions passées.
• Porte de Vérification : Les tests de reproduction passent de ROUGE à VERT ; aucune rupture de test collatérale.
• Compresser : Stocker l'explication de la cause racine et le diff de correctif minimal dans .loop-memory/positive-cases/.

2. Contenu & Rédaction

• Pipeline : Recherche d'Audience & d'Angle -> Accroche & Brouillon Narratif -> Critique & Polissage du Ton -> Relecture & Vérification des Faits -> Emballage de Distribution
• Vérification Apprendre : Lire les accroches les plus performantes et les mots-clés/interdits bannis.
• Porte de Vérification : Niveau de lecture cible, score de grille de voix de marque $\ge 8.5/10$, affirmations factuelles vérifiées.
• Compresser : Récolter les angles performants et les formules d'accroche dans la mémoire.

3. Prospection Commerciale

• Pipeline : Intelligence ICP -> Hypothèse de Valeur -> Séquencement Personnalisé -> Contre-Argumentation des Objections -> Préparation d'Envoi
• Vérification Apprendre : Interroger les taux de réponse sur les propositions de valeur, les modèles d'objection et les hypothèses invalides.
• Porte de Vérification : Liste de contrôle de spécificité (pas de lignes de publipostage génériques), conformité aux directives anti-spam.
• Compresser : Sauvegarder les accroches de personnalisation réussies et enregistrer les angles à faible réponse dans les cas négatifs.

4. Recherche, Analyse Financière & Juridique

• Pipeline : Découverte & Ingestion de Sources -> Vérification des Faits & Matrice de Risques -> Synthèse Quantitative / Juridique -> Test de Scénarios de Stress -> Briefing Exécutif
• Vérification Apprendre : Ingérer les précédents jurisprudentiels, les omissions d'analyses passées et les normes de validité des données.
• Porte de Vérification : Traçabilité à 100 % des sources citées ; matrices de risques testées contre des scénarios de stress.
• Compresser : Sauvegarder les modèles de synthèse, les évaluations de fiabilité des sources et les heuristiques d'évaluation des risques.

---

Directives de Dispatch des Sous-agents

Lors du dispatch de sous-agents à l'intérieur d'une boucle :

1. Spécificité du Rôle : Ne sollicitez jamais un agent généraliste. Préfixez les prompts avec des instructions de rôle de domaine (par exemple, Vous êtes le Sous-agent de Reproduction QA...).
2. Injection Mémoire : Fournissez toujours les chemins ou un résumé des cas .loop-memory/ pertinents dans le prompt initial du sous-agent.
3. Transmissions Discrètes : Les sous-agents doivent communiquer via des fichiers explicites (par exemple, scripts de reproduction, fichiers de brouillon, grilles d'évaluation) plutôt que par l'historique de conversation.
4. Porte d'Étape Autonome : Un sous-agent n'est PAS autorisé à faire passer le statut etapas.json à "completed" sans preuve vérifiable (logs, sorties de test, scores de validation).

---

Erreurs Courantes & Anti-modèles

Anti-modèle	Pourquoi Cela Casse la Boucle	La Bonne Pratique
Sauter la phase Apprendre	Les agents réinventent des bugs connus ou utilisent des angles de copie rejetés.	Imposer la lecture de .loop-memory/ comme étape 0 dans chaque prompt.
Omettre la phase Compresser	Les leçons sont perdues dès que le contexte de la session est réinitialisé.	Ne jamais conclure une tâche sans distiller les cas gagnants/échoués dans des fichiers.
Exécution monolithique de l'agent	Un seul agent se trompe en essayant de planifier, coder, vérifier et documenter à la fois.	Dispatcher des sous-agents spécialisés pour chaque étape discrète.
Vérification molle (« a l'air bon »)	Les hallucinations se glissent en production.	Utiliser des portes déterministes : suites de tests, sortie de linter, citations de faits.
Boucles de tentative illimitées	L'agent boucle indéfiniment sur un défaut non réparable.	Limiter les tentatives de boucle à 3 itérations avant de déclencher une porte d'escalade humaine.