AutoGen Framework : tutoriel multi-agent Python

Introduction

Le autogen framework sert surtout à construire des agents qui dialoguent entre eux au lieu d'enchaîner des étapes fixes. Il est pertinent si vous devez faire collaborer plusieurs rôles — par exemple recherche, critique et synthèse — dans un prototype Python rapidement testable. En revanche, pour un workflow linéaire, c'est souvent overkill : un script simple, un seul agent ou un graphe explicite sera parfois plus simple à maintenir. Dans ce tutoriel, vous allez installer AutoGen, comprendre ses briques utiles et monter un premier duo d'agents avant de décider si c'est vraiment le bon choix pour votre cas.

Résumé rapide

1. Installez AutoGen dans un environnement Python 3.10+ dédié.
2. Utilisez AssistantAgent pour les rôles LLM et OpenAIChatCompletionClient pour le client modèle.
3. Commencez par un agent seul, puis passez à RoundRobinGroupChat seulement si la collaboration apporte un vrai gain.
4. Validez tôt les limites de tours, les logs et les conditions d'arrêt avant toute mise en production.

Qu'est-ce qu'AutoGen framework et quand l'utiliser ?

AutoGen est un framework conversationnel publié par Microsoft Research. Son idée centrale est simple : au lieu de coder un pipeline rigide, vous faites interagir des agents par messages. Chaque agent reçoit un contexte, répond, puis transmet le relais à un autre acteur ou à une équipe. Ce modèle convient bien aux tâches où la qualité progresse par aller-retour : une première proposition, une critique, une révision, puis une validation finale.

Concrètement, AutoGen devient intéressant quand un seul prompt ne suffit plus. Si vous voulez séparer les responsabilités entre un agent “rédacteur”, un agent “relecteur” et éventuellement un agent “coordinateur”, le framework fournit déjà les primitives de base. C'est la raison pour laquelle il revient souvent dans les discussions sur les frameworks d'agents IA et sur l'orchestration d'agents.

L'autre intérêt d'AutoGen est pédagogique : il aide à visualiser comment une architecture multi-agent produit un résultat par conversation plutôt que par simple appel LLM isolé. En revanche, il faut garder une thèse claire : AutoGen n'est pas là pour rendre un agent “plus intelligent par magie”, mais pour rendre explicite une collaboration entre rôles. Si votre besoin tient dans un formulaire, une transformation de texte ou un workflow strictement déterministe, un outil comme LangGraph ou même un script applicatif plus classique sera souvent plus lisible.

La bonne question n'est donc pas “AutoGen est-il puissant ?”, mais “ai-je réellement besoin d'une conversation multi-agent pour améliorer mon résultat ?”. Si la réponse est non, restez sur une approche plus simple.

Installer AutoGen et créer un premier duo d'agents

Prérequis

Avant de toucher au code, vérifiez trois points :

• Python 3.10+
• un environnement virtuel dédié
• une clé API pour le fournisseur que vous comptez utiliser

AutoGen peut sembler accessible dès le premier import, mais la vraie difficulté vient ensuite : la coordination. C'est pour cela qu'il vaut mieux démarrer petit. Si vous débutez complètement avec les architectures agentiques, le guide créer un agent IA peut aider à poser les bases avant de complexifier.

Étape 1 — créer un environnement propre

python3 -m venv .venv
source .venv/bin/activate
python --version

Sortie attendue : Python 3.10+ et un shell pointant sur .venv.

L'objectif n'est pas seulement la propreté du projet. Vous évitez aussi de mélanger AutoGen avec d'autres bibliothèques d'agents et de perdre du temps sur des conflits de dépendances difficiles à diagnostiquer.

Étape 2 — installer les paquets documentés officiellement

La documentation officielle mentionne l'installation suivante :

pip install -U "autogen-agentchat" "autogen-ext[openai]"

Sortie attendue : l'installation se termine sans erreur, puis pip show autogen-agentchat et pip show autogen-ext trouvent les deux paquets.

