Aller au contenu principal

Frameworks open source pour agents IA

Avancé

Une fois que vous avez construit quelques agents à la main, la même plomberie revient sans cesse : une boucle qui appelle le modèle, exécute l'outil qu'il a demandé, réinjecte le résultat, et s'arrête quand le travail est terminé. Les frameworks d'agents empaquettent cette plomberie — plus l'état, la mémoire et la coordination multi-agents — pour que vous écriviez moins de code de liaison. Cette page est une carte durable et neutre vis-à-vis des fournisseurs des principales options open source, de ce qu'elles vous apportent réellement, et de comment choisir. Presque toutes sont agnostiques au modèle : elles fonctionnent avec Claude, GPT, Gemini et des modèles locaux à poids ouverts.

What you'll learn
  • Savoir ce qu'un framework d'agent vous apporte par rapport à une boucle codée à la main — et ce qu'il ne vous apporte pas
  • Reconnaître les trois archétypes : graphes avec état, équipes basées sur les rôles, et boucles minimales
  • Utiliser une procédure reproductible pour en choisir un — en arbitrant entre complexité et contrôle
  • Se rappeler qu'ils sont pour la plupart agnostiques au modèle — le framework vous enferme rarement chez un seul fournisseur

Ce qu'un framework d'agent vous apporte réellement​

Débarrassé de son branding, un framework vous offre un sous-ensemble de quatre choses :

  • Orchestration — la boucle de contrôle. Étapes séquentielles, branches, réessais, boucles-jusqu'à-terminé, et (de plus en plus) une exécution durable qui survit à un crash et reprend là où elle s'était arrêtée.
  • Outils — une manière standard de déclarer une fonction que le modèle peut appeler, de valider ses arguments, de l'exécuter et de renvoyer le résultat. La même boucle décrire→appeler→exécuter→renvoyer que vous connaissez déjà avec l'utilisation d'outils.
  • Mémoire et état — un endroit pour conserver l'historique de conversation, les faits de brouillon et les documents récupérés d'un tour à l'autre, pour que l'agent ne soit pas amnésique entre les étapes.
  • Multi-agent — des schémas pour plusieurs agents spécialisés qui se transmettent le travail : un superviseur déléguant à des exécutants, ou des pairs collaborant sur une tâche. (Conceptuellement la même idée que les sous-agents de Claude Code.)

Un framework en vaut la peine quand vous devriez sinon écrire et maintenir à la main les quatre. Il n'en vaut pas la peine quand votre tâche est « appeler le modèle, exécuter un ou deux outils, renvoyer une réponse » — là, le framework est une surcharge contre laquelle vous passerez du temps à lutter.

Les trois archétypes​

Les frameworks diffèrent moins que leur marketing ne le suggère. Il n'existe vraiment que trois formes, et la plupart des projets sont une variation de l'une d'elles :

  • Graphe avec état / workflow. Vous modélisez l'agent comme un graphe explicite de nœuds et d'arêtes (ou d'étapes et de transitions). Contrôle maximal, état inspectable, adapté aux flux de longue durée et à ceux avec humain dans la boucle. Plus à apprendre au départ. → LangGraph, LlamaIndex Workflows.
  • Équipe basée sur les rôles. Vous décrivez les agents par rôle (« chercheur », « rédacteur », « relecteur ») et les laissez collaborer ou exécuter un processus. Rapide pour exprimer une équipe multi-agents ; vous échangez un peu de contrôle fin contre l'abstraction de haut niveau. → CrewAI, et le style conversationnel multi-agents d'AutoGen.
  • Boucle minimale / peu d'abstractions. Une fine couche au-dessus de l'appel d'outils natif du modèle, avec des transferts entre quelques agents et pas grand-chose d'autre. Facile à lire de bout en bout, facile à abandonner. → OpenAI Agents SDK (le successeur de production de l'expérimental Swarm), et la boucle simple que vous écrivez vous-même.
Pro tip
  • Commencez par la chose la plus simple qui fonctionne — souvent une simple boucle d'appel d'outils bat un framework lourd.

Un tour d'horizon rapide (vérifiez le positionnement avant de vous engager)​

Voici les projets ouverts à connaître. Ils ne sont nommés que parce que le vrai dépôt de chacun a été vérifié ; tout ce qui est volatil vit derrière la VerifyNote ci-dessus.

  • LangGraph — un framework d'orchestration bas niveau pour des agents avec état et de longue durée, modélisés comme des graphes ; l'exécution durable et l'humain dans la boucle sont de première classe. Utilisable seul ou avec l'écosystème plus large LangChain. Agnostique au modèle.
  • LlamaIndex — a démarré comme un framework de données/RAG (connecteurs, index, récupération) et propose désormais aussi une couche Workflows pilotée par événements pour les agents. Solide quand votre agent est fondamentalement une récupération sur vos documents.
  • Microsoft AutoGen — un framework pour systèmes conversationnels multi-agents. À la mi-2026, il est en mode maintenance ; Microsoft oriente les nouveaux projets vers un successeur unifié (Microsoft Agent Framework, fusionnant AutoGen + Semantic Kernel). Vérifiez le statut actuel avant de commencer.
  • CrewAI — un framework basé sur les rôles : définissez les agents par rôle et objectif, organisez-les en Crews (collaboration autonome) ou en Flows (contrôle piloté par événements). Voie rapide vers une équipe multi-agents.
  • OpenAI Agents SDK — un framework délibérément léger, à peu d'abstractions, pour les workflows multi-agents avec transferts. Malgré son nom, il est agnostique au fournisseur (sa doc note la prise en charge de plus de 100 LLM), et c'est le successeur prêt pour la production de l'expérimental Swarm.
  • La boucle d'agent simple — pas de framework du tout : votre propre boucle while autour de l'appel d'outils natif du modèle. Le bon choix par défaut pour les agents simples, et ce que tous les frameworks ci-dessus enveloppent en fin de compte.

Comment choisir un framework​

Guided walkthrough1 of 6
  1. Une phrase sur ce que fait l'agent, plus les non-négociables : latence, plafond de coût, confidentialité des données, si les exécutions doivent survivre à un crash, et si un humain doit approuver des étapes.

La chose que tout framework enveloppe​

Avant de saisir la moindre bibliothèque, il aide de voir la boucle sur laquelle elles sont toutes bâties. C'est toute l'idée — le modèle décide, vous exécutez, on répète jusqu'à terminé :

# Provider-neutral agent loop — the core every framework wraps.
# `model_call` and `run_tool` are yours; swap in Claude, GPT, Gemini, or a local model.

def agent_loop(task, tools, max_steps=10):
    messages = [{"role": "user", "content": task}]

    for _ in range(max_steps):
        # 1. Ask the model what to do next (it sees the tool schemas).
        response = model_call(messages, tools=tools)

        # 2. No tool requested → the model is done. Return its answer.
        if not response.tool_calls:
            return response.text

        # 3. Run each requested tool and feed results back in.
        messages.append(response.as_message())
        for call in response.tool_calls:
            result = run_tool(call.name, call.arguments)
            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": result,
            })

    return "Stopped: hit max_steps without finishing."

