AutoGen : guide complet du framework multi-agents Microsoft

Orchestrer plusieurs agents IA qui collaborent, se corrigent mutuellement et exécutent du code sans intervention humaine constante est un défi technique non trivial. AutoGen, développé par Microsoft Research, propose une réponse concrète : un modèle conversationnel où chaque agent est un acteur autonome qui envoie et reçoit des messages. Ce guide couvre l'architecture interne d'AutoGen, ses composants clés, l'installation, la configuration et un exemple complet de pipeline multi-agents. À la fin, vous saurez décider si AutoGen correspond à votre cas d'usage.

---

Résumé rapide

Critère	Valeur
Créateur	Microsoft Research
Licence	MIT
Langage	Python 3.10+
Version stable	AutoGen 0.4.x (modèle acteurs asynchrone)
Approche	Agents conversationnels — message passing multi-tours
Points forts	Exécution de code sécurisée, GroupChat, flexibilité LLM
Points faibles	Courbe d'apprentissage v0.4, débogage de conversations longues

---

Ce qu'est AutoGen et sa place dans l'écosystème

AutoGen est un framework open-source Python conçu pour créer des systèmes où plusieurs agents LLM collaborent via des échanges de messages structurés. Chaque agent peut être un modèle de langage, un outil d'exécution de code, un proxy humain ou un groupe d'agents entier.

Historique et versions

La version 0.2 a popularisé le pattern AssistantAgent / UserProxyAgent. Elle reste largement utilisée dans les tutoriels en ligne. La version 0.4, publiée fin 2024, représente une réécriture substantielle : elle introduit un modèle d'acteurs asynchrone (inspiré d'Erlang/Akka) qui permet d'exécuter des agents en parallèle sans bloquer le fil principal. Les deux APIs coexistent dans la base de code, mais les nouveaux projets doivent cibler la v0.4.

Philosophie : tout est conversation

Là où des frameworks comme LangGraph modélisent un graphe d'états, AutoGen modélise une conversation. Un agent reçoit un message, produit une réponse (texte, appel d'outil, exécution de code), et transmet le résultat au prochain agent. Ce modèle est naturel pour les tâches itératives : rédaction + révision, génération de code + tests, recherche + synthèse.

Position dans l'écosystème Microsoft

AutoGen s'intègre nativement avec :

• Azure OpenAI — configuration directe sans surcouche
• Semantic Kernel — Microsoft positionne les deux frameworks comme complémentaires (SK pour les workflows d'entreprise, AutoGen pour les systèmes multi-agents exploratoires)
• Promptflow — possible pour le monitoring en production

Il reste néanmoins totalement compatible avec des LLM tiers : Anthropic Claude, Mistral, modèles locaux via Ollama ou LM Studio.

---

Architecture et composants principaux

ConversableAgent : la brique de base

Tout agent AutoGen hérite de ConversableAgent. Cette classe gère :

• La mémoire de conversation (historique des messages)
• La configuration LLM (modèle, température, clé API)
• Les fonctions d'outil enregistrées
• La logique de terminaison (quand arrêter la conversation)

Un ConversableAgent peut répondre automatiquement (via LLM), répondre via une fonction Python, ou demander une saisie humaine.

AssistantAgent

AssistantAgent est un ConversableAgent préconfiguré pour jouer le rôle d'un assistant LLM. Il génère des réponses textuelles ou propose des blocs de code à exécuter. Par défaut, il ne peut pas exécuter de code lui-même — il délègue cette responsabilité à un UserProxyAgent.

Configuration minimale :

from autogen import AssistantAgent

assistant = AssistantAgent(
    name="assistant",
    llm_config={
        "model": "gpt-4o",
        "api_key": "sk-...",
    },
    system_message="Tu es un expert Python. Propose du code clair et testé.",
)

UserProxyAgent

UserProxyAgent simule l'utilisateur humain dans la boucle. Son rôle principal : exécuter le code proposé par l'assistant, puis renvoyer le résultat dans la conversation. Il supporte trois modes d'intervention humaine :

• ALWAYS — demande confirmation à chaque message
• NEVER — exécution entièrement automatique
• TERMINATE — intervention uniquement pour arrêter la conversation

from autogen import UserProxyAgent

user_proxy = UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",
    code_execution_config={
        "work_dir": "workspace",
        "use_docker": True,  # recommandé en production
    },
    max_consecutive_auto_reply=10,
)