Ce duo suffit pour un premier tutoriel orienté conversation d'agents. Inutile de chercher tout de suite une pile complète avec mémoire, base vectorielle et outils externes. Si votre besoin principal est un workflow d'équipe plus directif, comparez aussi l'approche CrewAI avant de vous engager plus loin.

Étape 3 — configurer la clé API

Dans un shell Unix :

export OPENAI_API_KEY="votre_cle"
python - <<'PY'
import os
print(bool(os.environ.get("OPENAI_API_KEY")))
PY

Sortie attendue : True.

Cette vérification volontairement minimale vous évite un faux départ. Beaucoup de premiers essais “ratés” avec AutoGen viennent d'un problème de variable d'environnement, pas du framework lui-même.

Étape 4 — lancer un agent simple avant le multi-agent

Commencez par un seul AssistantAgent. Cela permet d'isoler le couple prompt + modèle avant d'ajouter de la coordination.

import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient

model_client = OpenAIChatCompletionClient(model="gpt-4o-mini")

agent = AssistantAgent(
    name="assistant_fr",
    model_client=model_client,
    system_message=(
        "Tu réponds en français avec un plan court, "
        "puis trois points d'action maximum."
    ),
)

async def main():
    result = await agent.run(task="Résume en 5 lignes ce qu'est un système multi-agent.")
    print(result.messages[-1].content)

asyncio.run(main())

Sortie attendue : une réponse textuelle finale, structurée en français. Si ce test échoue, n'ajoutez pas d'autres agents. Corrigez d'abord l'accès modèle, le prompt système et l'environnement.

Étape 5 — passer à un duo qui collabore

Une fois le premier agent validé, introduisez un deuxième rôle. Les exemples locaux utilisent AssistantAgent, OpenAIChatCompletionClient et RoundRobinGroupChat, ce qui est suffisant pour comprendre la logique sans sur-ingénierie.

import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_ext.models.openai import OpenAIChatCompletionClient

model_client = OpenAIChatCompletionClient(model="gpt-4o-mini")

researcher = AssistantAgent(
    name="researcher",
    model_client=model_client,
    system_message=(
        "Tu proposes une première réponse courte, factuelle et incomplète si besoin."
    ),
)

reviewer = AssistantAgent(
    name="reviewer",
    model_client=model_client,
    system_message=(
        "Tu critiques la réponse du researcher, tu corriges les zones floues "
        "et tu termines par une version finale concise."
    ),
)

team = RoundRobinGroupChat([researcher, reviewer], max_turns=4)

async def main():
    result = await team.run(task="Explique à un développeur quand utiliser un système multi-agent.")
    print(result.messages[-1].content)

asyncio.run(main())

Ici, le point important n'est pas le style de sortie. C'est la répartition des responsabilités. Le premier agent produit une base, le second agit comme garde-fou. Vous observez déjà le cœur d'AutoGen : la qualité vient moins d'un super prompt unique que d'une conversation courte entre rôles complémentaires.

Étape 6 — interpréter correctement le résultat

Si la réponse finale semble meilleure qu'avec l'agent seul, demandez-vous pourquoi. Est-ce grâce à la critique ? À une meilleure formulation ? Ou simplement parce que vous avez doublé le nombre d'appels modèle ? Cette question compte en production, car chaque tour supplémentaire ajoute du coût, de la coordination et potentiellement de la latence.

En pratique, gardez une checklist de validation simple :

• l'agent seul donne déjà une base correcte ;
• le second agent améliore vraiment le résultat sur vos exemples ;
• max_turns est limité ;
• le prompt de chaque rôle est distinct ;
• le résultat final peut être évalué humainement.

Si vous n'arrivez pas à prouver ce gain sur trois ou quatre tâches réelles, ne passez pas au multi-agent. AutoGen est utile quand la conversation apporte une vraie valeur, pas quand elle remplace une décision d'architecture.

Exemple concret : revue d'un brouillon technique à deux agents

Prenons un cas simple et vérifiable : vous rédigez un mini brouillon de documentation interne sur un outil Python. Vous voulez éviter deux défauts fréquents : une première version trop floue et une conclusion qui oublie les limites. Avec AutoGen, créez un agent researcher chargé de produire le brouillon initial et un agent reviewer chargé d'ajouter les oublis, de retirer le jargon et de signaler ce qui n'est pas vérifié.

