.NET – Construindo Sistemas Multiagentes com o MAF

Este artigo apresenta o Microsoft Agent Framework (MAF) para a construção de sistemas multiagentes coordenados e escaláveis na plataforma .NET.

A Inteligência Artificial generativa evoluiu rapidamente. No início, bastava enviar um único prompt para um modelo de linguagem e esperar pela resposta. Essa abordagem ainda funciona muito bem para tarefas simples, como resumir textos, traduzir conteúdos ou responder perguntas diretas.
Entretanto, aplicações corporativas raramente são tão simples.

Imagine um sistema onde o usuário solicita:

“Analise este contrato, identifique riscos jurídicos, verifique a situação financeira do cliente e gere uma recomendação para aprovação.”

Um único agente precisaria:

– Compreender a solicitação
– Dividir o problema em etapas
– Consultar diferentes fontes
– Utilizar ferramentas externas
– Validar as informações obtidas
– Produzir uma resposta consistente

Quanto maior a responsabilidade atribuída a um único agente, maiores são as chances de respostas inconsistentes, alucinações e aumento da latência.

É justamente nesse cenário que surge o Microsoft Agent Framework (MAF).

O que é o Microsoft Agent Framework?

O Microsoft Agent Framework (MAF) é o framework oficial da Microsoft para construção de aplicações baseadas em múltiplos agentes de IA.

Seu objetivo não é criar novos modelos de linguagem, mas oferecer toda a infraestrutura necessária para que vários agentes especializados trabalhem de forma coordenada.

Cada agente possui uma responsabilidade bem definida e colabora com os demais para resolver problemas complexos. Em vez de um único agente tentando fazer tudo, temos uma equipe de agentes especializados.

A evolução do ecossistema .NET para IA

Uma dúvida comum é a relação entre o Microsoft Agent Framework, o Semantic Kernel e o Microsoft.Extensions.AI.

Nos primeiros anos da IA no .NET, o Semantic Kernel era praticamente o ponto de entrada para quem desejava desenvolver aplicações com LLMs. Hoje o cenário evoluiu.

A Microsoft introduziu o Microsoft.Extensions.AI, que se tornou a camada de abstração recomendada para comunicação com modelos de linguagem.

A arquitetura moderna fica semelhante a esta:

Aplicação .NET
        │
Microsoft Agent Framework
        │
Microsoft.Extensions.AI
        │
OpenAI | Azure OpenAI | Ollama | GitHub Models | outros provedores

O Microsoft.Extensions.AI fornece abstrações como:

– IChatClient
– IEmbeddingGenerator
– Tool Calling
– Streaming
– Histórico de conversação

Tudo isso de forma independente do provedor utilizado.

O Semantic Kernel continua existindo, porém seu papel mudou. Hoje ele é uma biblioteca complementar utilizada quando a aplicação necessita de funcionalidades como:

– Plugins
– Memória avançada
– Planejamento automático
– Conectores prontos

Ou seja, ele deixou de ser o centro da arquitetura e passou a ser um componente opcional. Em novos projetos, é perfeitamente possível construir aplicações completas utilizando apenas o Microsoft.Extensions.AI juntamente com o Microsoft Agent Framework.

Principais componentes do Microsoft Agent Framework

O MAF oferece uma série de componentes que simplificam a construção de sistemas multiagentes:

Agent: Representa um agente especializado. Cada agente possui um objetivo, um conjunto de instruções, ferramentas disponíveis e capacidade de conversar com outros agentes.

Workflow: Define como os agentes colaboram. O workflow é representado por um grafo e pode conter execução sequencial, execução paralela, decisões condicionais e ciclos controlados.

Runtime: Responsável por executar o workflow. Controla a ordem de execução, troca de mensagens, tratamento de exceções e sincronização.

Estado compartilhado: O framework mantém automaticamente o estado da execução. O desenvolvedor não precisa transportar manualmente o histórico entre os agentes; cada um recebe exatamente o contexto necessário.

Tool Calling: Permite que os agentes utilizem ferramentas externas (ex.: consultar banco de dados, pesquisar documentos, chamar APIs REST ou acessar sistemas internos).

Middleware: Assim como o ASP.NET Core, o MAF permite inserir middleware para auditoria, logging, telemetria, autenticação e monitoramento.

Como funciona um workflow multiagente

Considere o seguinte fluxo de execução:

             Planner
                │
      ┌─────────┼─────────┐
      │         │         │
Financeiro   Jurídico   Pesquisa
      └─────────┼─────────┘
                │
           Reviewer
                │
           Response

Nesse exemplo:

1. O Planner interpreta a solicitação do usuário.
2. Os agentes Financeiro, Jurídico e Pesquisa trabalham em paralelo.
3. O Reviewer verifica inconsistências.
4. Por fim, o Response Agent produz a resposta final.

Essa divisão reduz a latência e melhora significativamente a qualidade das respostas.

Um exemplo prático

Vamos imaginar um sistema de aprovação de crédito. O usuário solicita:

“Posso conceder crédito ao cliente João?”

