Microsoft Agent Framework RC for .NET: Frozen APIs + MCP Support

Update (April 2026): This post covers the RC announcement. Check the official Microsoft Agent Framework repository and release notes for current GA status and package versions before starting a new production project.

The Announcement

Microsoft Agent Framework hit Release Candidate on February 19, 2026. GA is targeted for Q1 2026 — which means weeks, not months.

This matters for every .NET developer working with AI because Agent Framework is where Microsoft is concentrating its agentic AI investment. It’s the official successor to both Semantic Kernel Agents and AutoGen. AutoGen is entering maintenance-only mode. The Semantic Kernel agent abstractions (ChatCompletionAgent, OpenAIAssistantAgent) will continue to work, but new capabilities are landing in Agent Framework first.

If you’re building agents in .NET, this is the framework to learn.

What Agent Framework Actually Is

Agent Framework sits one layer above Semantic Kernel in the Microsoft AI stack:

Microsoft.Extensions.AI        ← abstraction layer (IChatClient, IEmbeddingGenerator)
        ↓
Semantic Kernel                ← orchestration SDK (plugins, memory, planners)
        ↓
Microsoft Agent Framework      ← agentic layer (multi-agent, MCP, workflows)
        ↓
Azure OpenAI / Azure AI Search ← model & search services

This layering is important. Agent Framework doesn’t replace Semantic Kernel — it builds on it. Your SK plugins still work. Your DI registration patterns still work. Your kernel configuration still works. Agent Framework adds the orchestration patterns needed for autonomous agents: multi-agent coordination, goal-directed reasoning, checkpointing for long-running tasks, and standardized tool integration through MCP.

Key Features in the RC

Four Orchestration Patterns

Agent Framework ships with four built-in orchestration strategies for multi-agent systems:

Sequential Pipeline — Agents execute in order, each one’s output becoming the next one’s input:

var pipeline = new SequentialOrchestrator(
    new[] { researchAgent, analysisAgent, writerAgent });

var result = await pipeline.InvokeAsync("Research quantum computing trends");
// researchAgent → analysisAgent → writerAgent

Concurrent Execution — Multiple agents work in parallel on the same task:

var concurrent = new ConcurrentOrchestrator(
    new[] { webSearchAgent, databaseAgent, apiAgent });

var results = await concurrent.InvokeAsync("Find pricing for product X");
// All three agents execute simultaneously

Handoff Pattern — Agents route tasks to specialists based on content:

var handoff = new HandoffOrchestrator(
    triageAgent,
    new Dictionary<string, Agent>
    {
        ["billing"] = billingAgent,
        ["technical"] = techSupportAgent,
        ["general"] = generalAgent
    });

Group Chat — Agents collaborate in a shared conversation with a moderator:

var groupChat = new GroupChatOrchestrator(
    moderator: coordinatorAgent,
    participants: new[] { designerAgent, developerAgent, reviewerAgent });

Native MCP Support

Agent Framework consumes MCP servers as first-class tool providers. No adapters, no wrapper code:

agent.AddMcpToolProvider(new Uri("https://tools.example.com/mcp"));

The agent discovers available tools from the MCP server, includes them in its tool calling schema, and invokes them as part of its reasoning loop. This is how you give agents access to databases, APIs, file systems, and external services without writing custom plugin code for each one.

Production Features

The RC includes features that separate “demo agent” from “production agent”:

• Checkpointing — Save and restore agent state for long-running workflows. If a task takes hours and your server restarts, the agent picks up where it left off.
• Human-in-the-Loop — Pause agent execution and wait for human approval before proceeding with sensitive actions.
• OpenTelemetry Integration — Trace agent reasoning, tool calls, and inter-agent communication with standard observability tooling.
• Structured Logging — Every agent decision, tool invocation, and handoff is logged with structured data for debugging and audit.

Should You Migrate Now?

This is the question everyone’s asking. Here’s a direct recommendation based on where your project sits:

Starting a new project with agentic features? Use Agent Framework RC. The API surface is frozen. The patterns are documented. Build on the framework that’s receiving all of Microsoft’s investment.

Have existing Semantic Kernel agents in production? Don’t rush. Plan migration for after GA when the migration guide and tooling are finalized. Your SK agent code will continue to work — SK isn’t going away.

Using Semantic Kernel for non-agentic features? Stay on SK. If you’re doing RAG, chat completions, function calling, or embedding generation without autonomous agents, Semantic Kernel is still the right tool. Agent Framework is specifically for agentic patterns.

Using AutoGen? Start planning migration. AutoGen is entering maintenance mode. New features and fixes will land in Agent Framework, not AutoGen.

Side-by-Side: SK Agent vs Agent Framework

Here’s the same simple agent built both ways, to give you a sense of the migration surface:

Semantic Kernel (current):

var agent = new ChatCompletionAgent
{
    Name = "Helper",
    Instructions = "You are a helpful assistant.",
    Kernel = kernel
};

var chat = new AgentGroupChat(agent);
chat.AddChatMessage(new ChatMessageContent(AuthorRole.User, "Hello"));
await foreach (var msg in chat.InvokeAsync())
{
    Console.WriteLine(msg.Content);
}

Agent Framework RC:

var agent = AgentBuilder.CreateChatCompletionAgent()
    .WithName("Helper")
    .WithInstructions("You are a helpful assistant.")
    .WithKernel(kernel)
    .Build();

var thread = await agent.CreateThreadAsync();
await thread.AddMessageAsync("Hello");
await foreach (var msg in thread.InvokeAsync())
{
    Console.WriteLine(msg.Content);
}

The concepts transfer directly. The API surface is more explicit about threads and lifecycle, which matters for production code where you need state management and checkpointing.

What Comes Next

GA is weeks away. When it ships, expect:

• Complete migration guide from Semantic Kernel Agents
• Visual Studio and VS Code project templates
• Azure Container Apps deployment guidance
• Integration with Azure AI Foundry for agent management

Further Reading

• Migrate from Semantic Kernel to Microsoft Agent Framework — Step-by-step migration guide with side-by-side code comparisons
• Microsoft Agent Framework: Complete Guide for .NET Developers — Deep dive into architecture, patterns, and production deployment
• Build Your First AI Agent in .NET — Hands-on agent tutorial using Semantic Kernel