Microsoft Agent - O início da era dos agentes

Hoje veremos o Microsoft Agent Framework um kit de desenvolvimento para criar Agentes de IA e fluxo de trabalho para .NET e Phyton.

Se você tem desenvolvido com .NET ou explorado fluxos de trabalho de IA, este mês a Microsoft lançou discretamente o Agent Framework (Prévia Pública) — e não é apenas mais um lançamento de SDK.

O Microsoft Agent Framework é um kit de desenvolvimento de software livre para criar agentes de IA e fluxos de trabalho de vários agentes para .NET e Python. Ele reúne e estende ideias de projetos Semânticos kernel e AutoGen , combinando seus pontos fortes ao mesmo tempo em que adiciona novos recursos. Criada pelas mesmas equipes, é a base unificada para a criação de agentes de IA daqui para frente.

Ele oferece duas categorias primárias de funcionalidades:

Agentes de IA: agentes individuais que usam LLMs para processar entradas de usuário, ferramentas de chamada e servidores MCP para executar ações e gerar respostas.

Fluxos de trabalho: fluxos de trabalho baseados em grafo que conectam vários agentes e funções para executar tarefas complexas e de várias etapas.

Ele é um novo modelo de runtime para construir sistemas inteligentes, com estado (stateful) e de múltiplos agentes diretamente no .NET. Pense nele como o LangChain encontra o Semantic Kernel — mas construído nativamente para o stack da Microsoft.

De Prompts a Agentes

Até agora, a maioria dos desenvolvedores .NET interagia com a IA por meio de APIs sem estado (stateless):

Prompt de entrada → resposta de saída → repete.

O Agent Framework introduz uma nova camada de abstração — uma que adiciona:

- Estado baseado em thread (seus agentes lembram do contexto)
- Chamada de função (Function calling) (raciocínio estruturado + invocação de ferramentas)
- Filtros e telemetria (orquestração rastreável)
- Suporte a cross-runtime (.NET e Python, local ou Azure)

Isso significa que seus aplicativos .NET podem finalmente pensar, agir e colaborar — não apenas chamar um modelo uma vez e esquecer.

Arquitetura

A arquitetura do Microsoft Agent Framework é o coração da sua capacidade de construir sistemas de IA complexos e com estado, unindo os pontos fortes do Semantic Kernel (foco empresarial, extensibilidade) e do AutoGen (orquestração multi-agente).

1- Aplicação .NET (Sua Aplicação)
- É a sua camada de apresentação e lógica de negócio.
- Ela inicia a conversa ou o fluxo de trabalho criando um AgentThread (para estado) e adicionando etapas (AgentCall).
- Ela consome o resultado final do agente ou do fluxo de trabalho.
- O desenvolvedor interage com APIs simples e intuitivas como thread.AddStep() e thread.ExecuteAsync().

2- Microsoft.AgentFramework (O Orquestrador)
Esta é a camada central, o runtime que adiciona a inteligência e o estado que faltavam nas chamadas de API tradicionais:

- Orquestração de Agente -  Gerencia a sequência, o paralelismo e a colaboração entre múltiplos agentes (padrões AutoGen como sequencial, concorrente, group chat).

- Estado basedo em thread -  Utiliza a classe AgentThread (ou abstrações semelhantes) para persistir o histórico da conversa (context) e o estado atual da tarefa

- Chamada de função -  Permite que o agente, em vez de apenas responder, decida invocar código (funções .NET, APIs externas, etc.)

- Filtros/ Telemetria  -  Inclui integração nativa com o OpenTelemetry para rastreamento distribuído, log de eventos e métricas

- Suporte Cross-Runtime -  A abstração é consistente, permitindo que a orquestração coordene agentes escritos em .NET e Python, localmente ou na nuvem.

3-  APIs de Modelo (Model APIs)
Esta camada trata da comunicação real com os Grandes Modelos de Linguagem (LLMs).

É agnóstica em relação à nuvem, ou seja, suporta:
   - Modelos locais (Local-first) como Ollama e Grok.
   - Serviços de nuvem como Azure AI, Azure OpenAI e OpenAI.

O Framework abstrai a chamada de API, permitindo que você troque o LLM subjacente sem refatorar o código do seu agente.

Exemplo prático

Este exemplo ilustra um princípio fundamental de design que é crucial para o Microsoft Agent Framework: a separação entre o Agente e o Orquestrador. Ele usa o OllamaAgent para demonstrar que o Agent Framework é agnóstico em relação ao LLM.

Vamos criar um projeto console no Visual Studio chamado OllamaAgentes.

No projeto vamos criar a interface IAIAgent:

Define o contrato que todos os agentes devem seguir, expondo o método InvokeAsync para executar prompts de IA de forma padronizada.

