Hoje vou apresentar os conceitos sobre os Sistemas Multi-Agentes (MAS), entender onde o Microsoft Agent Framework se encaixa no ecossistema de IA da Microsoft e implementar uma orquestração manual usando o Microsoft.Extensions.AI.

Os modelos de Inteligência Artificial evoluíram rapidamente nos últimos anos. Entretanto, muitos problemas de negócio são complexos demais para serem resolvidos por um único agente de IA.
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.