.NET - Apresentando o Microsoft Agent Framework

Neste artigo vou apresentar Microsoft Agent Framework que podemos usar para criar Agentes de IA.

Se você esta querendo criar Agentes de IA na plataforma .NET e não sabe por onde começar a princípio você poderá ficar confuso pois atualmente existem as seguintes opções na plataforma .NET para realizar a orquestração de agentes : Semantic Kernel,  AutoGen,  Microsoft.Extensions.AI e Microsoft Agent Framework.

O Microsoft Agent Framework é o novato do momento. Ele entrou em public preview há alguns meses e é basicamente o que acontece quando as equipes por trás do AutoGen e do Semantic Kernel decidem parar de manter dois frameworks separados e constroem um único — sem te obrigar a escolher.

O que é o Microsoft Agent Framework?

O Microsoft Agent Framework(MAF) é o que a Microsoft está construindo para substituir tanto o AutoGen quanto o Semantic Kernel. As mesmas equipes. Um único framework.

Com o MAF você obtém agentes que:
  - Mantêm memória de conversas
  - Conseguem chamar métodos C# como tools
  - Coordenam com outros agentes

A camada de abstração funciona com OpenAI, Azure OpenAI, Ollama, ou qualquer outro provider compatível.

O gerenciamento de estado baseado em threads já vem embutido, e, também vêm prontos: Telemetria
Filtros e recursos de produção que antes precisavam ser “colados” manualmente

A versão GA (General Availability) é esperada para o início de 2026.

Isso significa que mudanças quebrando compatibilidade podem acontecer como:
  - Remoção do método NotifyThreadOfNewMessagesAsync
  - Mudança na forma de criar threads

Nada catastrófico, mas importante saber se você pretende colocar isso em produção imediatamente.

Por que usar isso em vez do Semantic Kernel?

O Semantic Kernel funciona bem para:
  - Cadeias de prompts
  - Function calling simples

Mas quando você precisa:
  - Manter contexto por várias interações
  - Coordenar múltiplos agentes

… o Semantic Kernel começa a “brigar” com você.

O Agent Framework resolve isso nativamente:
  - Execução baseada em grafos
  - Roteamento condicional
  - Threads persistentes

Tudo aquilo que exigia muita infraestrutura manual no Semantic Kernel simplesmente funciona aqui.

Existe caminho para migração, pois , o Semantic Kernel e AutoGen não vão desaparecer, apenas não receberão novos recursos.

Configurando seu primeiro agente

Para ilustrar o uso deste recurso vamos configurar o nosso primeiro agente de IA.

Vamos precisar do .NET 8 ou superior (eu vou usar o .NET 10)

Podemos inicialmente criar um projeto Console e a seguir instalar os seguintes pacotes:

dotnet add package Azure.AI.OpenAI --version 2.1.0
dotnet add package Azure.Identity --version 1.17.1
dotnet add package Microsoft.Extensions.AI.OpenAI --version 10.1.1-preview.1.25612.2
dotnet add package Microsoft.Agents.AI.OpenAI --version 1.0.0-preview.251219.1

Todos os pacotes ainda estão em preview em janeiro de 2026.

A seguir podemos usar código abaixo que cria um agente mais simples possível:

using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;
using OpenAI;

AIAgent agent = new OpenAIClient("sua-api-key")
  .GetChatClient("gpt-4o-mini")
  .AsIChatClient()
  .CreateAIAgent(
      instructions: "Você ajuda desenvolvedores a encontrar informações técnicas precisas."
  );

var response = await agent.RunAsync("O que é C#?");
Console.WriteLine(response); 

Este código já cria um agente funcional:
  - Com personalidade (instructions)
  - Capaz de conversar
  - Integrado ao OpenAI
  - Trocar para Azure OpenAI exige apenas mudar o client.

Adicionando memória com threads

Agentes precisam de memória.
Sem isso, cada conversa começa do zero.

O Agent Framework resolve isso com threads.

AgentThread thread = agent.GetNewThread();

var r1 = await agent.RunAsync(
    "Qual a diferença entre IAsyncEnumerable e Task<List>?",
    thread
);

var r2 = await agent.RunAsync(
    "Qual devo usar para streaming de grandes volumes?",
    thread
); 

A thread mantém o contexto automaticamente.

Dando ferramentas ao agente

Aqui o framework realmente brilha.

Você escreve métodos C# normais, adiciona atributos, e o agente decide quando chamá-los.

[Description("Obtém o clima atual")]
async Task<string> GetWeather(string city)
{
    await Task.Delay(500);
    return $"Ensolarado, 22°C em {city}";
} 

O agente identifica quando precisa da ferramenta, chama o método e usa o retorno na resposta. Sem lógica de orquestração manual.

Fluxos com múltiplos agentes

Você pode criar agentes especializados:
  - Um agente para pesquisa
  - Outro para escrita
  - Outro para revisão

E coordenar tudo via código.

Esse padrão funciona muito bem para:
  - Revisão de código
  - Análise técnica
  - Geração de documentação
  - Pipelines de decisão

 E onde entra o Microsoft.Extensions.AI ?

O Microsoft.Extensions.AI fornece a Camada de abstração (IChatClient)

E o Agent Framework orquestra a Memória, threads, ferramentas, coordenação

Você pode usar os dois juntos.

Desta forma o Microsoft Agent Framework finalmente dá aos desenvolvedores .NET uma forma nativa e correta de criar agentes de IA.

É o caminho que a Microsoft escolheu e creio que vale a pena procurar saber como usá-lo.

E estamos conversados...  

"Todavia para nós há um só Deus, o Pai, de quem é tudo e em quem estamos; e um só Senhor, Jesus Cristo, pelo qual são todas as coisas, e nós por ele."
1 Coríntios 8:6