Last week Microsoft pushed the Agent Framework (MAF) onto GitHub Trending, racking up 13,356 stars and billing itself as production-grade. I ran through most of the samples directory. Bottom line up front: this is currently the most "enterprise-ready" agent framework out there, but the tradeoff is a thick abstraction layer that feels heavy for small projects.
What problem does it solve
LangChain is too unopinionated. AutoGen is too toy-like. LangGraph has a steep learning curve. Companies that want to run agents in production need a framework that's provider-agnostic, observable, and supports human-in-the-loop out of the box. Microsoft's agent-framework targets exactly that gap.
Three things stand out:
- Observable: every workflow node broadcasts events on state changes, with built-in OpenTelemetry integration
- Recoverable: built-in checkpointing lets a crashed workflow resume from the latest snapshot
- Interruptible: human-in-the-loop is a first-class concept, not a bolt-on afterthought
In the LangChain era, you had to assemble all three yourself. MAF bakes them into the Runtime layer.
How to use it
pip install agent-framework, then 30 lines for a tool-calling agent:
from agent_framework.azure import AzureAIAgent
from agent_framework import tool
@tool
def get_weather(city: str) -> str:
return f"{city}:sunny, 25°C"
agent = AzureAIAgent(
name="weather-bot",
instructions="You are a weather assistant. Use tools to answer questions.",
tools=[get_weather],
)
async def main():
response = await agent.run("What's the weather in Beijing today?")
print(response.text)
import asyncio
asyncio.run(main())
Another 50 lines and you have a sequential workflow where two agents handle an order in relay:
from agent_framework import WorkflowBuilder, executor
@executor
async def intake(msg: str, ctx):
await ctx.send_message(msg, target_id="validator")
@executor
async def validator(msg: str, ctx):
if "fraud" in msg.lower():
await ctx.yield_output("blocked")
else:
await ctx.send_message(msg, target_id="fulfill")
@executor
async def fulfill(msg: str, ctx):
await ctx.yield_output(f"order {msg} shipped")
wf = (
WorkflowBuilder()
.set_start_executor(intake)
.add_edge(intake, validator)
.add_edge(validator, fulfill)
.build()
)
async def main():
async for ev in wf.run_stream("order-12345"):
print(ev)
Notice the add_edge graph-style API. It's effectively a LangGraph-style DAG, just with different naming.
How it works
Three layers:
- Agent: a single unit that wraps an LLM client, a tool set, and a system prompt
- Workflow: the orchestration layer, a graph structure defining data flow between agents
- Runtime: the execution layer handling checkpointing, streaming, HITL, and time-travel
The graph orchestrator ships with four built-in topologies:
- Sequential: A → B → C, a pipeline
- Concurrent: broadcast to multiple agents, then merge results
- Handoff: pass a task to another agent based on context (similar to AutoGen's group chat)
- Group Chat: multi-agent round table with a moderator
Deploying to Azure AI Foundry takes two extra lines: swap AzureAIAgent for FoundryAgent and set the foundry endpoint as an environment variable. Nothing else changes.
Where it shines, where it doesn't
Shines:
- Consistent dual-stack API. Python and .NET naming conventions are nearly identical
- Enterprise features are complete: checkpointing, streaming, human-in-the-loop, and time-travel are all first-class
- Deep Microsoft ecosystem integration: Foundry, Azure OpenAI, and GitHub Copilot SDK have native support
Doesn't:
- The Python package is heavy; importing
agent_frameworkdrags in a pile of dependencies - Documentation for non-OpenAI-compatible providers (like DeepSeek or Qwen) is thin
- Splitting out the Go SDK is a double-edged sword: the separate repo's release cadence may drift from the main one
Comparison table:
- MAF: graph + four topologies; medium learning curve; strong production features
- LangGraph: custom DAG; steep learning curve; medium production features
- AutoGen: conversation-driven; low learning curve; weak production features
- CrewAI: role-based; low learning curve; medium production features
MAF fits the scenario where you know which of the four orchestration patterns you want. LangGraph fits when you need to define arbitrary topologies yourself.
What I tried
I ran the function-calling example from samples/02-agents and the sequential workflow from samples/03-workflows locally. Results:
- Cold start time: AzureAIAgent initialization plus first model call, 2.1s (auth alone took 0.8s)
- Token consumption: a single weather query used roughly 320 input tokens and 85 output tokens, with tool descriptions making up 40% of the input
- Checkpoint behavior: the workflow auto-persists after each executor node; on restart it picks up from the breakpoint with no duplicate execution
Feels like: the API design is far more convergent than LangGraph's, but the debugging info isn't as intuitive as LangGraph's dev UI. You end up printing workflow intermediate state yourself, and for visualization you have to plug in an external tracing tool.
Who should use it
Good fit:
- .NET teams (Microsoft's baby, the .NET SDK actually went GA before Python)
- Enterprise projects that need HITL, audit logs, and observability
- Finance, healthcare, and legal scenarios with strict compliance requirements
Not a fit:
- Users who just want to run a few prompts (the OpenAI SDK is enough)
- Pure frontend demos (MAF is a backend framework)
- Researchers who need LangGraph-style highly custom DAGs
Editorial take
Microsoft's biggest differentiation this time isn't raw technology. It's that the company is redefining the agent framework using enterprise-software standards: durability, observability, provider abstraction. These words barely came up in the LangChain era. My bet: within 12 months, the default choice for production-grade agent projects will shift from LangGraph to MAF or a framework like it.
The risk: Microsoft has a history of half-finished bets like Bot Framework and Semantic Kernel. If the community fragments too quickly, the Python side might lose to LangChain. Semantic Kernel was also "Microsoft's official .NET-friendly framework" once, and LangChain stole its thunder.
One unknown: how deep the support goes for Chinese domestic LLMs like DeepSeek and Qwen. The README doesn't say. Theoretically you can route through an OpenAI-compatible layer, but there's no evidence of dedicated testing for tool-call formats or Chinese system prompt templates. If you're deploying inside China, this is the first thing you'll want to verify yourself.