FactorSmith: Agentic Simulation Generation via Markov Decision Process Decomposition with Planner-Designer-Critic Refinement

Le papier présente FactorSmith, un cadre qui génère des simulations de jeux exécutables à partir de descriptions textuelles en combinant une décomposition de POMDP factorisé pour réduire le contexte et un flux de travail agenciel hiérarchique (planificateur, concepteur, critique) pour affiner itérativement la qualité du code.

L'essentiel

Imaginez que vous voulez construire une maison entière, mais vous ne donnez les instructions qu'à un seul architecte qui a une mémoire très courte et qui a tendance à inventer des choses quand il est débordé. C'est un peu le problème que rencontrent les intelligences artificielles (les "LLM") quand on leur demande de créer un jeu vidéo ou une simulation complexe à partir d'une simple phrase.

Le papier FactorSmith propose une solution ingénieuse en combinant deux idées simples : découper le travail et faire travailler une équipe.

Voici comment cela fonctionne, expliqué avec des analogies du quotidien :

1. Le Problème : Le "Grand Livre" trop gros

Quand on demande à une IA de coder un jeu complet d'un coup, c'est comme lui donner un livre de 1000 pages et lui dire : "Écris le chapitre 50". L'IA oublie souvent ce qui s'est passé au chapitre 1, invente des personnages qui n'existent pas, ou modifie des parties du livre qui ne concernent pas le chapitre 50. Elle se perd dans le contexte.

2. La Solution : L'approche "FactorSmith"

FactorSmith utilise une stratégie en deux temps, comme un chef d'orchestre très organisé.

Étape A : Le découpage intelligent (La "Factored POMDP")

Au lieu de demander à l'IA de tout faire d'un coup, le système découpe la simulation en petites pièces de puzzle.

• L'analogie : Imaginez que vous construisez une maison. Au lieu de dire à l'ouvrier "Construis toute la maison", vous lui dites : "Aujourd'hui, on pose seulement les briques du mur du salon". Demain, on s'occupe de la toiture.
• L'avantage : L'IA n'a besoin de se souvenir que des briques du salon. Elle ne se perd pas dans les détails de la toiture ou de la plomberie. C'est ce qu'on appelle la réduction du contexte.

Étape B : La triade d'agents (Le Planner, le Designer, le Critique)

C'est ici que FactorSmith devient vraiment malin. Pour chaque petite pièce du puzzle (par exemple, "poser les briques du salon"), l'IA ne travaille pas seule. Elle utilise une petite équipe de trois personnes virtuelles :

