Cenários como:
desenvolvimento assistido por IA;
automação de processos de negócio;
análise de documentos;
atendimento inteligente;
processamento de contratos;
sistemas autônomos;
Exigem a colaboração de diversos agentes
especializados.
Esse modelo é conhecido como Sistema Multi-Agente
(Multi-Agent System – MAS)
Porém, simplesmente criar vários
agentes não basta. É necessário coordená-los, compartilhar informações e
controlar o fluxo de execução.
Esse processo é chamado de
Orquestração de Agentes
O Ecossistema de IA da Microsoft
para .NET
A arquitetura atual do ecossistema de IA da Microsoft
pode ser representada pelas seguintes camadas:
O
Microsoft Agent Framework (MAF) é o sucessor direto do Semantic
Kernel Agents e do AutoGen, combinando as abstrações
simples de agentes do AutoGen com os recursos empresariais do
Semantic Kernel, como gerenciamento de estado, middleware, telemetria e
orquestração baseada em workflows.
Benefícios dos Sistemas Multi-Agentes
:
maior escalabilidade;
separação de responsabilidades;
reutilização de agentes;
workflows explícitos;
observabilidade;
execução
distribuída;
autonomia.
Quando usar Agentes e Quando
usar Workflows ?
A própria documentação do MAF recomenda:
Se uma
simples função resolve o problema, não use agentes.
Exemplo:
Equipe de Desenvolvimento de Software
Vamos imaginar uma equipe
composta pelos seguintes agentes:
O Fluxo
pode ser resumido da seguinte forma:
Esse fluxo ilustra o funcionamento de um sistema multiagente, em que diferentes
agentes especializados colaboram de forma coordenada para atingir um objetivo
comum. Cada agente desempenha uma responsabilidade específica — desde o
planejamento e implementação até a validação e revisão da solução — permitindo a
divisão do trabalho, a redução de erros e o aumento da qualidade do resultado
final.
Ao combinar especialização, colaboração e autonomia, essa
abordagem torna o processo de desenvolvimento mais eficiente, previsível e
escalável, evidenciando o potencial dos sistemas multiagentes para automatizar
tarefas complexas e entregar soluções mais robustas ao usuário.
Configurando o Modelo
O primeiro passo é configurar um
cliente de IA usando o Microsoft.Extensions.AI.
var apiKey =
builder.Configuration["OpenAI:ApiKey"]
?? throw new InvalidOperationException(
"A chave OpenAI:ApiKey não foi configurada.");
IChatClient chatClient =
new ChatClient(
model: "gpt-4o",
apiKey: apiKey)
.AsIChatClient();
|
Observe que estamos utilizando um
modelo real (`gpt-4o`) e não um modelo hipotético.
Criando um Agente Simples
O MAF permite criar agentes
que utilizam um modelo de linguagem e mantêm estado, memória e conversações. A
documentação oficial apresenta o conceito de um agente como:
Um agente
que recebe uma solicitação, chama um modelo e retorna uma resposta. A partir
daí, é possível adicionar ferramentas, conversas multi-turno, memória e
workflows.
Conceitualmentes temos:
Adicionando Ferramentas
Os agentes podem utilizar ferramentas
para executar tarefas externas:
consultar APIs;
acessar bancos de dados;
enviar e-mails;
pesquisar documentos;
chamar outros agentes.
Isso
transforma um simples chatbot em um agente capaz de agir sobre o ambiente.
Construindo um Workflow Multi-Agente
O diferencial
do Microsoft Agent Framework está nos workflows.
Em vez de codificar
manualmente, o workflow passa a definir explicitamente o fluxo de execução
entre os agentes.
Os workflows podem ser:
sequenciais;
paralelos;
condicionais;
com intervenção humana;
de longa duração.
Esses recursos são uma das grandes novidades do MAF
O MAF resolve problemas que começam a aparecer quando o sistema cresce e
precisa de :
1. Workflows complexos
2. Fluxos condicionais
3. Estado compartilhado
4. Conversas de longa duração
5. Human-in-the-loop
6. Observabilidade.
Para
fluxos simples e determinísticos, uma orquestração manual é
suficiente. O Microsoft Agent Framework passa a fazer sentido quando a
coordenação dos agentes se torna complexa.
Por isso vou mostrar a seguir
como fazer uma orquestação manual e em outro artigo vamos usar o MAF.
Orquestrando uma Equipe de Agentes para Criar uma API ASP.NET Core
Suponha que desejamos automatizar parte do
desenvolvimento de software utilizando IA.
A solicitação do usuário é: "Crie uma
API Asp.NET Core para um cadastro de clientes"
Em vez de enviar esse prompt para um único
modelo de IA, vamos criar uma equipe de agentes especializados:
Cada
agente possui uma responsabilidade específica.
Criando o Projeto
Podemos
criar o projeto no VS Code ou no Visual Studio 2026 como um projeto Console
usando o .NET 10. No Visual Studio podemos selecionar o template -
Console App.
No VS Code podemos usar os comandos:
dotnet new console -n MultiAgentDemo
cd MultiAgentDemo
A seguir devemos instalar os pacotes:
Microsoft.Agents.AI:
É o pacote principal (Core) que traz o suporte base, os ciclos de execução e o
gerenciamento de sessões do framework.
Microsoft.Agents.AI.OpenAI
ou Microsoft.Agents.AI.AzureAI: Caso vá utilizar os modelos da OpenAI ou do
Azure OpenAI.
Microsoft.Agents.AI.Workflows: Se for
criar orquestrações complexas de múltiplos agentes (gráficos, sequenciais ou
paralelos).
Microsoft.Extensions.Configuration.UserSecrets -
Adiciona suporte ao armazenamento e carregamento de segredos de
desenvolvimento (como chaves de API e strings de conexão) fora do código-fonte e
do controle de versão.
A seguir vamos inicializar o user-secrets no
projeto usando estes comandos na pasta do projeto:
dotnet
user-secrets init
dotnet user-secrets
set
"OpenAI:ApiKey"
"sua-api-key-aqui"
Também vamos criar no projeto o arquivo launchSettings.json com
esta definição:
{
"profiles": {
"MultiAgentDemo": {
"commandName": "Project",
"environmentVariables": {
"DOTNET_ENVIRONMENT": "Development"
}
}
}
}
|
Agora vamos criar 4 classes no projeto, em cada uma vamos definir o código
relacionado com a tarefa do respectivo agente.
1-
AgenteDesenvolvedor
using Microsoft.Extensions.AI;
namespace MultiAgentDemo;
public class AgenteDesenvolvedor
{
private readonly IChatClient _chatClient;
public AgenteDesenvolvedor(IChatClient chatClient)
{
_chatClient = chatClient;
}
public async Task ExecutarAsync(
string plano)
{
var resposta =
await _chatClient.GetResponseAsync(
$"""
Você é um desenvolvedor .NET.
Gere o código para o seguinte plano:
{plano}
""");
return resposta.Text;
}
}
|
2- AgentePlanejador
public class AgentePlanejador
{
private readonly IChatClient _chatClient;
public AgentePlanejador(IChatClient chatClient)
{
_chatClient = chatClient;
}
public async Task ExecutarAsync(
string solicitacao)
{
var resposta =
await _chatClient.GetResponseAsync(
$"""
Você é um arquiteto de software.
Crie um plano de implementação para:
{solicitacao}
""");
return resposta.Text;
}
}
|
3- AgenteRevisor
using Microsoft.Extensions.AI;
namespace MultiAgentDemo;
public class AgenteRevisor
{
private readonly IChatClient _chatClient;
public AgenteRevisor(IChatClient chatClient)
{
_chatClient = chatClient;
}
public async Task ExecutarAsync(
string codigo)
{
var resposta =
await _chatClient.GetResponseAsync(
$"""
Você é um revisor de código.
Analise o código abaixo e sugira melhorias:
{codigo}
""");
return resposta.Text;
}
}
|
4- AgenteOrquestrador
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();
}
}
|
A seguir o código da 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(
"A chave OpenAI:ApiKey não foi configurada.");
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(
"""
Criar uma API ASP.NET Core
para cadastro de clientes
utilizando EF Core e o SQLite
Use EnsureCreated() para criar o banco
""");
|
Esta aplicação implementa uma orquestração manual de agentes, onde cada
agente possui uma responsabilidade específica dentro de um fluxo de trabalho.
O usuário fornece uma solicitação, que é inicialmente processada pelo
Agente Planejador, responsável por analisar o problema e criar um plano de
implementação.
Em seguida, o resultado desse planejamento é enviado para
o Agente Desenvolvedor, que utiliza o plano recebido para gerar uma solução em
código. Por fim, o Agente Revisor analisa o código produzido e sugere melhorias
ou correções.
O papel do Agente Orquestrador é coordenar a execução
desses agentes. Ele funciona como um gerente, controlando a ordem de execução e
encaminhando a saída de um agente para o próximo.
Esse padrão é conhecido
como orquestração sequencial, pois cada etapa depende do resultado produzido
pela etapa anterior. Embora este exemplo utilize apenas chamadas de métodos em
C#, ele demonstra um dos conceitos fundamentais dos sistemas multi-agentes: a
divisão de um problema complexo em tarefas menores executadas por especialistas.
É importante destacar que esta aplicação não utiliza diretamente os recursos
do Microsoft Agent Framework, como workflows declarativos, estado compartilhado,
sessões ou execução distribuída.
O objetivo do exemplo é apresentar os
conceitos básicos de agentes e orquestração de forma simples e didática. Em
aplicações mais complexas, o Microsoft Agent Framework pode substituir essa
orquestração manual, oferecendo recursos avançados para coordenar dezenas de
agentes, compartilhar contexto, implementar fluxos condicionais e monitorar toda
a execução do sistema.
Nota: Como estamos usando o
mesmo IChatClient, cada agente não possui memória própria.
Na prática, ele
funciona mais como: Prompt 1 -> LLM, Prompt 2 -> LLM e
Prompt 3 -> LLM
e não como agentes persistentes. Isso é suficiente
para demonstrar orquestração de agentes, mas ainda não explora os recursos do
Microsoft.Agents.AI.
Executando o projeto poderemos ver o resultado
da execução de cada agente:
1-Planejador
2-
Desenvolvedor
3-Revisor
Conclusão
O mais importante ao trabalhar com sistemas multi-agentes não é o framework
escolhido, mas sim identificar quando o problema realmente se beneficia da
colaboração entre especialistas. Em muitos casos, uma simples chamada ao modelo
de IA é suficiente. Em outros, dividir a responsabilidade entre agentes torna a
solução mais organizada, previsível e fácil de evoluir.
A pequena aplicação construída neste artigo
mostra que um sistema multi-agente é, antes de tudo, uma questão de
arquitetura e separação de
responsabilidades, e não de ferramentas ou bibliotecas. Frameworks como
o Microsoft Agent Framework surgem apenas quando a complexidade aumenta e a
orquestração manual começa a se tornar difícil de manter.
Em outras palavras:
comece simples, entenda o problema e só
então introduza um framework de agentes quando ele realmente resolver um
problema que você já possui.
Multi-Agentes
- Orquestração manual
