Aujourd’hui, je vais présenter les concepts des Systèmes Multi-Agents (SMA), comprendre où le Microsoft Agent Framework s’intègre dans l’écosystème d’IA de Microsoft et mettre en œuvre une orchestration manuelle en utilisant le Microsoft.Extensions.AI.
Les modèles d’Intelligence Artificielle ont rapidement évolué ces dernières années. Cependant, de nombreux problèmes métier sont trop complexes pour être résolus par un seul agent d’IA.
Des scénarios tels que :
développement assisté par IA;
automatisation des processus métier;
analyse de documents;
service client intelligent;
traitement de contrats;
systèmes autonomes;
necessitent la collaboration de plusieurs agents spécialisés.
Ce modèle est connu sous le nom de Système Multi-Agents (Multi-Agent System – MAS)
Cependant, créer simplement plusieurs agents ne suffit pas. Il est nécessaire de les coordonner, de partager des informations et de contrôler le flux d’exécution.
Ce processus est appelé Orchestration des Agents
L’Ecosystème IA de Microsoft pour .NET
L’architecture actuelle de l’écosystème IA de Microsoft peut être représentée par les couches suivantes :
Le Microsoft Agent Framework (MAF) est le successeur direct des Semantic Kernel Agents et de l’AutoGen, combinant les abstractions simples d’agents d’AutoGen avec les capacités d’entreprise du Semantic Kernel, telles que la gestion d’état, le middleware, la télémétrie et l’orchestration basée sur des workflows.
Avantages des Systèmes Multi-Agents :
une scalabilité accrue;
division des responsabilités;
réutilisation des agents;
workflows explicites;
observabilité;
exécution distribuée;
autonomie.
Quand utiliser des Agents et Quand utiliser des Workflows ?
La documentation même du MAF le recommande :
Si une fonction simple résout le problème, n’utilisez pas d’agents.
Exemple : Équipe de Développement Logiciel
Imaginons une équipe composée des agents suivants :
Le flux peut être résumé comme suit :
Ce flux illustre le fonctionnement d’un système multi-agent, dans lequel différents agents spécialisés collaborent de manière coordonnée pour atteindre un objectif commun. Chaque agent assume une responsabilité précise — de la planification et de l’implémentation jusqu’à la validation et la révision de la solution — permettant une répartition du travail, une réduction des erreurs et une amélioration de la qualité du résultat final.
En combinant spécialisation, collaboration et autonomie, cette approche rend le processus de développement plus efficace, prévisible et évolutif, mettant en évidence le potentiel des systèmes multi-agents pour automatiser des tâches complexes et livrer des solutions plus robustes à l’utilisateur.
Configuration du Modèle
La première étape consiste à configurer un client IA en utilisant le Microsoft.Extensions.AI.
var apiKey =
builder.Configuration["OpenAI:ApiKey"]
?? throw new InvalidOperationException(
"La clé OpenAI:ApiKey n’a pas été configurée.");
IChatClient chatClient =
new ChatClient(
model: "gpt-4o",
apiKey: apiKey)
.AsIChatClient();Notez que nous utilisons ici un modèle réel (`gpt-4o`) et non un modèle hypothétique.
Création d’un Agent Simple
Le MAF permet de créer des agents qui utilisent un modèle de langage et qui conservent l’état, la mémoire et les conversations. La documentation officielle présente le concept d’un agent comme :
Un agent qui reçoit une demande, appelle un modèle et retourne une réponse. À partir de là, il est possible d’ajouter des outils, des conversations à tours multiples, de la mémoire et des workflows.
Conceptionnellement, nous avons :
Ajout d’Outils
Les agents peuvent utiliser des outils pour exécuter des tâches externes :
consulter des API ;
accéder à des bases de données ;
envoyer des e-mails ;
rechercher des documents ;
faire appel à d’autres agents.
Cela transforme un simple chatbot en un agent capable d’agir sur son environnement.
Construction d’un Workflow Multi-Agent
La particularité du Microsoft Agent Framework réside dans les workflows.
Plutôt que d’écrire du code manuellement, le workflow définit explicitement le flux d’exécution entre les agents.
Les workflows peuvent être :
séquentiels ;
parallèles ;
conditionnels ;
avec intervention humaine ;
à durée longue.
Ces fonctionnalités constituent l’une des grandes nouveautés du MAF
Le MAF résout des problèmes qui apparaissent lorsque le système grossit et qu’il nécessite :
1. Workflows complexes
2. Flux conditionnels
3. État partagé
4. Conversations de longue durée
5. Humain dans la boucle
6. Observabilité.
Pour des flux simples et déterministes, une orchestration manuelle est suffisante. Le Microsoft Agent Framework prend tout son sens lorsque la coordination des agents devient complexe.
Pour cette raison, je vais maintenant montrer comment réaliser une orchestration manuelle et, dans un autre article, nous utiliserons le MAF.
Orchestration d’une Équipe d’Agents pour Créer une API ASP.NET Core
Supposons que nous souhaitons automatiser une partie du développement logiciel en utilisant l’IA.
La demande de l’utilisateur est : « Crée une API ASP.NET Core pour l’inscription des clients »
Plutôt que d’envoyer cette requête à un seul modèle d’IA, créons une équipe d’agents spécialisés :
Chaque agent possède une responsabilité spécifique.
Création du Projet
Nous pouvons créer le projet dans VS Code ou dans Visual Studio 2026 en tant que projet Console utilisant le .NET 10. Dans Visual Studio, on peut sélectionner le modèle – Console App.
Dans VS Code, nous pouvons utiliser les commandes :
dotnet new console -n MultiAgentDemo
cd MultiAgentDemo
Ensuite, nous devons installer les paquets :
Microsoft.Agents.AI : C’est le paquet principal (Core) qui apporte le support de base, les cycles d’exécution et la gestion des sessions du framework.
Microsoft.Agents.AI.OpenAI ou Microsoft.Agents.AI.AzureAI: Si vous prévoyez d’utiliser les modèles OpenAI ou Azure OpenAI.
Microsoft.Agents.AI.Workflows : Si vous souhaitez créer des orchestrations complexes de multiples agents (graphiques, séquentiels ou parallèles).
Microsoft.Extensions.Configuration.UserSecrets – Ajoute le support au stockage et au chargement des secrets de développement (comme les clés d’API et les chaînes de connexion) hors du code source et du contrôle de version.
Ensuite, nous allons initialiser les secrets utilisateur dans le projet en utilisant ces commandes dans le répertoire du projet :
dotnet user-secrets init
dotnet user-secrets set “OpenAI:ApiKey” “votre-cle-api-ici”
Nous allons également créer dans le projet le fichier launchSettings.json avec cette définition :
{
"profiles": {
"MultiAgentDemo": {
"commandName": "Project",
"environmentVariables": {
"DOTNET_ENVIRONMENT": "Development"
}
}
}
}Maintenant, créons 4 classes dans le projet, chacune définissant le code relatif à la tâche de l’agent concerné.
1- Agent Développeur
using Microsoft.Extensions.AI;
namespace MultiAgentDemo;
public class AgenteDesenvolvedor
{
private readonly IChatClient _chatClient;
public AgenteDesenvolvedor(IChatClient chatClient)
{
_chatClient = chatClient;
}
public async Task ExecuterAsync(
string plano)
{
var resposta =
await _chatClient.GetResponseAsync(
$"""
Você é um desenvolvedor .NET.
Gere o código para o seguinte plano:
{plano}
""");
return resposta.Text;
}
}
2- AgentPlanificateur
public class AgentePlanejador
{
private readonly IChatClient _chatClient;
public AgentePlanejador(IChatClient chatClient)
{
_chatClient = chatClient;
}
public async Task ExecuterAsync(
string solicitacao)
{
var resposta =
await _chatClient.GetResponseAsync(
$"""
Você é um arquiteto de software.
Crie un plan de mise en œuvre pour :
{solicitacao}
""");
return resposta.Text;
}
}
3- AgentRéviseur
using Microsoft.Extensions.AI;
namespace MultiAgentDemo;
public class AgenteRevisor
{
private readonly IChatClient _chatClient;
public AgenteRevisor(IChatClient chatClient)
{
_chatClient = chatClient;
}
public async Task ExecuterAsync(
string codigo)
{
var resposta =
await _chatClient.GetResponseAsync(
$"""
Você é un réviseur de code.
Analisez le code ci-dessous et proposez des améliorations :
{codigo}
""");
return resposta.Text;
}
}4- AgentOrchestrateur
namespace MultiAgentDemo;
public class AgenteOrquestrador
{
private readonly AgentePlanejador _planejador;
private readonly AgenteDesenvolvedor _desenvolvedor;
private readonly AgenteRevisor _revisor;
public AgenteOrquestrador(
AgentePlanejador planejador,
AgenteDesenvolvedor desenvolvedor,
AgenteRevisor revisor)
{
_planejador = planejador;
_desenvolvedor = desenvolvedor;
_revisor = revisor;
}
public async Task ExecutarAsync(string solicitacao)
{
Console.WriteLine("======== PLANEJADOR ========");
var plano =
await _planejador.ExecutarAsync(solicitacao);
Console.WriteLine(plano);
Console.WriteLine();
Console.WriteLine("====== DESENVOLVEDOR ======");
var codigo =
await _desenvolvedor.ExecutarAsync(plano);
Console.WriteLine(codigo);
Console.WriteLine();
Console.WriteLine("========= REVISOR =========");
var revisao =
await _revisor.ExecutarAsync(codigo);
Console.WriteLine(revisao);
Console.WriteLine();
}
}À suivre, le code de la classe Program :
using Microsoft.Extensions.AI;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using MultiAgentDemo;
using OpenAI.Chat;
var builder = Host.CreateApplicationBuilder(args);
builder.Configuration.AddUserSecrets();
var apiKey =
builder.Configuration["OpenAI:ApiKey"]
?? throw new InvalidOperationException(
"La clé OpenAI:ApiKey n’a pas été configurée.");
IChatClient chatClient =
new ChatClient(
model: "gpt-4o",
apiKey: apiKey)
.AsIChatClient();
builder.Services.AddSingleton(chatClient);
builder.Services.AddTransient();
builder.Services.AddTransient();
builder.Services.AddTransient();
builder.Services.AddTransient();
var app = builder.Build();
var orquestrador =
app.Services.GetRequiredService();
await orquestrador.ExecutarAsync(
"""
Créer une API ASP.NET Core
pour l’inscription des clients
en utilisant EF Core et SQLite
Utilisez EnsureCreated() pour créer la base
""");
Cette application met en œuvre une orchestration manuelle des agents, où chaque agent a une responsabilité spécifique au sein d’un flux de travail.
L’utilisateur fournit une demande, qui est initialement traitée par l Agent Planificateur, chargé d’analyser le problème et de créer un plan de mise en œuvre.
Ensuite, le résultat de cette planification est transmis à l Agent Développeur, qui utilise le plan reçu pour générer une solution sous forme de code. Enfin, l Agent Réviseur analyse le code produit et suggère des améliorations ou des corrections.
Le rôle de l Agent Orchestrateur est de coordonner l’exécution de ces agents. Il agit comme un gestionnaire, contrôlant l’ordre d’exécution et acheminant la sortie d’un agent vers le suivant.
Ce modèle est connu sous le nom d’orchestration séquentielle, car chaque étape dépend du résultat produit par l’étape précédente. Bien que cet exemple n’utilise que des appels de méthodes en C#, il illustre l’un des concepts fondamentaux des systèmes multi-agents : la division d’un problème complexe en tâches plus petites réalisées par des spécialistes.
Il est important de noter que cette application n’utilise pas directement les ressources du Microsoft Agent Framework, telles que les workflows déclaratifs, l’état partagé, les sessions ou l’exécution distribuée.
L’objectif de l’exemple est de présenter les concepts de base des agents et de l’orchestration de manière simple et pédagogique. Dans des applications plus complexes, le Microsoft Agent Framework peut remplacer cette orchestration manuelle, en offrant des ressources avancées pour coordonner des dizaines d’agents, partager du contexte, mettre en œuvre des flux conditionnels et surveiller l’ensemble de l’exécution du système.
Note : Comme nous utilisons le même IChatClient, chaque agent ne possède pas sa mémoire propre. En pratique, il fonctionne plutôt comme : Prompt 1 -> LLM, Prompt 2 -> LLM et Prompt 3 -> LLM et non comme des agents persistants. Cela suffit pour démontrer l’orchestration des agents, mais n’explore pas encore les ressources du Microsoft.Agents.AI.
En exécutant le projet, on peut voir le résultat de l’exécution de chaque agent :
1- Planificateur
2- Développeur
3- Réviseur
Conclusion
L’essentiel lorsqu’on travaille avec des systèmes multi-agents n’est pas le framework choisi, mais plutôt de savoir quand le problème bénéficie réellement de la collaboration entre spécialistes. Dans de nombreux cas, un simple appel au modèle IA suffit. Dans d’autres, partager la responsabilité entre agents rend la solution plus organisée, plus prévisible et plus facile à faire évoluer.
La petite application construite dans cet article démontre qu’un système multi-agent est, avant tout, une question d’architecture et de répartition des responsabilités, et non d’outils ou de bibliothèques. Des frameworks comme le Microsoft Agent Framework n’apparaissent que lorsque la complexité augmente et que l’orchestration manuelle devient difficile à maintenir.
En d’autres termes : commencez simple, comprenez le problème et n’introduisez un framework d’agents que lorsque cela résout réellement un problème que vous possédez déjà.
