Microsoft Agent Framework

Microsoft Agent Framework is an open-source, production-oriented SDK for building AI agents and multi-agent workflows, maintained by Microsoft under an MIT license. First released in October 2025, it merges the lineages of Semantic Kernel and AutoGen into a single, polyglot framework with first-class support for Python and .NET (C#). The project has already accumulated over 10,600 GitHub stars and 1,800 forks, with 140 contributors and 86 releases as of mid-2026, signaling strong engineering investment.

The framework sits in the orchestration, agent runtime, and workflow categories. It competes directly with LangChain, CrewAI, and LangGraph for teams that need structured, durable agent systems rather than stateless chat loops. Its design philosophy is rooted in serving enterprise .NET and Python teams who require consistent APIs across both languages, built-in governance, and a clear path to Azure AI Foundry for hosting. Microsoft built this framework explicitly for production: checkpointing, OpenTelemetry tracing, human-in-the-loop patterns, and graph-based workflows are first-class constructs, not afterthoughts.

Building with Microsoft Agent Framework is code-first and imperative with declarative workflow definitions. The core abstraction is the Agent object, which exposes a pipeline architecture. An agent processes requests through three layers: agent middleware (logging, validation, transformation), a context layer (chat history providers, AI context providers), and a chat client layer (the LLM provider, wrapped with middleware for function calling and telemetry). This layered design lets you customize behavior at any point without forking the framework.

Workflows are defined as directed graphs. You compose agents and tasks using edges for sequential, concurrent, handoff, and group collaboration patterns. The framework provides built-in executors for running these graphs, with checkpointing that supports time-travel debugging (replaying from any node). Control flow is explicit: you define which agents handle which steps, how tools are passed between agents, and how human-in-the-loop gates pause execution. This graph-based approach means you can model complex processes like document approval chains, multi-step research pipelines, or customer escalation flows without hand-coding state machines.

Agents can invoke tools (function calling), maintain memory via pluggable persistence providers, and stream responses. The framework uses a consistent RunAsync() (C#) or run() (Python) pattern across all agent types, making it straightforward to switch between single-agent and multi-agent modes.

Python and .NET parity. This is the framework’s standout feature. Both Python and C# APIs share identical patterns, agent types, workflow builders, and tool interfaces. A team with mixed-language services can build agents in one language and port logic to the other with minimal friction. No other production agent framework offers this level of cross-platform consistency.

Graph-based workflows. Agents compose into workflows using a directed graph model. Supported patterns include sequential pipelines, concurrent fan-out, conditional handoffs between specialized agents, and group chat-style orchestration. The checkpointing system persists state at each node, enabling pause, restart, and rollback. Time-travel debugging lets you re-run a workflow from any prior step, which is critical when troubleshooting multi-agent conversations.

Azure AI Foundry deployment. A single command deploys agents to Foundry Hosted Agents, giving you managed infrastructure, built-in governance policies, and Azure Monitor integration. For organizations already on Azure, this reduces operational overhead significantly. Self-hosting is also supported (Docker, Kubernetes, any cloud), but the Azure path is the smoothest.

OpenTelemetry tracing. Agents emit traces and metrics via OpenTelemetry, plugging into your existing observability stack (e.g., Azure Monitor, Datadog, Grafana). The DevUI provides a local dashboard for inspecting agent conversations, tool calls, and workflow state during development.

Tool use and memory. Function calling is handled through a middleware pipeline that manages tool invocation, error handling, and rate limiting. Memory can be backed by in-memory stores, databases, or vector stores via provider interfaces.

Streaming. Real-time token streaming from LLM calls is supported, enabling user-facing chat experiences with progressive response rendering.

Human in the loop. Workflows can pause at checkpoints and await human approval or input before proceeding. This is implemented as a special edge or middleware that suspends execution and resumes after external confirmation.

Multi-agent coordination. The framework supports agent handoff (delegating a conversation to another agent) and group collaboration (agents share a common context and respond sequentially or in rounds). It also integrates with the A2A protocol for interoperability with agents built on other frameworks.

Enterprise agents on Azure. The primary target. Organizations that already use Azure OpenAI, Azure Functions, and Durable Tasks can deploy agent workflows with managed governance, role-based access control, and cost tracking. Typical workloads include internal copilots for IT helpdesk, HR policy Q&A, and compliance document review.

.NET teams adding agents. C# and F# teams that want to augment existing .NET applications with AI agents without learning Python or JavaScript. Microsoft Agent Framework gives them a familiar async/await pattern, dependency injection support, and seamless integration with ASP.NET Core, Azure Functions, and Entity Framework. Use cases include automated customer support escalations, code generation pipelines integrated with CI/CD, and data processing agents that call existing .NET services.

Migrating from Semantic Kernel or AutoGen. Teams that have built prototypes on Semantic Kernel’s plugin system or AutoGen’s multi-agent chats but hit scaling or governance issues. Microsoft provides dedicated migration guides for both predecessors, including API mapping tables and code transformation recipes. This framework is the intended successor for both projects, so migration effort is lower than switching to a completely different paradigm.

Research assistants and document processing. Graph workflows enable multi-step pipelines: ingest a document, extract entities, summarize, then generate a report. Human-in-the-loop checkpoints allow a reviewer to verify sensitive extracts before final output.

Poor fit for. Teams that need a first-class JavaScript/TypeScript SDK (Node.js/Deno/Bun). Only TypeScript bindings exist for declarative agents (around 3% of the codebase), and there is no full TypeScript agent SDK. Also, teams targeting non-Azure clouds (AWS, GCP) will find managed deployment less integrated; self-hosting works but requires more manual setup than frameworks with native cloud SDK support.

Install the Python package via pip:

1pip install agent-framework

For .NET, add the NuGet package:

1dotnet add package Microsoft.Agents.AI

A minimal agent in Python (conceptual, not runnable as-is):

1from agent_framework import Agent, ChatClientAgent
2
3agent = ChatClientAgent(
4    name="assistant",
5    instructions="You are a helpful assistant.",
6    model="gpt-4o",
7    api_key="...",  # or use Azure OpenAI config
8)
9
10response = agent.run("What is the capital of France?")
11print(response.text)

You need an LLM provider key (OpenAI, Azure OpenAI, or any OpenAI-compatible endpoint). For memory, you can start with an in-memory store and later swap to a database. Tracing via OpenTelemetry requires an exporter (console is enough for local dev).

Full documentation is at [learn.microsoft.com/en-us/agent-framework/](https://learn.microsoft.com/en-us/agent-framework/), with quickstart tutorials, migration guides, and samples. The GitHub repository ([github.com/microsoft/agent-framework](https://github.com/microsoft/agent-framework)) contains example projects for both Python and C#. Community discussions happen on the Microsoft Foundry Discord.

vs LangChain / LangGraph. Both frameworks offer graph-based workflows, tool use, and multi-agent patterns. Microsoft Agent Framework’s edge is Python/.NET parity and native Azure AI Foundry deployment. LangChain has a larger community, more pre-built integrations, and first-class TypeScript support. Choose Microsoft Agent Framework if you are deeply invested in the .NET ecosystem or need Azure governance out of the box. Choose LangChain if you need broad cloud-agnostic integrations, JS/TS teams, or the richest selection of third-party tools.

vs CrewAI. CrewAI is a Python-only framework focused on role-based multi-agent teams with a simpler API. Microsoft Agent Framework offers more granular control over workflow graphs, checkpointing, and observability. CrewAI is easier to get started with for quick prototypes; Microsoft Agent Framework is better for production durability and cross-language teams. Neither has a fully mature TypeScript SDK, though Microsoft plans to expand.

vs Semantic Kernel / AutoGen (predecessors). This framework is the direct upgrade. If you already use Semantic Kernel for plugin orchestration or AutoGen for multi-agent chats, migrating to Microsoft Agent Framework gives you graph workflows, built-in tracing, and a unified API for both Python and .NET. The migration guides are official and well-documented. Do not start new projects on the old frameworks.

vs Pydantic AI. Pydantic AI is Python-only, lightweight, and type-safe, ideal for structured output and validation-heavy pipelines. Microsoft Agent Framework is heavier, but provides multi-agent orchestration, workflow durability, and cross-language support. Use Pydantic AI for simple LLM calls with strict output schemas; use Microsoft Agent Framework for multi-agent systems that need resilience and governance.

For teams already in the Microsoft ecosystem or requiring a consistent Python/.NET agent stack, Microsoft Agent Framework is the strongest option in early 2026. Its youth means fewer community recipes and third-party integrations, but the core engineering is production-grade and the roadmap is aggressive.