Microsoft Agent Framework 1.0: AI Multi-Agente para .NET y Python

Qué Reemplaza Microsoft Agent Framework

Microsoft Agent Framework es la unificación lista para producción de dos proyectos previamente separados: Semantic Kernel (el SDK de orquestación de grado empresarial) y AutoGen (el framework de conversación multi-agente de Microsoft Research). En vez de mantener dos herramientas superpuestas, Microsoft fusionó las abstracciones simples de agentes de AutoGen con las características empresariales de Semantic Kernel -- gestión de estado basada en sesiones, seguridad de tipos, middleware, telemetría y soporte extensivo de modelos y embeddings -- en un solo framework de grado comercial. El resultado es un SDK unificado disponible para .NET y Python con APIs consistentes.

Antes de Agent Framework, los desarrolladores que construían agentes AI en el stack de Microsoft enfrentaban una elección fragmentada: Semantic Kernel ofrecía arquitectura robusta de plugins e integraciones empresariales pero carecía de orquestación multi-agente nativa, mientras que AutoGen sobresale en patrones conversacionales multi-agente pero necesitaba más robustez para producción. Agent Framework resuelve esto proveyendo una sola instalación, un solo conjunto de abstracciones y una sola hoja de ruta. Semantic Kernel ahora está en modo mantenimiento. AutoGen ha sido archivado.

El framework es open-source bajo la licencia MIT, alojado en github.com/microsoft/agent-framework. La versión 1.0 se lanzó el 3 de abril de 2026, después de un preview público (octubre 2025) y un release candidate (febrero 2026). Incluye compromiso de soporte a largo plazo de Microsoft, con APIs estables garantizadas dentro de versiones mayores. La superficie estabilizada de v1.0 incluye la abstracción central de agente único, conectores de servicio para .NET y Python, hooks de middleware, proveedores de memoria y contexto, workflows basados en grafos para topologías de orquestación complejas, y cinco patrones de orquestación multi-agente (secuencial, concurrente, handoff, group chat y Magentic-One). En Build 2026 (3 de junio de 2026), Microsoft sumó nuevas capacidades sobre la base 1.0: el Agent Harness (compactación automática de contexto, acceso a shell y sistema de archivos, aprobaciones human-in-the-loop), CodeAct (el modelo escribe un único programa Python sandboxed que llama tools vía call_tool, colapsando bucles multi-paso en un solo turno), y Foundry Hosted Agents con facturación scale-to-zero.

Instalación y Primer Agente

Empezar toma menos de 5 minutos en cualquier lenguaje. El paquete .NET está disponible en NuGet y el paquete Python en PyPI. Ambos incluyen todos los sub-paquetes necesarios para funcionalidad core, orquestaciones y conectores de proveedor.

C# (.NET)

// Install the NuGet package
dotnet add package Microsoft.Agents.AI

// Program.cs - Your first agent in C#
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

// Any IChatClient implementation works here
IChatClient chatClient = new AzureOpenAIChatClient(
    endpoint: "https://your-resource.openai.azure.com",
    model: "gpt-5.5",
    credential: new DefaultAzureCredential()
);

var agent = new ChatClientAgent(
    chatClient,
    name: "Assistant",
    instructions: "You are a helpful coding assistant."
);

// Single-turn
string response = await agent.RunAsync("Explain async/await in C#.");
Console.WriteLine(response);

// Multi-turn with conversation history
var thread = new ChatThread();
await agent.RunAsync("What is dependency injection?", thread);
await agent.RunAsync("Show me an example.", thread);
Console.WriteLine(thread.Last().Text);

Python

# Install all sub-packages
pip install agent-framework

# first_agent.py - Your first agent in Python
import asyncio
from agent_framework import Agent
from agent_framework.openai import OpenAIChatClient

client = OpenAIChatClient(model="gpt-5.5")

agent = Agent(
    client=client,
    name="Assistant",
    instructions="You are a helpful coding assistant."
)

# Single-turn
result = asyncio.run(agent.run("Explain async/await in Python."))
print(result)

# Multi-turn with conversation history
async def multi_turn():
    thread = agent.create_thread()
    await agent.run("What is dependency injection?", thread=thread)
    await agent.run("Show me an example.", thread=thread)
    print(thread.last().text)

asyncio.run(multi_turn())