O fluxo poderia ser composto pelos seguintes agentes:

– Planner Agent: Analisa a solicitação e identifica quais verificações precisam ser realizadas.
– Credit Agent: Consulta o histórico financeiro, calcula score e verifica inadimplência.
– Compliance Agent: Consulta listas de restrição e verifica políticas internas.
– Risk Agent: Calcula o risco da operação.
– Reviewer Agent: Confere se todos os dados necessários foram coletados. Caso exista alguma inconsistência, solicita nova execução do agente responsável.
– Response Agent: Produz uma resposta amigável para o usuário.

Implementando com Microsoft Agent Framework

Como exemplo, vamos desenvolver um sistema de atendimento onde quatro agentes colaboram para responder uma solicitação do usuá

O projeto apresentado a seguir tem como objetivo demonstrar os principais conceitos do Microsoft Agent Framework de forma simples e didática. Ele não representa uma aplicação completa nem segue todas as práticas recomendadas para um sistema em produção.

Pense nele como um esboço de um sistema multiagente. O foco é compreender como os principais elementos do framework se relacionam entre si:

– configuração do Microsoft.Extensions.AI;
– criação de agentes especializados;
– utilização de ferramentas (Tools);
– montagem de um workflow;
– execução coordenada entre os agentes.

Para manter o exemplo simples, diversas preocupações comuns em aplicações reais foram omitidas, como configuração por arquivos, tratamento de exceções, logging, telemetria, persistência de estado, testes automatizados, autenticação, monitoramento e organização em múltiplos projetos.

Em uma aplicação corporativa, cada agente normalmente possui responsabilidades mais elaboradas, utiliza várias ferramentas, compartilha estado com outros agentes e participa de workflows mais complexos, envolvendo execuções paralelas, decisões condicionais e integração com serviços externos.

Portanto, utilize este exemplo como um ponto de partida para compreender a arquitetura básica de uma aplicação construída com o Microsoft Agent Framework. Depois de entender esses conceitos fundamentais, será muito mais fácil evoluir para soluções mais robustas e próximas de cenários reais.

Vamos criar um projeto do tipo Console usando o .NET 10 com o nome MultiAgentes no Visual Studio 2026.

Estrutura do projeto:(sugestão)

MultiAgentes
│
├── Agents
│      PlannerAgent.cs
│      CreditAgent.cs
│      ComplianceAgent.cs
│      ReviewerAgent.cs
│      ResponseAgent.cs
│
├── Tools
│      CreditTool.cs
│      ComplianceTool.cs
│
├── Models
│      CreditAnalysisRequest.cs
│      CreditAnalysisResult.cs
│
├── Workflows
│      CreditAnalysisWorkflow.cs
│
├── Configuration
│      AiConfiguration.cs
│
├── appsettings.json
│
└── Program.cs

Código da classe Program

using Microsoft.Extensions.DependencyInjection;
var builder = Host.CreateApplicationBuilder(args);
// Configura o ChatClient
builder.Services.AddChatClient(
    new OpenAIChatClient(
        model: "gpt-4.1",
        apiKey));
// Registra as Tools
builder.Services.AddSingleton<CreditTool>();
builder.Services.AddSingleton<ComplianceTool>();
// Registra os Agents
builder.Services.AddSingleton<PlannerAgent>();
builder.Services.AddSingleton<CreditAgent>();
builder.Services.AddSingleton<ComplianceAgent>();
builder.Services.AddSingleton<ReviewerAgent>();
builder.Services.AddSingleton<ResponseAgent>();
// Registra o Workflow
builder.Services.AddSingleton<CreditWorkflow>();
var app = builder.Build();
var workflow = app.Services.GetRequiredService<CreditWorkflow>();
var resultado = await workflow.RunAsync(
    "Avalie o pedido de crédito do cliente João.");
Console.WriteLine(resultado);

PlannerAgent

public class PlannerAgent
{
    public ChatClientAgent Create(IChatClient chatClient)
    {
        return new ChatClientAgent(
            chatClient,
            instructions: """
            Analise a solicitação e determine
            quais verificações serão necessárias.
            """);
    }
}

CreditAgent

public class CreditAgent
{
    private readonly CreditTool _tool;

    public CreditAgent(CreditTool tool)
    {
        _tool = tool;
    }

    public ChatClientAgent Create(IChatClient chatClient)
    {
        return new ChatClientAgent(
            chatClient,
            instructions: """
            Consulte o histórico financeiro
            e o score do cliente.
            """,
            tools: [_tool]);
    }
}

ComplianceAgent

public class ComplianceAgent
{
    private readonly ComplianceTool _tool;
    public ComplianceAgent(ComplianceTool tool)
    {
        _tool = tool;
    }
    public ChatClientAgent Create(IChatClient chatClient)
    {
        return new ChatClientAgent(
            chatClient,
            instructions: """
            Verifique políticas internas
            e regras de compliance.
            """,
            tools: [_tool]);
    }
}

ReviewerAgent