Le paramètre use_docker est critique pour la sécurité : avec True, le code s'exécute dans un conteneur isolé. Sans Docker, le code tourne directement dans l'environnement Python du processus hôte.

GroupChat et GroupChatManager

Pour les pipelines avec plus de deux agents, AutoGen fournit GroupChat et GroupChatManager. Le GroupChat définit les participants et la stratégie de sélection du prochain locuteur. Le GroupChatManager orchestre les tours de parole.

from autogen import GroupChat, GroupChatManager

group_chat = GroupChat(
    agents=[assistant_coder, assistant_reviewer, user_proxy],
    messages=[],
    max_round=15,
    speaker_selection_method="auto",  # ou "round_robin", ou une fonction custom
)

manager = GroupChatManager(
    groupchat=group_chat,
    llm_config={"model": "gpt-4o", "api_key": "sk-..."},
)

Le mode speaker_selection_method="auto" délègue au LLM le choix du prochain intervenant, ce qui produit des conversations plus fluides mais augmente le coût en tokens.

Installation

pip install pyautogen
# Avec support Docker pour l'exécution de code isolée
pip install pyautogen[docker]
# Avec dépendances pour les outils mathématiques
pip install pyautogen[mathchat]

Pour la v0.4 avec le modèle acteurs :

pip install "autogen-agentchat>=0.4" "autogen-ext[openai]"

Les deux packages coexistent. pyautogen maintient l'API v0.2/v0.3 ; autogen-agentchat est le nouveau package v0.4.

Configuration LLM centralisée

AutoGen supporte un fichier de configuration pour gérer plusieurs modèles et clés API :

config_list = [
    {
        "model": "gpt-4o",
        "api_key": "sk-...",
    },
    {
        "model": "claude-3-5-sonnet-20241022",
        "api_key": "sk-ant-...",
        "api_type": "anthropic",
    },
]

llm_config = {
    "config_list": config_list,
    "temperature": 0.1,
    "timeout": 120,
}

AutoGen fait automatiquement du fallback : si le premier modèle échoue (quota, erreur réseau), il essaie le suivant dans la liste.

---

Exemple concret : pipeline de génération et validation de code

Ce pipeline met en place trois agents : un agent qui génère du code Python, un agent qui le relit et suggère des améliorations, et un proxy qui exécute le code final.

import autogen

config_list = autogen.config_list_from_json("OAI_CONFIG_LIST")

llm_config = {
    "config_list": config_list,
    "temperature": 0.1,
    "cache_seed": 42,
}

# Agent 1 : génère le code
coder = autogen.AssistantAgent(
    name="coder",
    llm_config=llm_config,
    system_message=(
        "Tu es un développeur Python senior. "
        "Quand tu proposes du code, inclus toujours des tests unitaires avec pytest. "
        "Réponds en français."
    ),
)

# Agent 2 : relit et critique le code
reviewer = autogen.AssistantAgent(
    name="reviewer",
    llm_config=llm_config,
    system_message=(
        "Tu es un expert en revue de code. "
        "Analyse le code proposé : sécurité, performance, lisibilité. "
        "Propose des corrections précises. Réponds en français."
    ),
)

# Agent 3 : exécute le code dans un environnement isolé
executor = autogen.UserProxyAgent(
    name="executor",
    human_input_mode="NEVER",
    code_execution_config={
        "work_dir": "generated_code",
        "use_docker": "python:3.11-slim",
        "timeout": 60,
    },
    max_consecutive_auto_reply=5,
    is_termination_msg=lambda msg: "TERMINÉ" in msg.get("content", ""),
)

# Création du GroupChat
group_chat = autogen.GroupChat(
    agents=[coder, reviewer, executor],
    messages=[],
    max_round=12,
    speaker_selection_method="auto",
)

manager = autogen.GroupChatManager(
    groupchat=group_chat,
    llm_config=llm_config,
)

# Lancement du pipeline
executor.initiate_chat(
    manager,
    message=(
        "Génère une fonction Python qui parse un fichier CSV, "
        "calcule la moyenne et l'écart-type de chaque colonne numérique, "
        "et retourne un dictionnaire. Inclus des tests pytest. "
        "Quand les tests passent, écris TERMINÉ."
    ),
)

