Semantic Kernel est né comme la réponse de Microsoft à la question de savoir comment brancher des modèles de langage dans des applications de l'écosystème .NET sans renoncer à ce qu'exigent les logiciels d'entreprise : injection de dépendances, télémétrie, typage et middleware.
En avril 2026, Microsoft a publié la version 1.0 d'Agent Framework et l'a désigné comme successeur, en fusionnant le travail de deux de ses propres projets. Semantic Kernel publie toujours des versions et a une grande communauté, mais la direction est claire et un nouveau projet doit en tenir compte.
Ce texte couvre les deux : ce qu'offre l'ancienne bibliothèque, ce que change le successeur, et quand la migration a du sens.
Le modèle conceptuel
La base est un kernel, c'est-à-dire un conteneur qui réunit des modèles, des plugins et des services de support. Il ressemble au conteneur d'injection de dépendances familier dans cet écosystème, et ce n'est pas un hasard.
var builder = Kernel.CreateBuilder();
builder.AddAzureOpenAIChatCompletion(deployment, endpoint, apiKey);
builder.Plugins.AddFromType<OrdersPlugin>();
var kernel = builder.Build();Un plugin est une classe avec des méthodes marquées par des attributs qu'un modèle peut appeler. Les descriptions des méthodes et des paramètres viennent des attributs, donc le schéma dérive du code plutôt que d'un fichier séparé.
public class OrdersPlugin
{
[KernelFunction, Description("Returns the status of the order with the given number.")]
public async Task<string> GetStatus(
[Description("order number")] string number)
=> await _db.StatusAsync(number);
}La description dans l'attribut n'est pas un commentaire pour un développeur mais un texte que le modèle lit. Une phrase qui dit quand appeler la méthode améliore la précision plus que n'importe quel changement de l'instruction système, et c'est l'optimisation la moins chère que cette bibliothèque offre.
Ce que change le successeur
Le nouveau framework simplifie ce pour quoi l'ancienne bibliothèque exigeait du cérémonial, tout en gardant ce dont les logiciels d'entreprise ont besoin.
Le plus grand changement concerne les outils. Au lieu d'une classe de plugin avec des attributs, tu peux passer une méthode ordinaire, et le schéma dérive de sa signature. Sur trois outils, c'est la différence entre une ligne et un fichier séparé.
Le deuxième changement simplifie le modèle conceptuel. Un kernel comme conteneur séparé cesse d'être obligatoire, car un agent est créé directement et les dépendances sont injectées par le mécanisme standard de l'écosystème.
Le troisième fusionne le travail de deux projets. Auparavant, Microsoft développait une bibliothèque pour brancher des modèles à côté d'un projet séparé pour les conversations multi-agents, ce qui obligeait à choisir ou à combiner. Maintenant, c'est une seule chose.
Le quatrième est le support à long terme. Une version marquée prête pour la production avec un engagement de stabilité de l'interface est un argument en soi dans cet écosystème, car les applications d'entreprise vivent des années.
Migration
Le passage n'est pas une réécriture de l'application et n'est pas non plus un simple échange de dépendance.
Le code qui appelle le modèle se porte facilement, car les concepts sont proches : un agent avec des instructions, un fil de conversation, des outils. Le code des plugins doit changer, mais dans le sens de la simplification, puisqu'une classe à attributs devient des méthodes ordinaires.
Ce qui demande le plus d'attention est tout ce qui a été construit autour du kernel : services personnalisés enregistrés dans le conteneur, filtres qui interceptent les appels et configuration passée par le conteneur. Cela demande à être repensé dans le nouveau dispositif.
L'ordre pratique est le suivant. Porte d'abord un agent vers le nouveau framework et exécute-le à côté de l'existant, car les deux bibliothèques peuvent vivre dans la même application. Porte ensuite le reste en vérifiant le comportement sur le même ensemble de cas. Enfin, retire l'ancienne dépendance.
Microsoft publie un guide de migration qui fait correspondre les concepts, donc commence par là plutôt que de deviner.
Quand ne pas bouger
Tous les projets n'ont pas à migrer, et cela mérite d'être dit clairement.
Une application qui tourne de façon stable avec un périmètre de changements fermé n'y gagne que du travail. L'ancienne bibliothèque publie toujours des versions et ne disparaîtra pas du jour au lendemain, donc repousser la décision d'un an est défendable.
La migration a du sens quand tu prévois une extension, quand le cérémonial autour des plugins frotte, ou quand tu as besoin de quelque chose qui n'existe que dans le nouveau framework. Elle a aussi du sens sur un projet qui démarre maintenant, car écrire du nouveau code sur une bibliothèque qui a un successeur désigné, c'est prendre une dette en connaissance de cause.
Le troisième facteur est l'équipe. Si personne ne connaît l'une ou l'autre bibliothèque, le successeur est le choix évident. Si l'équipe connaît l'ancienne et a des déploiements qui fonctionnent dessus, pèse le coût d'apprentissage.
Fixe une date pour revoir la décision plutôt que de la repousser indéfiniment. Une entrée de calendrier six mois plus tard, où tu vérifies l'état des deux bibliothèques, ne coûte rien et protège du cas où la migration ne devient urgente que quand une dépendance cesse de fonctionner.
L'appel d'outils en pratique
Quelle que soit la bibliothèque que tu choisis, les mêmes règles s'appliquent, car elles découlent du fonctionnement d'un modèle plutôt que d'une solution particulière.
La description d'un outil détermine la précision plus que tout le reste. Le modèle ne voit que le nom, la description et le schéma des paramètres, donc une phrase qui dit clairement quand appeler l'outil compte plus qu'une description de l'implémentation.
Le nombre d'outils compte. Un modèle qui choisit parmi quatre se trompe moins souvent qu'un qui choisit parmi vingt, donc répartir entre plusieurs agents spécialisés vaut souvent mieux qu'un seul qui détient l'ensemble complet.
Fais respecter les permissions dans le code de l'outil plutôt que dans les instructions. L'identifiant de l'utilisateur doit venir du contexte de l'appel plutôt que d'un paramètre que le modèle peut remplir librement. C'est le même principe qu'avec l'OpenAI Agents SDK et toute autre bibliothèque d'agents.
Les limites sont obligatoires. Un agent sans plafond d'étapes peut appeler le même outil en boucle, et sans timeout il peut rester suspendu sur un appel qui ne revient jamais.
Middleware et télémétrie
C'est là que les bibliothèques de cet écosystème battent les alternatives, car elles répondent à des besoins que les logiciels d'entreprise soulèvent dès le premier jour.
Un middleware te permet d'intercepter un appel au modèle ou à un outil et d'en faire quelque chose : enregistrer, mesurer, rejeter, réessayer. C'est le même patron qu'un pipeline de requêtes serveur, donc une équipe le connaît sans l'apprendre.
public class CostLimitMiddleware : IFunctionInvocationFilter
{
public async Task OnFunctionInvocationAsync(
FunctionInvocationContext context, Func<FunctionInvocationContext, Task> next)
{
if (_counter.DailyExceeded())
throw new InvalidOperationException("Daily limit exceeded");
await next(context);
_counter.Add(context.Result.Metadata?["Usage"]);
}
}Trois usages reviennent le plus. Le premier est la limitation des coûts, pour qu'un bug de boucle ne vide pas le budget. Le deuxième est la validation des actions irréversibles, où la couche met l'appel en pause et demande un consentement. Le troisième est l'enregistrement dans un système d'observabilité.
La télémétrie repose ici sur le standard utilisé dans tout cet écosystème, donc les traces des appels au modèle arrivent là où tu collectes déjà des données sur le reste de l'application. C'est mieux qu'un outil séparé, car diagnostiquer une requête lente n'exige aucun recoupement entre deux systèmes.
Active la télémétrie dès le premier jour. La consommation de tokens, la durée des appels et le nombre de nouvelles tentatives sont trois chiffres dont l'absence ne se remarque qu'à la première facture surprenante.
Déploiement dans le cloud
Déployer sur la plateforme de Microsoft apporte quelques éléments qui simplifient le travail et qu'il vaut mieux connaître avant de tout configurer à ta façon.
Une identité managée supprime complètement les clés de la configuration. L'application s'authentifie avec l'identité que la plateforme lui attribue, donc il n'y a rien à garder dans un fichier et rien à faire tourner.
builder.AddAzureOpenAIChatCompletion(
deploymentName: deployment,
endpoint: endpoint,
credentials: new DefaultAzureCredential());Le deuxième élément est le filtrage de contenu activé par défaut côté service. Il aide parfois et gêne parfois, quand ton domaine contient un vocabulaire jugé sensible. Vérifie comment il se comporte sur tes données avant de déclarer que c'est prêt.
Le troisième est constitué des limites de débit liées à un déploiement de modèle. Les dépasser renvoie une erreur au lieu de mettre en file, donc les nouvelles tentatives avec un délai croissant sont ici obligatoires plutôt que recommandées.
Une décision séparée est de savoir si l'agent doit tourner dans ton processus. Foundry Agent Service l'exécute côté fournisseur et propose deux voies : un agent défini uniquement par configuration, sans code à maintenir, ou ta propre image de conteneur, à laquelle la plateforme ajoute un endpoint, la mise à l'échelle, l'identité et la collecte des traces. La première voie te décharge de la maintenance mais supprime la possibilité de brancher le middleware décrit plus haut, donc tout ce qui dépasse un contrôle d'exécution trivial sort vers la variante conteneur.
Face aux alternatives
| Option | Point fort | Point faible | À choisir quand |
|---|---|---|---|
| Agent Framework | Successeur supporté, outils plus simples, écosystème .NET | Plus jeune, moins de contenus | Nouveau projet .NET |
| Semantic Kernel | Maturité, grande communauté, nombreux exemples | Un successeur désigné existe | Déploiement existant sans projet d'extension |
| LangChain | Le plus grand ensemble d'intégrations | Surtout Python et TypeScript | Projet hors de l'écosystème .NET |
| PydanticAI | Sortie typée, tests sans modèle | Python uniquement | Un résultat qui alimente directement le code |
Pour une équipe qui travaille en .NET, le choix se ramène aux deux premières lignes, car les alternatives imposeraient un service séparé dans un autre langage. C'est parfois justifié avec un backend déjà découpé en services, et sur un monolithe cela ajoute une frontière qui n'existait pas.
Remarque que ces bibliothèques résolvent le même problème de façon similaire, car toutes reposent sur le modèle d'appel d'outils que les fournisseurs de modèles exposent. Les différences concernent le confort et l'écosystème plutôt que les capacités.
La conclusion pratique est que le choix de la bibliothèque décide rarement du succès d'un déploiement. Ce qui le décide, ce sont les descriptions des outils, les limites dans l'instruction et le fait de disposer d'un ensemble de cas pour mesurer les changements. Ces trois éléments se transposent d'une bibliothèque à l'autre presque sans changement, donc le travail qu'on y consacre ne périt pas dans une migration.
La seconde conclusion concerne l'ordre du travail. Commence par une tâche et trois outils, et amène-la à un état où elle se comporte de façon prévisible avant de construire un système à cinq agents. Étendre sur des fondations non éprouvées multiplie des problèmes dont la source ne pourra plus être identifiée.
Recherche dans tes propres données
L'usage le plus courant de ces bibliothèques en entreprise est de répondre à des questions à partir de la documentation interne plutôt que de construire des agents qui agissent.
La bibliothèque expose une abstraction de magasin vectoriel, donc le code ne dépend pas d'une base de données particulière. Cela aide pour prototyper sur une option intégrée et passer plus tard à quelque chose de plus sérieux.
var collection = store.GetCollection<string, Fragment>("documentation");
var results = collection.SearchAsync(questionVector, top: 5);Remarque cependant que l'abstraction simplifie le choix d'une base de données plutôt que la tâche elle-même. La qualité des réponses dépend du découpage des documents, du choix du modèle d'embedding et du filtrage, c'est-à-dire de choses qu'aucune couche intermédiaire ne règle.
Quand tu travailles avec des documents hors de l'anglais, le choix du modèle d'embedding compte plus que celui de la base de données. Un modèle entraîné surtout sur des données anglaises renvoie des fragments moins bien appariés, et le diagnostic est trompeur, car cela ressemble à un défaut de recherche.
À plus grande échelle, utilise une base spécialisée, Qdrant par exemple, et mesure la précision avec un outil dédié plutôt que de la juger à l'impression sur quelques questions.
Erreurs fréquentes
La première est d'écrire des descriptions d'outils pour un développeur. Le modèle lit le même texte et a besoin d'une phrase sur le moment où appeler la méthode, pas d'une description de l'implémentation.
La deuxième est de passer un identifiant d'utilisateur dans les paramètres d'un outil. Le modèle peut fournir celui de quelqu'un d'autre, donc l'identité doit venir du contexte de l'appel.
La troisième est l'absence de plafond d'étapes. Un agent en boucle brûle autant de tokens que tu le permets, et sur un modèle haut de gamme, la découverte est coûteuse.
La quatrième est de démarrer un nouveau projet sur une bibliothèque qui a un successeur désigné. Cela fonctionne et cela signifie une migration prévue plus tard plutôt qu'une décision prise maintenant.
La cinquième est de n'avoir aucun ensemble de cas de test avant de migrer. Sans lui, tu ne peux pas savoir si le comportement après le passage correspond, et les différences sont parfois subtiles.
La sixième est de garder les clés dans la configuration de l'application. Dans cet écosystème, le bon endroit est un magasin de secrets, et pour les déploiements cloud une identité managée, qui supprime complètement les clés.
FAQ
Semantic Kernel est-il obsolète ?
Il n'est pas retiré, mais Microsoft a désigné un successeur et c'est là que va l'effort principal de développement. L'ancienne bibliothèque publie toujours des versions et a une grande communauté, donc les déploiements existants continuent de fonctionner, alors qu'un nouveau projet gagne à démarrer sur le successeur.
En quoi Agent Framework diffère-t-il de Semantic Kernel ?
Il simplifie la définition des outils, car une méthode ordinaire suffit à la place d'une classe de plugin à attributs. Il fusionne aussi le travail de deux projets Microsoft auparavant développés séparément et est sorti en version de production avec un engagement de stabilité de l'interface.
Combien de temps prend la migration ?
Cela dépend de la quantité de logique construite autour du kernel. Le code d'appel au modèle et les définitions d'outils se portent vite, tandis que les services personnalisés dans le conteneur et les filtres qui interceptent les appels prennent du temps. Les deux bibliothèques peuvent tourner côte à côte, donc cela peut se faire par étapes.
Fonctionne-t-il avec d'autres modèles que ceux de Microsoft ?
Oui, des modèles de divers fournisseurs sont pris en charge, Claude et des modèles locaux via une interface compatible avec un format populaire compris. L'intégration avec les services cloud de Microsoft va le plus loin, ce qui, pour des déploiements dans cet écosystème, est parfois décisif.
Convient-il aux systèmes multi-agents ?
Oui, et c'est l'une des raisons de la fusion des deux projets. Des intégrations existent aussi avec des protocoles d'échange entre agents construits sur des plateformes différentes, ce qui compte dans les grands déploiements où tout ne vient pas d'une seule équipe.
La documentation du successeur se trouve dans le centre d'apprentissage de Microsoft, et le guide de migration dans un article séparé.