Enter Microsoft Agent Framework (MAF) 1.9 — released June 18, 2026, just three days ago. And with 11,500 GitHub stars, 1,900 forks, it’s Microsoft’s most serious attempt yet at a cross-language agent orchestration system. I spent the weekend installing it, pushing it through a real multi-agent workflow, and deploying the whole thing on a cheap VPS. Here’s what I found.

TL;DR: Who Should Pay Attention

If you’re building agents that need to do more than one thing in sequence — review code then write tests then deploy — and you care about state management, observability, and not losing your mind debugging a chain of 8 LLM calls, MAF is worth your time. But it’s not a LangChain killer. It’s not trying to be. It’s something else entirely: a graph-based state machine for agent workflows, with built-in hosting patterns that actually make “deploy to production” a one-step action rather than a week-long project.

What Is Microsoft Agent Framework?

So MAF is Microsoft’s open-source framework for building, orchestrating, and deploying AI agents — in Python and .NET with consistent APIs across both. It was forked from the earlier Semantic Kernel work but completely re-architected around four layers:

Agent → Workflow → Graph → Hosting

• Agent: the basic unit — a client + instructions + tools
• Workflow: a decorated function or class method that represents a step
• Graph: the orchestration layer — chains agents in sequential, concurrent, handoff, or group patterns
• Hosting: how the graph gets deployed — A2A protocol, Durable Tasks, Azure Functions, or a plain old FastAPI service

What caught my attention is the graph-as-state-machine design. But instead of chains inside chains inside chains (LangChain’s nemesis), MAF gives you explicit graph constructs. You can see the flow. You can debug the flow. And when something fails mid-way, the durable execution runtime can pick up where it left off — no wasted tokens.

First Agent in 5 Minutes

So I tested this on my Ryzen 9 workstation running Python 3.11. The install pulled in about 60 dependencies (it’s a big framework), but it took under a minute.

from agent_framework import Agent
from agent_framework.openai import OpenAIChatClient

agent = Agent(
    name="code_explainer",
    client=OpenAIChatClient(model="gpt-4o"),
    instructions="You explain code snippets in plain English. "
                 "Keep explanations under 200 words. "
                 "Assume the reader knows Python but not the specific library.",
)

response = agent.run("def foo(x): return [i**2 for i in range(x) if i % 2 == 0]")
print(response)

That’s it. And four imports, one class instantiation, one run() call. The OpenAIChatClient abstracts away prompt construction, token counting, and retry logic — you get a clean interface that feels like calling a function.

What I liked: the instructions parameter doubles as a system prompt but gets compiled into the graph’s metadata, which means downstream tools and middleware can read it. And what surprised me: the middleware stack runs before and after every agent call — logging, metrics, content filtering — and it Just Worked out of the box.

The Real Magic: Multi-Agent Workflows with Graph Patterns

Now where MAF shines is when you need multiple agents collaborating on a single task. Here’s a realistic example I built: a code review pipeline with three specialists.

from agent_framework import Agent
from agent_framework.graph import SequentialGraph
from agent_framework.middleware import LoggingMiddleware, MetricsMiddleware

reviewer = Agent(
    name="reviewer",
    client=OpenAIChatClient(model="gpt-4o"),
    instructions="Review code for bugs, security issues, and logic errors. "
                 "Output a structured report with severity levels.",
)

security_agent = Agent(
    name="security",
    client=OpenAIChatClient(model="gpt-4o"),
    instructions="Analyze code for OWASP Top 10 vulnerabilities. "
                 "Flag any hardcoded secrets, SQL injection vectors, "
                 "or unsafe deserialization.",
)

qa_agent = Agent(
    name="qa_engineer",
    client=OpenAIChatClient(model="gpt-4o"),
    instructions="Given the code and the review report, "
                 "generate a test plan. Include edge cases.",
)

pipeline = SequentialGraph(
    agents=[reviewer, security_agent, qa_agent],
    middleware=[LoggingMiddleware(), MetricsMiddleware()],
    max_retries=2,
)

result = pipeline.run(code_snippet)

So the SequentialGraph passes the output of each agent as input to the next — but you can also use ConcurrentGraph (fan-out, results merge), HandoffGraph (agent A delegates to agent B mid-turn), or GroupGraph (agents collaborate on a shared context). The handoff pattern is particularly interesting for support/chat scenarios where a customer agent hands off to a billing agent.

Here’s the thing that sold me: the middleware in MAF is a first-class concept. But in LangChain you’d hack together callbacks. And in CrewAI you’d monkey-patch the agent class. But in MAF you just pass a list of middleware objects, and they fire at every lifecycle hook — on_agent_start, on_agent_end, on_step_start, on_error. That single feature alone makes observability ten times easier.

Microsoft Agent Framework vs LangChain vs CrewAI: The Honest Comparison

Now I’ve used all three in production-ish settings this year. Here’s the breakdown.

Still, when MAF takes a different approach from LangChain — it’s built for structured, observable production workflows rather than rapid experimentation. Still, LangChain’s strength is its ecosystem and flexibility. And CrewAI’s is its simplicity. But MAF’s is its architecture. Pick the tool that fits your team’s maturity.