E sua implementação na classe  OllamaAgente que Implementa o agente que se conecta localmente ao Ollama via HTTP, envia o prompt e retorna o texto gerado pelo modelo:

using System.Text;
using System.Text.Json;

namespace AgentesOllama;

public class OllamaAgent : IAIAgent
{
    public async Task<string> InvokeAsync(string prompt)
    {
        using var client = new HttpClient();
        var payload = new { model = "llama3.1", prompt };
        var content = new StringContent(JsonSerializer.Serialize(payload), 
                                 Encoding.UTF8, "application/json");
        
        using var response = await client.PostAsync("http://localhost:11434/api/generate"
                                                     ,content);

        response.EnsureSuccessStatusCode();

       var stream = await response.Content.ReadAsStreamAsync();
       using var reader = new StreamReader(stream);

        var sb = new StringBuilder();

        while (!reader.EndOfStream)
        {
            var line = await reader.ReadLineAsync();

            if (string.IsNullOrWhiteSpace(line))
                continue;

            try
            {
                using var doc = JsonDocument.Parse(line);
                if (doc.RootElement.TryGetProperty("response", out var resp))
                {
                    sb.Append(resp.GetString());
                }
            }
            catch
            {
                // Ignora linhas malformadas
            }
        }

        return sb.ToString().Trim();
    }
}

Crie a classe AgentCall que representa uma etapa do fluxo, associando um agente específico a uma entrada (Input) que será processada.

A seguir a classe AgentThread  que gerencia e executa em sequência todas as chamadas (AgentCall) adicionadas, coordenando o fluxo multiagente.

namespace AgentesOllama;

public class AgentThread
{
    private readonly List<AgentCall> _steps = new();

    public void AddStep(AgentCall call) => _steps.Add(call);

    public async Task ExecuteAsync()
    {
        foreach (var step in _steps)
        {
            Console.WriteLine($"\n Executando agente: {step.Agent!.GetType().Name}");
            var result = await step.Agent.InvokeAsync(step.Input!);
            Console.WriteLine($"🔹 Resultado:\n{result}");
        }
    }
}

Agora na classe Program inclua o código que vai invocar o agente:

Este código cria uma instância de AgentThread, adiciona os agentes com seus prompts e inicia a execução, exibindo os resultados no console.

Executando o projeto iremos obter o seguinte resultado:

Temos a resposta do Agente para a pergunta: O que é uma estrela ?

O poder real surge quando você começa a encadear agentes:

thread.AddStep(new AgentCall
{
    Agent = new GrokAgent(),
    Input = "Extract key insights
    from customer feedback JSON"
});

thread.AddStep(new AgentCall
{
    Agent = new OllamaAgent(),
    Input = "Rewrite insights as a
    marketing summary"
});

await thread.ExecuteAsync();

Cada agente lida com seu próprio domínio:

Grok → raciocínio estruturado (JSON, extração de dados)
Ollama → geração criativa (texto, resumos)

Adicione Elsa Workflows ou seu orquestrador favorito, e você terá uma cadeia de agentes completa — construída inteiramente em C#.

Desta forma O Microsoft Agent Framework não é apenas uma biblioteca de conveniência — ela é projetada para cargas de trabalho de produção reais.

- Estado baseado em Thread Não é mais necessário serializar o contexto entre as etapas — as threads persistem o estado nativamente.

- Telemetria integrada Cada chamada de agente pode emitir métricas, rastreamentos (traces) e filtros para observabilidade e governança.

- Híbrido Local + Nuvem Comece localmente com Ollama ou Grok, implante perfeitamente no Azure AI Foundry quando você escalar.

-  Ciente de Custos Filtros permitem que você gerencie o uso de tokens e orçamentos de desempenho — crítico para configurações corporativas.

E por ser nativo do .NET, você pode depurar, criar perfis e fazer benchmarking com as mesmas ferramentas que já utiliza

Cenários do Mundo Real

Isso não é pesquisa — é engenharia pronta para ser lançada.

Copilots corporativos: Construa assistentes departamentais para portais de finanças, RH ou seguros — integrados com Keycloak ou Azure AD.

RPA Multi-agente: Combine parsers de documentos, extratores de dados e geradores de resposta em fluxos de tarefas autônomos.

Agentes Offline: Mantenha tudo on-premise para conformidade, usando modelos Ollama ou Grok localmente.

Seus aplicativos .NET podem agora orquestrar cadeias de raciocínio, integrar-se a APIs internas e executar sistemas de decisão orientados por políticas — tudo sem a sobrecarga do Python.

“O Agent Framework marca o momento em que os desenvolvedores .NET param de chamar a IA — e começam a colaborar com ela.”

Seja você construindo copilots, assistentes de fluxo de trabalho ou ecossistemas multi-agentes completos, é aqui que seu aplicativo .NET de próxima geração começa.