1. Le Designer (L'Architecte créatif) : Il propose le code, il dessine les briques.
2. Le Critique (L'Inspecteur de qualité) : Il ne crée rien. Il regarde le travail du Designer et dit : "Attends, cette brique est de travers" ou "Tu as oublié la fenêtre". Il donne une note précise.
3. Le Planner (Le Chef de chantier) : Il écoute les deux. Si le Designer a fait une erreur, le Chef dit : "On recommence ce mur". Si le travail est bon, il dit : "C'est validé, on passe à la suite".

L'analogie du "Rebond" :
Si le Designer fait une erreur, le système ne se contente pas de dire "Essaie encore". Le Chef de chantier a une mémoire de sauvegarde. Si la nouvelle version est pire que l'ancienne, il annule le changement et revient au point de départ sûr. C'est comme jouer à un jeu vidéo avec des points de contrôle : si vous tombez dans un trou, vous reprenez juste avant, au lieu de recommencer tout le niveau.

3. Pourquoi ça marche mieux ?

Le papier montre que cette méthode est supérieure pour deux raisons principales :

• Moins d'hallucinations : En donnant à l'IA seulement les informations nécessaires pour la tâche actuelle (le mur du salon), elle ne s'invente pas des choses bizarres.
• Meilleure qualité : Grâce au "Critic" qui note le travail, l'IA s'améliore à chaque tentative. C'est comme un professeur qui corrige un devoir avant qu'il ne soit rendu, au lieu de simplement le noter à la fin.

En résumé

FactorSmith, c'est comme passer d'un artisan solitaire qui essaie de construire un gratte-ciel tout seul (et qui fait des erreurs) à une entreprise de construction ultra-organisée :

1. On divise le chantier en petites zones gérables.
2. Pour chaque zone, on a un architecte qui propose, un inspecteur qui vérifie, et un chef qui décide de valider ou de rejeter le travail.
3. On ne passe à la zone suivante que lorsque la zone actuelle est parfaite.

Le résultat ? Des simulations de jeux vidéo générées par ordinateur qui fonctionnent mieux, contiennent moins de bugs et respectent mieux les consignes que les méthodes précédentes. C'est une façon intelligente de dire à l'IA : "Prends ton temps, travaille petit à petit, et fais-toi vérifier".

Résumé technique

1. Problématique

La génération de simulations exécutables (notamment des jeux vidéo ou des environnements d'apprentissage par renforcement) à partir de spécifications en langage naturel reste un défi majeur. Les modèles de langage (LLM) actuels éprouvent des difficultés face aux bases de code vastes et interconnectées, ce qui entraîne :

• Des hallucinations (fonctions inexistantes).
• L'ignorance de parties des spécifications.
• Des modifications de code non pertinentes pour la tâche en cours.

Les approches existantes souffrent de deux limites principales :

1. FactorSim : Utilise une décomposition POMDP (Processus de Décision Markovien Partiellement Observable) pour réduire le contexte, mais repose sur une génération "en un seul coup" (single-shot) par étape, sans mécanisme d'auto-correction robuste.
2. SceneSmith : Utilise une architecture d'agents (Planificateur-Concepteur-Critique) pour l'affinement itératif, mais ne tire pas parti de la structure factorisée des simulations pour réduire le contexte.

2. Méthodologie : FactorSmith

FactorSmith propose un cadre unifié combinant la décomposition factorisée (pour la réduction de contexte) et un flux de travail d'agents hiérarchique (pour l'affinement itératif).

A. Décomposition Factorisée (POMDP)

Le système modélise la simulation comme un POMDP factorisé sur son espace d'états $S = S[1] \times \dots \times S[n]$.

• Principe : La génération est décomposée en étapes modulaires. Pour chaque étape, le système sélectionne uniquement un sous-ensemble minimal de variables d'état pertinentes (le "scope" $Z_k$) et les fonctions qui en dépendent.
• Avantage : Cela réduit drastiquement la fenêtre de contexte que chaque appel LLM doit traiter, évitant la surcharge cognitive du modèle.

B. Flux de Travail Agentique (Planificateur-Concepteur-Critique)

Au sein de chaque étape factorisée, FactorSmith intègre une interaction tripartite d'agents (inspirée de SceneSmith) :

1. Le Concepteur (Designer) : Propose des artefacts de code (fonctions d'entrée, transitions d'état, rendu) en se basant uniquement sur le contexte restreint ($S[Z_k]$).
2. Le Critique (Critic) : Évalue la proposition du concepteur selon des rubriques structurées (exactitude, complétude, usage des états, qualité du code) et attribue des scores numériques et un feedback textuel.
3. Le Planificateur (Planner) : Orchestre l'interaction. Il décide d'accepter la proposition, de demander une révision, ou de procéder à un rollback (retour à un point de contrôle précédent) si la qualité se dégrade.

C. Pipeline d'Exécution

Le processus se déroule en trois phases :

1. Décomposition de haut niveau : La spécification textuelle est divisée en étapes modulaires via Chain-of-Thought.
2. Exécution des étapes factorisées : Pour chaque étape, le pipeline sélectionne le contexte pertinent, décompose la requête en composants MVC (Contrôleur, Modèle, Vue), et exécute le cycle d'affinement agentique pour chaque composant.
3. Assemblage et Validation : Les fonctions générées sont assemblées et vérifiées pour la compilation et l'exécution de base.

3. Contributions Clés

1. Cadre Unifié : Formalisation d'un pipeline intégrant un flux de travail agentique (Planificateur-Concepteur-Critique) à l'intérieur de chaque étape d'une génération factorisée POMDP.
2. Analyse Mathématique : Démonstration de la composition entre l'affinement agentique et la sélection de contexte factorisé, avec une analyse des compromis computationnels.
3. Implémentation Open Source : Développement d'une architecture basée sur le SDK OpenAI Agents, utilisant SQLite pour la gestion des sessions et des points de contrôle, avec un système de notation structurée.
4. Résultats Empiriques : Preuve expérimentale que cette approche surpasse les bases non-agentiques et les approches factorisées simples en termes de justesse du code et d'alignement avec les prompts.

4. Résultats Expérimentaux

Les expériences ont été menées sur le benchmark PyGame Learning Environment (PLE), couvrant 8 jeux 2D (ex: Flappy Bird, Snake, Pong).

• Performance : FactorSmith surpasse tous les baselines (Vanilla, Self-Debug, FactorSim, AgentCoder) sur tous les jeux.
  • Par rapport à FactorSim (la base la plus forte), FactorSmith améliore le taux de réussite des tests système de 7 à 8 points de pourcentage sur les jeux complexes (ex: Catcher, Waterworld).
• Robustesse : Le taux de réussite à l'exécution (300 frames sans crash) est significativement plus élevé.
• Étude d'ablation :
  • Le retrait du Critique réduit les performances de 7 points, confirmant l'importance de l'évaluation itérative.
  • Le retrait de la factorisation (utilisation du contexte complet avec agents) entraîne la plus grande dégradation (-12 points), prouvant que la réduction de contexte est la technique la plus impactante.
• Efficacité des Tokens : Bien que FactorSmith utilise plus de tokens que FactorSim (à cause de l'affinement itératif), il en utilise moins que les approches CoT + Self-Debug grâce à la sélection de contexte restreint et à l'arrêt précoce grâce au score structuré.

5. Signification et Perspectives

FactorSmith démontre que la décomposition structurelle (réduction du contexte) et l'affinement agentique (amélioration de la qualité) sont complémentaires et non mutuellement exclusives.

• Innovation : La séparation des rôles de génération et d'évaluation, couplée à une structure de contexte restreint, permet de capturer des erreurs subtiles (off-by-one, références incorrectes) que les générations en un seul coup manquent.
• Limites : L'approche est actuellement limitée aux simulations 2D (PyGame) et introduit une latence et un coût supplémentaires. Les scores du critique, bien que structurés, restent des jugements d'LLM et peuvent être mal calibrés.
• Futur : Les auteurs envisagent d'intégrer un feedback basé sur l'exécution réelle du code, d'étendre la méthode aux simulations 3D pour la robotique, et d'entraîner des modèles plus petits spécialisés pour les rôles de concepteur et de critique afin de réduire les coûts.

En résumé, FactorSmith représente une avancée significative dans la génération de code par IA, en transformant la création de simulations d'un processus linéaire et fragile en un processus itératif, structuré et auto-correctif.