Si vous savez lire ceci, vous comprenez ce que fait chaque framework de cette page sous le capot. Les graphes ajoutent l'état et le branchement explicites ; les équipes ajoutent les rôles et la délégation ; les SDK minimaux ajoutent des transferts soignés — mais le battement de cœur est toujours cette boucle.

Prompt système d'agent minimal (à associer à la boucle ci-dessus)

You are a task-completing agent with access to tools.

Loop:
1. Think briefly about the next single step toward the goal.
2. If a tool would help, call exactly ONE tool with valid arguments.
3. When you have enough to answer, stop calling tools and give the final answer.

Rules:
- Prefer the fewest tool calls that get the job done.
- If a tool fails, read the error and adjust — do not repeat the same call.
- Never invent tool results; use only what tools actually returned.
- If the goal is impossible with the available tools, say so and stop.

Goal: {one-sentence task}

Une note sur le battage médiatique​

Aucun framework ici n'est « le meilleur » — cette question est mal posée. Les frameworks à graphe l'emportent sur le contrôle et la durabilité ; les frameworks à équipe l'emportent sur l'expression rapide d'une équipe ; les minimaux l'emportent sur la lisibilité et le faible verrouillage ; et une boucle simple l'emporte plus souvent que les README des frameworks ne l'admettent. Le bon choix est le plus petit outil qui rend claire votre étape la plus dure. Comme pour le choix d'un modèle, laissez votre propre tâche — pas un nombre d'étoiles — décider. La même discipline que vous appliqueriez avec les évaluations s'applique ici : prototypez, mesurez sur des cas réels, gardez une sortie de secours.

Testez-vous

0/3
  1. Votre agent fait un appel au modèle, exécute un seul outil de recherche, et renvoie une réponse. Quel est le bon point de départ ?
  2. Vous avez besoin d'un agent qui s'exécute longtemps, doit survivre à un crash et reprendre, et laisse un humain approuver certaines étapes. Quel archétype convient le mieux ?
  3. Un coéquipier dit « OpenAI Agents SDK veut dire qu'on est enfermés avec GPT ». Est-ce exact ?
Frameworks d'agents — idées clés
Appuyez sur Entrée ou Espace pour retourner la carte. Utilisez les flèches gauche et droite pour naviguer entre les cartes.Terme affiché.
1 / 6
Key takeaways
  • Un framework d'agent empaquette l'orchestration, les outils, la mémoire et la coordination multi-agents — n'en adoptez un que lorsque vous devriez sinon construire les quatre vous-même.
  • Trois archétypes couvrent le domaine : graphes avec état (contrôle/durabilité), équipes basées sur les rôles (équipes rapides), et boucles minimales (lisibilité, faible verrouillage).
  • Presque tous sont agnostiques au modèle — ils tournent sur Claude, GPT, Gemini et des modèles locaux ; vérifiez par projet plutôt que de supposer.
  • Aucun framework n'est universellement « le meilleur » ; choisissez le plus petit outil qui rend claire VOTRE étape la plus dure, et gardez une sortie de secours.
  • La simple boucle d'appel d'outils est le choix par défaut honnête — et c'est exactement ce que tout framework enveloppe.
  • Le statut de maintenance change (p. ex. AutoGen → un successeur) ; confirmez qu'un projet est activement maintenu sur son propre dépôt avant de vous engager.

Sources et lectures complémentaires​

Suite​