Deploying MAF to a VPS: The Production Path

And the deployment section is where the framework surprised me most. And MAF ships with multiple hosting patterns — you don’t bolt on deployment, it’s part of the architecture.

The simplest path: wrap your graph in a FastAPI service and run it on a VPS.

# deploy_service.py
from agent_framework.hosting import serve
from agent_framework.a2a import A2ARouter

router = A2ARouter()

@router.agent("code-review-pipeline")
async def handle_review(request):
    pipeline = create_pipeline()
    return await pipeline.run(request.input)

serve(router, host="0.0.0.0", port=8080)

Then on your VPS:

# Assuming Ubuntu 22.04+
sudo apt update && sudo apt install python3-pip -y
pip install agent-framework
python deploy_service.py

Now that last command spins up a FastAPI server with A2A (Agent-to-Agent) protocol support out of the box. A2A is Google and Microsoft’s joint standard for agent communication — think of it as HTTP for agents. Your MAF service speaks A2A natively, which means other A2A-compatible agents (from any framework) can discover and call your agents.

And for teams that need durable execution (workflows that survive server restarts), MAF integrates with Azure Durable Tasks or the open-source durabletask Python package. And the workflow state is persisted to a storage backend, and on recovery the framework replays from the last checkpoint — not from the beginning. But for expensive agent workflows (each call costing tokens), this makes a serious difference.

Honest Limitations

Still, I can’t recommend MAF without being upfront about the rough edges.

1. The dependency surface is massive. pip install agent-framework pulls in 60+ packages — everything from Hyperlight sandboxing to Azure Storage to Qdrant. If you’re deploying on a minimal VPS, you’ll need at least 1 GB of disk space just for the framework. I’d love to see a lightweight install option (pip install agent-framework-core) for folks who don’t need the full Azure integration.

2. 680 open issues is a lot. Microsoft’s development velocity is high (the framework gets commits almost daily), but the issue tracker has real pain points — documentation gaps, edge cases in the graph runtime, and some provider driver bugs. The v1.9.0 release fixed 170+ issues from v1.8, so the trend is positive, but you’ll hit rough patches.

3. Azure is the path of least resistance — and that’s a double-edged sword. MAF supports OpenAI, Anthropic, Ollama, and Bedrock providers through its abstraction layer, but the documentation and examples overwhelmingly favor Azure. If you’re a startup running everything on OpenAI’s API directly, be prepared to read between the lines of Microsoft-centric docs.

4. The learning curve is steeper than CrewAI. CrewAI’s “define an agent, define a task, run it” model takes 10 minutes. MAF’s graph patterns, middleware lifecycle, and hosting abstractions take a solid afternoon to internalize. It’s time well spent for production systems, but it’s real friction.

5. Python tooling ecosystem is still maturing. The .NET version of MAF benefits from Visual Studio’s debugging and IntelliSense — the Python version gets less IDE polish. Type hints are good, but autocomplete in VS Code didn’t surface some graph constructors reliably.

Who Should (And Shouldn’t) Use MAF

You should use MAF if:

• Your agent workflows have branching, retry, or human-in-the-loop requirements
• You need durable execution (state survives crashes)
• You’re operating in a .NET shop and want consistent agent APIs across stacks
• You care about A2A protocol compatibility
• “Three nines” reliability matters more than “I can build it in an afternoon”

You should skip MAF if:

• You need a proof-of-concept by tomorrow
• You’re building a simple RAG pipeline (LangChain is the right tool)
• Your team has zero experience with graph/state-machine concepts
• You want a minimal deployment footprint

The Bottom Line

So here’s my bottom line: Microsoft Agent Framework 1.9 is one of the most production-ready multi-agent orchestration frameworks I’ve tested this year. It’s not the easiest to learn, not the lightest to deploy, and certainly not the most popular in the GitHub star race. But it’s the only one that treats deployment as a first-class problem, builds observability into the architecture, and handles workflow durability without bolting on third-party services.

And the real test was the VPS deployment: going from pip install to a multi-agent pipeline running behind an A2A endpoint in about 45 minutes. That’s faster than any production LangChain deployment I’ve done, and it’s the metric that matters most to me right now.

If you’re already committed to the Microsoft ecosystem, this is a no-brainer. If you’re not, it’s still worth evaluating for the graph-based orchestration alone. Just budget an afternoon to wrap your head around the patterns — your future self, debugging a 12-agent workflow at 2 AM, will thank you.

📚 Want to go deeper? Check out Building LLM Powered Applications: Create Intelligent Apps and Agents for production patterns and advanced orchestration techniques.

Also in this series: Omnigent Review: Open-Source Multi-Agent Orchestration and Agent Apprenticeship: The Agent Learning Ecosystem — the perfect companion if you’re still in the “learning to build agents” phase.

Disclosure: Some links in this article are affiliate links. If you purchase through them, I may earn a commission at no extra cost to you. All opinions and testing are my own.