Ambos ejemplos usan la misma API conceptual: crear un cliente, crear un agente con instrucciones y llamar a run. El agente gestiona historial de conversación, maneja reintentos y streamea respuestas. Las herramientas se agregan como funciones decoradas (Python) o vía metadata de función (C#).

Patrones de Orquestación Multi-Agente

Agent Framework provee cinco patrones de orquestación integrados que surgieron de Microsoft Research y uso real en producción. Cada patrón maneja la coordinación de agentes de forma diferente según la estructura de la tarea. Todos soportan streaming, checkpointing, aprobaciones human-in-the-loop y pausa/reanudación.

1. Orquestación Secuencial

Los agentes se ejecutan uno tras otro en orden definido. La salida de cada agente alimenta al siguiente. Usa esto para pipelines donde cada etapa depende de la anterior -- por ejemplo, un agente investigador seguido de un agente analista seguido de un agente redactor.

// C# - Sequential orchestration
var researcher = new ChatClientAgent(client, name: "Researcher",
    instructions: "Research the given topic thoroughly.");
var analyst = new ChatClientAgent(client, name: "Analyst",
    instructions: "Analyze the research and extract key insights.");
var writer = new ChatClientAgent(client, name: "Writer",
    instructions: "Write a clear summary from the analysis.");

var pipeline = new SequentialOrchestration(researcher, analyst, writer);
var result = await pipeline.RunAsync("Impact of AI on healthcare in 2026");
Console.WriteLine(result);

2. Orquestación Concurrente

Los agentes se ejecutan en paralelo y los resultados se agregan. Usa esto cuando las subtareas son independientes -- por ejemplo, consultar múltiples fuentes de datos simultáneamente. Reduce la latencia total comparada con ejecución secuencial.

3. Orquestación Handoff

La responsabilidad se transfiere entre agentes a medida que el contexto evoluciona. Un agente puede hacer handoff a un agente más especializado basado en el estado de la conversación. Común en soporte al cliente: un agente de triaje rutea a agentes de facturación, soporte técnico o gestión de cuentas.

# Python - Handoff orchestration
from agent_framework import Agent, HandoffOrchestration

triage = Agent(client, name="Triage",
    instructions="Route the user to the right specialist.")
billing = Agent(client, name="Billing",
    instructions="Handle billing and payment questions.")
technical = Agent(client, name="Technical",
    instructions="Handle technical support issues.")

orchestration = HandoffOrchestration(
    entry_agent=triage,
    agents=[triage, billing, technical]
)
result = await orchestration.run("I was charged twice for my subscription")

4. Orquestación de Chat Grupal

Los agentes colaboran en una conversación compartida, tomando turnos basados en una estrategia de selección configurable. Usa esto para brainstorming, revisión de código o cualquier escenario donde múltiples perspectivas mejoran el resultado.

5. Orquestación Magentic-One

El patrón más sofisticado, de Microsoft Research. Un agente manager construye y refina un ledger dinámico de tareas, coordinando agentes especializados (navegador web, manejador de archivos, coder, operador de terminal) para completar tareas complejas y multi-paso. Mejor para investigación abierta y workflows autónomos.

Intercambio de Proveedores vía IChatClient

La abstracción IChatClient de Microsoft.Extensions.AI es la base de la flexibilidad de proveedores de Agent Framework. Cada conector de modelo implementa esta interfaz, así que cambiar de proveedor es un cambio de configuración, no de código. Tu lógica de agente, herramientas, orquestaciones y código de evaluación permanecen intactos.

// C# - Same agent, different providers
using Microsoft.Extensions.AI;

// Azure OpenAI
IChatClient azureClient = new AzureOpenAIChatClient(
    endpoint: "https://myresource.openai.azure.com",
    model: "gpt-5.5",
    credential: new DefaultAzureCredential());

// OpenAI direct
IChatClient openaiClient = new OpenAIChatClient(
    model: "gpt-5.5",
    apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY"));

// Anthropic Claude
IChatClient claudeClient = new AnthropicChatClient(
    model: "claude-sonnet-4-6",
    apiKey: Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY"));

// Google Gemini
IChatClient geminiClient = new GeminiChatClient(
    model: "gemini-3.1-pro-preview",
    apiKey: Environment.GetEnvironmentVariable("GOOGLE_API_KEY"));

// Local Ollama (no API key needed)
IChatClient ollamaClient = new OllamaChatClient(
    endpoint: "http://localhost:11434",
    model: "llama3");

// All work identically with any agent
var agent = new ChatClientAgent(claudeClient,
    instructions: "You are a helpful assistant.");

Esto es particularmente poderoso para workflows de desarrollo: usa Ollama localmente para iteración rápida sin costos de API, testea contra OpenAI o Claude para validación de calidad, y despliega con Azure OpenAI en producción con compliance empresarial.

# Python - Provider swapping
from agent_framework import Agent
from agent_framework.openai import OpenAIChatClient
from agent_framework.anthropic import AnthropicChatClient
from agent_framework.ollama import OllamaChatClient

# Development: local Ollama
dev_client = OllamaChatClient(model="llama3")

# Production: Claude via Anthropic
prod_client = AnthropicChatClient(model="claude-sonnet-4-6")

# Same agent definition works with either
agent = Agent(
    client=prod_client,  # swap to dev_client for local dev
    name="CodeReviewer",
    instructions="Review code for bugs, security issues, and style."
)

Interoperabilidad MCP + A2A

Agent Framework tiene soporte de primera clase para el Protocolo de Contexto de Modelo (MCP) y el protocolo Agent-to-Agent (A2A). MCP permite a los agentes descubrir e invocar dinámicamente herramientas externas expuestas por servidores compatibles con MCP. En vez de hardcodear integraciones de herramientas, los agentes se conectan a servidores MCP en runtime.

El soporte A2A habilita colaboración cross-runtime. Un agente construido con Microsoft Agent Framework puede descubrir, negociar y delegar tareas a agentes construidos con otros frameworks (Claude Agent SDK, LangGraph, CrewAI) a través del protocolo A2A estandarizado. Las Agent Cards exponen capacidades, y el modelo de ciclo de vida de tareas maneja handoffs entre límites organizacionales.

// C# - Agent with MCP tools
using Microsoft.Agents.AI;
using Microsoft.Agents.MCP;

var mcpServer = new McpServerConnection("npx", new[] {
    "-y", "@modelcontextprotocol/server-github"
}, new Dictionary<string, string> {
    ["GITHUB_TOKEN"] = Environment.GetEnvironmentVariable("GITHUB_TOKEN")
});

var agent = new ChatClientAgent(chatClient,
    name: "DevAssistant",
    instructions: "Help with code review and PR management.",
    tools: await mcpServer.GetToolsAsync()
);

// The agent can now use all GitHub MCP tools
var result = await agent.RunAsync("Review PR #42 in my-org/my-repo");

# Python - Agent with A2A collaboration
from agent_framework import Agent
from agent_framework.a2a import A2AClient

# Discover external agents via A2A
external = A2AClient("https://partner-api.example.com/.well-known/agent.json")
partner_agent = await external.discover()

# Local agent can delegate to external agent
agent = Agent(
    client=chat_client,
    name="Coordinator",
    instructions="Coordinate with the partner agent for data analysis.",
    collaborators=[partner_agent]
)

result = await agent.run("Analyze Q1 sales data using the partner's tools")

Debugging con DevUI en Navegador

DevUI es un debugger local basado en navegador que visualiza la ejecución de agentes en tiempo real. Renderiza el grafo del agente, resalta el nodo en ejecución y muestra el historial completo de mensajes para cada agente en una vista de paneles divididos. Clickea en cualquier agente para inspeccionar su system prompt, llamadas a herramientas, respuestas del LLM y estado en ese punto.

La característica más poderosa es el replay de ejecución. DevUI graba cada paso, y puedes navegar por la línea de tiempo para entender exactamente cómo cambió el estado y dónde salieron mal las cosas. Invaluable para debuggear orquestaciones multi-agente complejas.

# Launch DevUI for Python
pip install agent-framework-devui
agent-framework-devui --port 8080

# Launch DevUI for .NET
dotnet tool install -g Microsoft.Agents.DevUI
agent-framework-devui --port 8080 --tracing

# Options:
#   --port, -p    Port (default: 8080)
#   --host        Host (default: 127.0.0.1)
#   --headless    API only, no UI
#   --no-open     Don't auto-open browser
#   --tracing     Enable OpenTelemetry tracing
#   --reload      Enable auto-reload on code changes
#   --mode        developer|user (default: developer)

DevUI también expone una API de Responses compatible con OpenAI. Combinado con trazado OpenTelemetry (flag --tracing), obtienes trazas distribuidas completas que se integran con tu stack de observabilidad existente -- Jaeger, Zipkin, Azure Monitor o cualquier colector compatible con OTLP.

Desplegando en Azure AI Foundry

Azure AI Foundry provee hosting gestionado para agentes de Agent Framework. Empaqueta tu agente como un contenedor Docker, sube a Azure Container Registry y despliega en Foundry Agent Service. Foundry gestiona el runtime, auto-escalado e infraestructura. Los agentes hosteados soportan la API de Responses de OpenAI.

Desarrolla y debuggea localmente con DevUI, valida con el framework de evaluación, containeriza y despliega vía Foundry CLI. Foundry provee observabilidad integrada (Azure Monitor), durabilidad (estado persistido) y compliance (residencia de datos, encriptación, RBAC). Para despliegues en Kubernetes, Foundry se integra con AKS.

# Dockerfile for Agent Framework agent
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8080
CMD ["python", "-m", "agent_framework.serve", "--host", "0.0.0.0", "--port", "8080"]

# Deploy to Azure AI Foundry
az login
az acr build --registry myregistry --image my-agent:v1 .
az foundry agent deploy \
    --name my-agent \
    --image myregistry.azurecr.io/my-agent:v1 \
    --project my-ai-project \
    --region northcentralus

Nota: Los agentes hosteados en Foundry Agent Service lanzaron en North Central US y se están desplegando regiones adicionales. En Build 2026 (junio 2026), los Hosted Agents ganaron facturación scale-to-zero (no pagas mientras el agente está ocioso), identidad integrada, escalado automático, estado de sesión gestionado y versionado.

Migración desde Semantic Kernel

El cambio conceptual clave es que las clases de agentes específicas de servicio de Semantic Kernel (ChatCompletionAgent, AzureAIAgent, OpenAIAssistantAgent) se reemplazan por un solo ChatClientAgent que funciona con cualquier implementación de IChatClient.

Las instancias existentes de KernelFunction se pueden convertir a herramientas de Agent Framework usando .as_agent_framework_tool() (Python) o .AsAgentTool() (C#). Requiere semantic-kernel >= 1.38. La conversión preserva esquemas de parámetros, descripciones y tipos de retorno.

// C# - Migration example
// BEFORE: Semantic Kernel
var kernel = Kernel.CreateBuilder()
    .AddAzureOpenAIChatCompletion("gpt-5.5", endpoint, credential)
    .Build();
var agent = new ChatCompletionAgent {
    Kernel = kernel,
    Instructions = "You are a helpful assistant."
};

// AFTER: Agent Framework
IChatClient client = new AzureOpenAIChatClient(
    endpoint: endpoint, model: "gpt-5.5", credential: credential);
var agent = new ChatClientAgent(client,
    instructions: "You are a helpful assistant.");

// KernelFunction conversion (requires SK >= 1.38)
KernelFunction oldTool = KernelFunctionFactory.CreateFromMethod(
    () => DateTime.UtcNow.ToString(), "GetTime");
var newTool = oldTool.AsAgentTool();

Microsoft provee una guía oficial de migración en learn.microsoft.com con muestras de código por característica. La migración se puede hacer incrementalmente -- ambos frameworks coexisten en el mismo proyecto durante la transición.

Comparación vs LangGraph, CrewAI y Paperclip

El panorama de frameworks de agentes en 2026 está saturado. Así se compara Microsoft Agent Framework en las dimensiones que importan para uso en producción.

LangGraph sigue siendo el más probado en batalla para workflows complejos con estado. El enfoque basado en grafos da control explícito sobre transiciones de estado. Carece de soporte .NET de primera parte y requiere LangSmith (cloud pago) para observabilidad completa.

CrewAI sobresale en prototipado rápido con su metáfora de crews basados en roles. 47,800+ estrellas en GitHub y más de 2 mil millones de ejecuciones de agentes en el último año (junio 2026). Los equipos frecuentemente chocan con su techo de flujo de control y migran a LangGraph o Agent Framework para producción. Solo Python.

Paperclip es una capa de orquestación para "empresas sin humanos." 70,000+ estrellas en GitHub desde su lanzamiento en marzo 2026. Atractivo para automatización empresarial autónoma pero carece de las primitivas enfocadas en desarrolladores que los sistemas de agentes en producción necesitan.

Microsoft Agent Framework es la elección natural para equipos invertidos en el ecosistema Microsoft. Soporte .NET sin igual. IChatClient y Azure AI Foundry lo hacen el camino de menor resistencia para despliegues empresariales. El tradeoff es lock-in de Azure y comunidad más pequeña.

Workflows Declarativos con YAML

Define agentes y orquestaciones en archivos YAML versionados, revisados por código y específicos por entorno. Habilita workflows GitOps donde cambios de comportamiento del agente pasan por el mismo proceso de revisión de PR que el código de aplicación.

# agents/support-team.yaml
name: SupportTeam
orchestration: handoff
entry_agent: triage

agents:
  - name: triage
    instructions: |
      You are a customer support triage agent.
      Route billing issues to the billing agent.
      Route technical issues to the technical agent.
    model: gpt-5.5
    handoffs: [billing, technical]

  - name: billing
    instructions: |
      You handle billing and subscription questions.
      You can look up invoices and process refunds.
    model: gpt-5.5
    tools:
      - lookup_invoice
      - process_refund

  - name: technical
    instructions: |
      You handle technical support and debugging.
      You have access to the knowledge base and logs.
    model: claude-sonnet-4-6
    tools:
      - search_knowledge_base
      - query_logs

# Load and run from YAML (Python)
from agent_framework import load_orchestration

team = load_orchestration("agents/support-team.yaml")
result = await team.run("I was charged twice last month")