La tâche peut être : “Rédige un résumé de 120 mots sur la création d'un agent de support interne, puis relis-le pour identifier les hypothèses non prouvées.” Avec RoundRobinGroupChat et max_turns=4, vous obtenez une séquence courte : proposition, critique, correction, version finale. Le résultat attendu n'est pas “plus long”, mais plus sûr : moins d'affirmations gratuites, une structure plus claire et une meilleure séparation entre faits, hypothèses et prochaines actions.

C'est un bon exemple parce qu'il prouve quelque chose de précis : AutoGen vaut le coup quand la relecture d'un second rôle améliore la fiabilité du texte. Si votre second agent ne fait que paraphraser le premier, vous payez surtout de la coordination supplémentaire.

Bonnes pratiques pour éviter le multi-agent gadget

Commencez toujours avec une borne de conversation stricte : max_turns, tâche claire et critères d'arrêt visibles. Sans cela, les agents bavardent, les logs deviennent difficiles à lire et le bénéfice métier disparaît derrière le bruit.

Ensuite, instrumentez tôt. Même sur un prototype, gardez un run_id, l'historique des messages, le prompt système utilisé et le nombre de tours. Ce minimum d'observabilité aide à comprendre si un mauvais résultat vient du modèle, d'un rôle mal défini ou d'un simple problème de coordination. En production, ajoutez du monitoring sur les échecs d'appel, les retries et la durée moyenne par conversation.

Enfin, surveillez le coût caché : plus d'agents signifie souvent plus de messages, donc plus de maintenance. Le vrai risque n'est pas seulement financier ; c'est aussi la dette de coordination. Si deux agents n'apportent pas un gain mesurable de qualité, restez sur une approche plus simple et plus facile à tester.

Questions fréquentes

AutoGen framework est-il adapté à un débutant ?

Oui pour apprendre les bases d'un système conversationnel, mais pas comme premier framework si vous ne maîtrisez pas déjà Python, les appels API et l'asynchrone. Pour un premier projet agentique en production, AutoGen peut être déroutant. Il devient pertinent quand vous voulez comprendre comment plusieurs rôles coopèrent réellement.

Quelle différence entre AutoGen et un agent Python classique ?

Un agent Python classique encapsule souvent un prompt, quelques outils et une logique séquentielle. AutoGen ajoute une structure de conversation entre rôles distincts. La différence utile n'est donc pas “plus d'IA”, mais plus de coordination. Si cette coordination n'améliore pas le résultat, AutoGen n'apporte pas grand-chose.

Faut-il commencer par un GroupChat tout de suite ?

Non. Le bon réflexe est de valider d'abord un agent seul avec un objectif précis, puis d'ajouter un second rôle seulement si vous voyez un manque clair : critique, validation ou reformulation. Un RoundRobinGroupChat est utile quand chaque tour a une fonction identifiable, pas pour rendre la démo plus impressionnante.

AutoGen fonctionne-t-il seulement avec l'écosystème Microsoft ?

Non. Le framework vient de Microsoft Research, mais le tutoriel de base repose surtout sur des paquets Python et un client modèle. Ce qui compte, c'est la compatibilité du client choisi et la qualité de votre orchestration. L'ancrage Microsoft n'oblige pas à bâtir toute votre architecture autour d'Azure.

Articles liés

AutoGen est surtout un bon choix quand vous avez besoin d'une collaboration explicite entre rôles, pas quand un seul agent suffit. Commencez petit, mesurez le gain réel sur vos tâches, puis augmentez la complexité seulement si la conversation améliore la qualité. Si vous hésitez encore, la prochaine étape logique est de comparer AutoGen à un framework plus directif ou de revoir les bases d'architecture multi-agent.

• Panorama des frameworks d'agents IA
• Guide complet pour comprendre OpenClaw
• Comparatif OpenClaw vs AutoGen pour choisir plus vite
• Architectures multi-agents : modèles utiles et limites
• Créer un agent IA pas à pas avant de complexifier