Skip to content

methodology.md

Latest commit

 

History

History
133 lines (97 loc) · 3.54 KB

methodology.md

File metadata and controls

133 lines (97 loc) · 3.54 KB

Méthodologie d'Entraînement

🎯 Objectif

Cette méthodologie explique comment entraîner un agent à raisonner structurellement, sans règles explicites codées en dur.

🚫 Ce qu'il NE FAUT PAS Faire

❌ Règles Explicites

Interdit : Coder des règles conditionnelles explicites

# ❌ MAUVAIS
if error_rate > 0.5:
    decision = "refused"
elif tests_passed and security_ok:
    decision = "accepted"

❌ Logique Métier dans le Code

Interdit : Coder la logique métier directement

# ❌ MAUVAIS
def should_deploy():
    if code_merged and tests_passed:
        return True
    return False

✅ Ce qu'il FAUT Faire

✅ Structurer en Graphe

Autorisé : Construire un graphe où les signaux convergent

# ✅ BON
graph = Graph()
graph.add_node(Node(id="A", content="Code merged", status=PROVEN))
graph.add_node(Node(id="B", content="Tests passed", status=UNCERTAIN))
graph.add_node(Node(id="G", content="Deploy", type=GOAL))
graph.add_edge(Edge(source="A", target="G", type=SUPPORTS))
graph.add_edge(Edge(source="B", target="G", type=SUPPORTS))

✅ Laisser Émerger les Décisions

Autorisé : Laisser l'agent décider en fonction de la convergence

# ✅ BON
agent = AutonomousAgent(graph)
result = agent.decide(goal="G")
# La décision émerge de la convergence des signaux

📋 Étapes d'Entraînement

Étape 1 : Identifier les Signaux

Identifier tous les signaux pertinents pour la décision :

  • Signaux techniques (tests, sécurité, infrastructure)
  • Signaux organisationnels (approbations, politiques)
  • Signaux contextuels (trafic, charge, événements)

Étape 2 : Structurer le Graphe

Construire le graphe :

  • Nœuds = signaux
  • Arêtes = relations (supports, requires, contradicts)
  • Goal = décision à prendre

Étape 3 : Définir les Relations

Définir comment les signaux se relient :

  • SUPPORTS : un signal supporte la décision
  • REQUIRES : un signal est requis pour la décision
  • CONTRADICTS : un signal contredit la décision

Étape 4 : Tester la Convergence

Tester différents scénarios :

  • Scénario 1 : Tous les signaux PROVEN → accepted ?
  • Scénario 2 : Signaux incertains → partial ?
  • Scénario 3 : Signaux insuffisants → refused ?

Étape 5 : Évaluer l'Émergence

Vérifier que les décisions émergent correctement :

  • Les décisions sont-elles justifiables ?
  • Les invariants sont-ils respectés ?
  • Les cas limites sont-ils gérés ?

🎓 Exemple : Exercice DevOps

Scénario : Décision de Déploiement

Signaux identifiés :

  • A : Code merged
  • B : Tests passed
  • C : Security scan clean
  • D : Infra stable
  • E : Manual approval

Structure du graphe :

A → G (SUPPORTS)
B → G (SUPPORTS)
C → G (SUPPORTS)
D → G (SUPPORTS)
E → G (SUPPORTS)

Test de convergence :

  • Si B, C, D sont PROVEN → accepted
  • Si B, C, D sont UNCERTAIN → partial
  • Si seulement A est PROVEN → refused (A est un prérequis, pas un signal décisionnel)

🔑 Points Clés

  1. Structure > Logique : La structure du graphe est plus importante que la logique codée
  2. Convergence : Les décisions émergent de la convergence des signaux
  3. Explicabilité : Chaque décision doit être justifiable via le graphe
  4. Invariants : Les invariants émergent naturellement, pas explicitement

📚 Références

  • Voir invariants.md pour les invariants émergents
  • Voir evaluation.md pour le protocole d'évaluation
  • Voir exercise_template.md pour créer un nouvel exercice