Pendant deux ans, Microsoft a développé en parallèle deux bibliothèques pour construire des agents. L'une est née de la recherche et privilégiait la conversation libre entre agents, l'autre a été conçue pour les entreprises et mettait l'accent sur les plugins, la sécurité et l'intégration avec le reste de l'offre.
Maintenir deux réponses à la même question est devenu indéfendable. Microsoft Agent Framework fusionne les deux lignées en un seul projet, publié en version stable en avril 2026, avec des concepts et des interfaces identiques en Python et sur la plateforme .NET.
Pour qui possède du code sur AutoGen ou Semantic Kernel, c'est la cible de migration indiquée. Pour un nouveau projet, c'est l'une de plusieurs options raisonnables, et je décris plus bas quand le choisir est justifié.
Deux niveaux : agent et workflow
Le projet sépare deux choses que d'autres bibliothèques fusionnent souvent, et cette séparation est sa meilleure idée.
Un agent est un modèle avec des instructions et un ensemble d'outils. Il reçoit une tâche, décide lui-même quels outils appeler et dans quel ordre, et renvoie un résultat. La liberté est ici un avantage, car sur une tâche imprévisible, un plan rigide gêne.
from agent_framework import ChatAgent
from agent_framework.openai import OpenAIChatClient
def check_stock(sku: str) -> int:
"""Returns the number of units available in the warehouse."""
return warehouse.count(sku)
agent = ChatAgent(
chat_client=OpenAIChatClient(model="gpt-4o"),
instructions="You answer questions about product availability. Always check stock.",
tools=[check_stock],
)
result = await agent.run("Do we still have shoes in size 42?")Un workflow décrit ce qui doit se passer, écrit explicitement par toi. Les étapes, les conditions, les branches et les checkpoints sont visibles, donc l'exécution est reproductible.
Répartir le travail entre ces deux niveaux est une ligne directrice pratique pour tout le projet. Décris un processus métier aux étapes connues comme un workflow. Laisse à un agent une étape isolée qui exige du jugement. L'inverse, confier tout le processus à un agent, produit quelque chose que tu ne peux ni déboguer ni reproduire.
Les patterns d'orchestration
Cinq dispositifs prêts à l'emploi existent pour combiner plusieurs agents, et les connaître par leur nom est utile, car ils couvrent la plupart des besoins réels.
Le dispositif séquentiel passe le résultat d'un agent au suivant. Le plus simple et le plus souvent suffisant.
Le dispositif concurrent exécute plusieurs agents sur la même entrée et rassemble les résultats. Raisonnable quand les tâches sont indépendantes, car il ramène la durée à celle du plus lent.
La conversation de groupe laisse les agents échanger des messages, comme dans l'AutoGen d'origine. Flexible et le plus difficile à prévoir.
Le handoff passe le contrôle à un autre agent avec tout le contexte. C'est le dispositif familier des centres d'assistance, où un dossier voyage vers un spécialiste.
Le dispositif coordinateur planifie le travail, le répartit et assemble les résultats, en revenant au plan quand quelque chose échoue.
En choisissant parmi eux, commence par le plus simple que tu puisses défendre. Le séquentiel et le concurrent couvrent la plupart des usages, tandis que la conversation de groupe paraît la plus intéressante et déçoit le plus souvent en production, car la même entrée produit des exécutions différentes.
Checkpoints et reprise
Cette fonctionnalité décide si une solution a sa place en production sur des processus plus longs, et beaucoup de bibliothèques en manquent encore.
Un workflow sauvegarde son état à des moments désignés. Si le processus casse à mi-chemin, par une panne d'un service externe ou un redémarrage lors d'un déploiement, la reprise part du dernier checkpoint plutôt que du début.
L'importance ne se voit que dans les factures. Un processus de douze étapes qui échoue à la dixième coûte dix appels au modèle à chaque tentative de correction du bug, en l'absence de checkpoints. Avec des checkpoints, il en coûte un.
Le second avantage concerne l'intervention humaine. Un workflow peut se mettre en pause et attendre une validation, l'état restant sauvegardé aussi longtemps que nécessaire. Cela permet de construire des processus où un agent prépare une décision et une personne la confirme, sans garder le processus en mémoire pendant trois jours.
Le harness, ou la couche d'exécution
La version de mi-2026 a ajouté une couche qui regroupe en un seul bloc ce que l'on assemblait auparavant à la main autour de chaque agent sérieux.
Cela comprend la boucle de raisonnement, l'accès au shell et au système de fichiers, la gestion du contexte sur de longues sessions et les flux avec validation humaine. C'est exactement l'ensemble que chaque équipe construisant un agent pour du code ou des fichiers écrivait elle-même, généralement moins bien.
Par ailleurs, une approche est apparue où le modèle, au lieu de choisir les outils un par un, écrit un court programme qui les appelle tous, et le programme s'exécute une seule fois dans un environnement isolé. Le gain est double : moins d'appels au modèle et moins de tours, puisque toute la séquence passe en une seule fois.
Cette solution en est à un stade précoce et mérite d'être traitée comme une expérience plutôt que comme une fondation. La direction mérite pourtant l'attention, car elle montre où va tout le domaine : d'un modèle qui choisit des outils à un modèle qui écrit le code qui les appelle.
Middleware, ou le contrôle de l'exécution
Un mécanisme qui s'avère plus important que les patterns d'orchestration eux-mêmes dans un déploiement sérieux, tout en occupant peu de place dans la documentation.
Chaque étape d'exécution peut porter une fonction qui intercepte ce qui se passe : avant l'appel au modèle, après celui-ci, avant l'appel d'un outil et une fois celui-ci terminé. Cela paraît banal et résout quatre problèmes à la fois.
Le premier est la validation des actions. Un outil qui modifie des données ou envoie un message peut exiger une confirmation, et le middleware est l'endroit pour la vérifier, sans éparpiller des conditions dans le code des outils.
Le deuxième est l'enregistrement de l'exécution. Chaque appel avec ses arguments, son résultat, sa durée et sa consommation de tokens atterrit dans un journal à un seul endroit, donc le diagnostic ultérieur n'exige aucune relance.
Le troisième est la gestion des erreurs. Un outil qui lève une exception devrait généralement renvoyer le message au modèle plutôt que de faire tomber toute l'exécution, car le modèle peut souvent corriger les arguments et réessayer.
Le quatrième est le plafonnement du coût. Un compteur d'appels et de tokens tenu dans cette couche te permet d'interrompre une exécution au-delà d'un seuil au lieu de découvrir le dépassement sur une facture.
Écris ces quatre choses une seule fois, au début du projet, et attache-les à chaque agent. Les ajouter plus tard, avec douze agents en place, représente le même travail multiplié par douze.
Observabilité et coûts
Un agent échoue autrement que du code ordinaire, car il ne lève aucune exception et renvoie plutôt une réponse moins bonne qu'attendu. Cela change la façon dont il faut le surveiller.
La bibliothèque émet de la télémétrie dans un format très répandu, donc les exécutions se branchent sur l'outillage que l'équipe utilise déjà sans tableau de bord séparé. Une exécution apparaît sous forme d'arbre : appels au modèle, appels d'outils, durées et consommation de tokens.
Trois mesures méritent d'être suivies dès le premier jour. Le nombre de tours par tâche montre si l'agent tourne en rond. Le coût par tâche dit si la solution passe à l'échelle. La part de tâches menées à bien, mesurée sur un ensemble fixe de cas, dit si un changement des instructions a amélioré quelque chose ou n'en a eu que l'air.
Cette troisième mesure exige un ensemble de cas avec des résultats attendus et c'est la seule qui permette de comparer deux versions d'un agent. Sans elle, le jugement se réduit à une impression tirée de quelques essais manuels, et les impressions trompent régulièrement, en particulier autour des changements de prompt système.
À quoi il se connecte
La bibliothèque ne t'attache pas à un seul fournisseur de modèles, et c'est un changement significatif par rapport aux anciens outils de Microsoft.
Des connecteurs prêts couvrent les services de Microsoft, les modèles OpenAI, Claude, les offres de Google et d'Amazon, ainsi que des modèles exécutés en local. Changer de fournisseur revient à remplacer le client dans le constructeur de l'agent, sans rien changer ailleurs.
Deux protocoles devenus des standards cette année sont aussi pris en charge. Le premier permet de rattacher des outils et des sources de données exposés par des serveurs externes, donc une intégration existante avec un système d'entreprise n'exige aucun code sur mesure. Le second décrit la communication entre agents de fournisseurs différents, ce qui compte quand ton agent doit parler à celui de quelqu'un d'autre.
Vérifie la prise en charge des deux sur ton propre cas avant de les inscrire dans un document d'architecture. Les standards sont jeunes et la compatibilité est parfois partielle.
Microsoft Agent Framework face aux alternatives
| Option | Point fort | Point faible | À choisir quand |
|---|---|---|---|
| Microsoft Agent Framework | Une variante .NET, checkpoints, support à long terme | Nombreux concepts, attraction vers Azure | Une entreprise sur des technologies Microsoft |
| LangGraph | Graphe d'états, outillage d'observabilité mature | Python et JavaScript uniquement | Un processus à l'état complexe |
| OpenAI Agents SDK | Très peu de concepts, démarrage rapide | Périmètre d'orchestration plus étroit | Un agent simple avec des outils |
| Google ADK | Intégration avec les services Google | Écosystème plus jeune | Un projet sur l'infrastructure Google |
Le premier critère est banal et décisif : le langage. Si le backend tourne sur .NET, cette bibliothèque est pratiquement la seule option sérieuse, car aucune des autres ne propose de variante pour cette plateforme. LangGraph et l'OpenAI Agents SDK te donnent Python et JavaScript, Google ADK te donne Python, Java et Go, et .NET n'apparaît dans aucune d'elles.
Le deuxième est l'engagement de support. La version stable porte la promesse de conserver l'interface, ce qui, après l'histoire des deux projets précédents, a une vraie valeur pour une équipe qui planifie un déploiement mesuré en années.
Le troisième, comme toujours, est de savoir si un framework est nécessaire. Un agent avec trois outils et une seule étape, c'est une centaine de lignes de code qui appellent directement le modèle, sans aucune bibliothèque.
Migrer depuis les projets précédents
Le fournisseur publie des guides pour les deux lignées, et il est rentable de commencer par là, car ils font correspondre les concepts.
En venant de la première bibliothèque, le plus grand changement est d'abandonner la conversation comme mécanisme de contrôle. Ce qui était un échange de messages entre agents devient un workflow aux étapes explicites. Il s'avère généralement que l'ordre était de toute façon fixe, donc le changement supprime l'irreproductibilité sans rien retirer.
En venant de la seconde, le plus grand changement est le modèle d'agent. Les plugins et les fonctions se transposent directement, tandis que la couche de planification fonctionne différemment et demande d'être repensée.
Dans les deux cas, l'ordre du travail est le même. Commence par extraire les outils en code ordinaire indépendant de la bibliothèque, car c'est la partie la plus précieuse et elle se déplace sans changement. Construis ensuite un ensemble de cas de test avec des résultats attendus, car sans lui tu ne peux pas distinguer une migration réussie d'une migration ratée. Ce n'est qu'après que tu réécris l'orchestration.
Ne migre pas tout d'un coup. Un processus déplacé en entier et exécuté en parallèle de l'ancien en dit plus qu'un plan couvrant dix processus, car seule la comparaison des deux versions sur le même trafic montre la différence de qualité et de coût.
Erreurs fréquentes
La première est de confier à un agent un processus entier aux étapes connues. Décris les étapes connues comme un workflow, car tu y gagnes en reproductibilité et en débogage moins cher.
La deuxième est de sauter les checkpoints sur les processus longs. Chaque redémarrage coûte alors une exécution complète depuis le début, appels au modèle compris.
La troisième est de choisir la conversation de groupe parce qu'elle paraît la plus intéressante. La production valorise la reproductibilité, et ce dispositif ne la fournit pas.
La quatrième est de n'avoir aucun plafond de coût par exécution. Un agent pris dans une boucle peut faire des dizaines d'appels avant que quelqu'un remarque un problème.
La cinquième est d'inscrire les protocoles dans un document d'architecture sans vérifier la compatibilité sur ton propre cas. Les standards sont jeunes et la prise en charge est parfois partielle.
La sixième est de migrer sans ensemble de tests. Les agents ne renvoient pas de valeurs comparables avec un signe égal, donc sans cas portant des résultats attendus, juger un changement relève de la devinette.
FAQ
Est-ce le successeur d'AutoGen et de Semantic Kernel ?
Oui, le fournisseur l'appelle le successeur direct des deux, créé par les mêmes équipes. AutoGen est en mode maintenance, Semantic Kernel reste pris en charge, et le nouveau développement va dans un seul dépôt.
Cela fonctionne-t-il en dehors de l'écosystème Microsoft ?
Oui. Des connecteurs prêts couvrent des modèles de divers fournisseurs, y compris exécutés en local, et la bibliothèque n'exige pas les services cloud de Microsoft. L'intégration avec eux va toutefois plus loin qu'avec le reste, ce qui, dans un déploiement sur ce cloud, est parfois l'argument décisif.
Python ou .NET ?
Les deux variantes partagent les mêmes concepts et un périmètre comparable, donc choisis selon le langage de ton backend. La variante .NET est ici l'élément différenciant face à la concurrence, car la plupart des bibliothèques d'agents n'en proposent pas.
Ai-je besoin d'un framework pour un agent simple ?
Généralement non. Un agent avec quelques outils et une seule étape, c'est peu de code qui appelle directement le modèle. Un framework se justifie avec la gestion de l'état, les checkpoints, les nouvelles tentatives et l'observabilité.
Comment savoir s'il convient à mon projet ?
Construis-y un vrai processus de ton propre système, pas un exemple de la documentation, et mesure trois choses : le coût par exécution, le temps de réponse et la rapidité avec laquelle tu établis la cause après une exécution ratée. La troisième mesure est celle qui décide le plus souvent et elle est la moins vérifiée.
La documentation se trouve sur le site du projet, et les nouvelles de version sur le blog de l'équipe.