Overview & Positioning

Key Points

• Microsoft Agent Framework GA April 2026. Replaces Semantic Kernel orchestration + AutoGen for new work.
• Built on Microsoft.Extensions.AI. Uses IChatClient under the hood.
• Capabilities: single agent, multi-agent orchestration (5 patterns), workflows, MCP integration, A2A protocol.
• For new projects: this is the .NET orchestration layer.
• For existing SK apps: SK still works; migrate when feasible.

What it is

A higher-level abstraction over IChatClient for building agentic apps:

• Agent = persona + instructions + tools + memory.
• Orchestration = coordinating multiple agents.
• Workflow = deterministic multi-step pipeline (more constrained than free-form agents).
• Tools = functions; can come from MCP servers.

Why it exists

2024 reality:
  - Semantic Kernel: SK Planners; ChatHistory; .NET-specific.
  - AutoGen: Python-first; multi-agent; Microsoft Research origin.
  - LangChain (Python): de-facto.

2026 reality:
  - Microsoft Agent Framework: unified .NET orchestration.
  - Built on Microsoft.Extensions.AI (the new abstraction).
  - First-party support; OTel; eval-friendly.

Core abstractions

public abstract class Agent
{
    public string Name { get; init; }
    public string? Description { get; init; }
    public string? Instructions { get; init; }
    public abstract Task<AgentResponse> InvokeAsync(IEnumerable<ChatMessage> messages, CancellationToken ct);
}

public class ChatClientAgent : Agent
{
    public IChatClient ChatClient { get; init; }
    public IList<AITool> Tools { get; init; }
    // ...
}

Hello agent

var agent = new ChatClientAgent(chatClient)
{
    Name = "Assistant",
    Instructions = "You are a helpful assistant. Be concise."
};

var response = await agent.InvokeAsync("What's 2+2?");
Console.WriteLine(response.Messages.Last().Text);

Or:

await foreach (var update in agent.InvokeStreamingAsync(messages))
    Console.Write(update.Text);

Tools

var agent = new ChatClientAgent(chat)
{
    Instructions = "...",
    Tools = [
        AIFunctionFactory.Create(GetWeather),
        new MCPToolAdapter("https://my-mcp-server")
    ]
};

Tools can be: - .NET methods (via AIFunctionFactory). - MCP servers (uniform interface across vendor agents).

Memory / threads

var thread = new AgentThread();
await agent.InvokeAsync("Hello", thread);
await agent.InvokeAsync("What's my name?", thread);   // remembers context

Threads persist conversation state. Pluggable storage.

Multi-agent orchestration patterns

Detailed in subsequent topic files.

Workflows vs Agents

• Agents: free-form; LLM-driven flow.
• Workflows: structured; deterministic; LLM only at well-defined steps.

For known-procedure tasks: workflow. For exploratory tasks: agent.

See Workflows vs Agents.

MCP integration

var agent = new ChatClientAgent(chat)
{
    Tools = [.. await MCPClient.LoadToolsFromServer("https://github-mcp-server")]
};

MCP makes tools cross-platform. See MCP Integration.

A2A protocol

Agents from different vendors / systems communicate via standardized messages. Early in 2026.

Migration

See Migration from SK and AutoGen.

When NOT use Agent Framework

• Simple chat completion → just IChatClient.
• One-off RAG → no need for full agent.
• Highly constrained workflow → use Durable Functions or similar.

Senior considerations

• Don't reach for agents when a function call suffices.
• Multi-agent costs scale linearly with calls — measure.
• Always trace; agent flows can be opaque without OTel.
• Test deterministically where you can; agentic tests are flaky.

Cross-references

• Agent Basics
• IChatClient & Pipeline
• Migration from SK and AutoGen
• Workflows vs Agents
• MCP Integration