Ce que fait ce pipeline :

1. executor envoie la consigne au manager
2. Le manager délègue à coder qui génère le code et les tests
3. reviewer analyse et propose des corrections
4. coder itère sur les suggestions
5. executor exécute le code dans le conteneur Docker et renvoie stdout/stderr
6. La boucle continue jusqu'au mot-clé TERMINÉ ou jusqu'à max_round

---

Bonnes pratiques et limites

Sécurité d'exécution du code

Ne jamais utiliser use_docker=False en production ou dans un environnement partagé. Le UserProxyAgent avec exécution directe peut lancer n'importe quelle commande système. Utiliser impérativement un conteneur Docker avec une image minimale (python:3.11-slim) et un timeout court.

Contrôle des coûts

Les GroupChats avec speaker_selection_method="auto" consomment des tokens à chaque tour pour choisir le prochain intervenant. Sur des tâches longues, préférer round_robin ou une fonction de sélection déterministe. Activer cache_seed dans llm_config pour rejouer des conversations sans rappeler l'API.

Débogage des conversations longues

Activer le logging pour suivre chaque message :

import logging
logging.basicConfig(level=logging.INFO)

Pour inspecter l'historique complet après une conversation :

print(group_chat.messages)

Gestion des boucles infinies

Toujours définir max_consecutive_auto_reply et max_round. Sans ces limites, un agent peut entrer dans une boucle de correction sans jamais converger. La fonction is_termination_msg permet d'arrêter proprement sur un signal applicatif.

Limites connues

• Le débogage d'une conversation de 20+ tours est laborieux : difficile de savoir quel agent a pris quelle décision.
• La v0.4 (modèle acteurs) change significativement l'API par rapport à la v0.2 : les tutoriels anciens ne sont pas directement transposables.
• Les conversations très longues font grossir le contexte LLM rapidement, ce qui augmente les coûts et peut dépasser la fenêtre contextuelle du modèle.

---

FAQ

AutoGen est-il gratuit ?

Oui. AutoGen est open-source sous licence MIT. Le coût réel est celui des appels API aux LLM que vous utilisez (OpenAI, Anthropic, etc.). Vous pouvez aussi utiliser des modèles locaux via Ollama pour réduire les coûts à zéro — la qualité dépendra alors du modèle local choisi.

Quelle est la différence entre AutoGen v0.2 et v0.4 ?

La v0.2 utilise un modèle synchrone simple. La v0.4 introduit un modèle d'acteurs asynchrone : les agents peuvent s'exécuter en parallèle, les messages sont traités via une file. L'API change (nouveau package autogen-agentchat) et offre une meilleure scalabilité, mais nécessite de reprendre le code existant.

AutoGen peut-il fonctionner sans OpenAI ?

Oui. AutoGen supporte Anthropic Claude, Mistral, Google Gemini, et les modèles locaux via des serveurs compatibles OpenAI (Ollama, LM Studio, vLLM). Il suffit de configurer api_type et base_url dans config_list.

AutoGen convient-il pour la production ?

AutoGen est utilisé en production, mais nécessite des précautions : isolation Docker pour l'exécution de code, gestion des erreurs LLM, monitoring des coûts et des tokens. Pour des workflows très structurés et prévisibles, LangGraph ou un orchestrateur dédié peuvent être plus adaptés.

Quelle différence avec CrewAI ?

AutoGen modélise des conversations libres entre agents ; CrewAI modélise des équipes avec des rôles et des tâches assignées statiquement. AutoGen est plus flexible pour les workflows exploratoires ; CrewAI est plus lisible pour des pipelines avec des étapes bien définies.

---

Articles liés

AutoGen s'inscrit dans un écosystème plus large de frameworks d'agents IA. Pour comparer directement AutoGen avec d'autres solutions, consulter la comparaison détaillée avec OpenClaw ou le guide général sur les agents IA. Si vous évaluez plusieurs frameworks avant de choisir, le comparatif global est le point de départ recommandé.

• OpenClaw vs AutoGen : comparaison 2026
• Guide complet des agents IA
• Meilleur framework agent IA : comparatif 2026
• Guide complet OpenClaw
• CrewAI : guide complet
• LangGraph : guide complet