public class ReviewerAgent
{
    public ChatClientAgent Create(IChatClient chatClient)
    {
        return new ChatClientAgent(
            chatClient,
            instructions: """
            Revise todas as respostas
            recebidas dos demais agentes.
            """);
    }
}

ResponseAgent

public class ResponseAgent
{
    public ChatClientAgent Create(IChatClient chatClient)
    {
        return new ChatClientAgent(
            chatClient,
            instructions: """
            Gere uma resposta final
            para o usuário.
            """);
    }
}

CreditTools

public class CreditTool
{
    public string GetCreditScore(string cliente)
    {
        return $"Cliente {cliente} possui score 820.";
    }
} 

ComplianceTool

public class ComplianceTool
{
    public string CheckCompliance(string cliente)
    {
        return "Nenhuma restrição encontrada.";
    }
}

CreditWorkflow

public class CreditWorkflow
{
    private readonly IChatClient _chatClient;
    private readonly PlannerAgent _planner;
    private readonly CreditAgent _credit;
    private readonly ComplianceAgent _compliance;
    private readonly ReviewerAgent _reviewer;
    private readonly ResponseAgent _response;
    public CreditWorkflow(
        IChatClient chatClient,
        PlannerAgent planner,
        CreditAgent credit,
        ComplianceAgent compliance,
        ReviewerAgent reviewer,
        ResponseAgent response)
    {
        _chatClient = chatClient;
        _planner = planner;
        _credit = credit;
        _compliance = compliance;
        _reviewer = reviewer;
        _response = response;
    }
    public async Task<string> RunAsync(string prompt)
    {
        var planner = _planner.Create(_chatClient);
        var credit = _credit.Create(_chatClient);
       var compliance = _compliance.Create(_chatClient);
       var reviewer = _reviewer.Create(_chatClient);
       var response = _response.Create(_chatClient);
       var workflow = new WorkflowBuilder(planner)
       .AddParallelEdges(
                planner,
                credit,
                compliance)
            .Join(credit, compliance)
           .AddEdge(reviewer, response)
           .Build();
        return await workflow.RunAsync(prompt);
    }
}

AIConfiguration

public class AIConfiguration
{
    public const string SectionName = "OpenAI";
    public string Model { get; set; } = "gpt-4.1";
    public string ApiKey =>
        Environment.GetEnvironmentVariable("OPENAI_API_KEY")
        ?? throw new InvalidOperationException(
            "A variável de ambiente OPENAI_API_KEY não foi encontrada.");
}

Neste exemplo, vimos apenas a estrutura básica de uma aplicação multiagente utilizando o Microsoft Agent Framework. Embora simplificado, ele mostra como configurar o ambiente, definir agentes especializados, montar um workflow e executar uma solicitação de forma coordenada. A partir dessa base, podemos evoluir a solução adicionando novos agentes, ferramentas e workflows mais sofisticados para atender cenários reais de negócio.

O Microsoft Agent Framework é responsável por:

– Controlar o fluxo entre os agentes
– Compartilhar o contexto
– Sincronizar a execução
– Consolidar os resultados
– Retornar a resposta final

Observe que o desenvolvedor se concentra apenas na lógica de negócio. Toda a infraestrutura de orquestração é fornecida pelo framework.

Quando utilizar múltiplos agentes?

Utilize múltiplos agentes quando:

– Existirem diferentes responsabilidades
– Houver necessidade de especialistas distintos
– O fluxo possuir várias etapas
– Ferramentas diferentes forem utilizadas
– Houver validações independentes

Para tarefas simples, um único agente continua sendo a melhor escolha.

Boas práticas

Algumas recomendações importantes ao projetar suas soluções:

– Mantenha cada agente responsável por apenas uma função
– Utilize Tool Calling em vez de inserir conhecimento diretamente no prompt
– Prefira workflows pequenos e reutilizáveis
– Implemente critérios claros de término para evitar ciclos infinitos
– Monitore custos e latência
– Utilize telemetria e logging para acompanhar a execução dos agentes

Conclusão:

O Microsoft Agent Framework representa uma evolução importante para aplicações de IA no ecossistema .NET. Ele fornece uma infraestrutura robusta para orquestrar múltiplos agentes, permitindo construir soluções mais modulares, escaláveis e fáceis de manter.

Ao mesmo tempo, a arquitetura moderna da plataforma também evoluiu. O Microsoft.Extensions.AI passou a ser a principal camada de abstração para comunicação com modelos de linguagem, enquanto o Semantic Kernel deixou de ser um componente obrigatório e passou a atuar como uma biblioteca complementar, útil em cenários específicos que exigem recursos adicionais como plugins, memória ou planejamento.

Mais do que adotar múltiplos agentes por tendência, o verdadeiro valor do MAF está em modelar problemas reais como fluxos colaborativos entre especialistas. Quando cada agente possui uma responsabilidade clara e trabalha em conjunto com os demais por meio de workflows bem definidos, é possível desenvolver aplicações de IA mais confiáveis, escaláveis e alinhadas às boas práticas de arquitetura de software.