Microsoft shipped Agent Framework 1.0 on April 7. The press release says "unification." The architecture says something else.

What Actually Happened

For eighteen months, Microsoft ran two competing agent projects. Semantic Kernel was the enterprise play — a .NET-first kernel with plugins, connectors, and the kind of middleware hooks that make architects feel safe. AutoGen was the research play — conversation-centric multi-agent choreography out of Microsoft Research, where agents talk to each other in chat threads and emergent behavior is a feature, not a bug.

Agent Framework 1.0 merges them. But "merge" is generous. Semantic Kernel's kernel, plugin model, and connector system survived intact. AutoGen's conversation model got replaced with directed graphs. The multi-agent patterns — sequential, concurrent, handoff, group chat — survived as concepts, but the mechanism underneath is now explicit state transitions between graph nodes, not agents chatting their way to consensus.

Both predecessors have entered maintenance mode. No new features. If you bet on AutoGen's conversational paradigm, your migration requires what Microsoft diplomatically calls "architectural rethinking" for anything beyond simple two-agent setups. They offer an autogen_compat bridge module. It adds overhead. It will eventually be deprecated.

Directed Graphs Beat Conversations (In Production)

This is the real story buried under the "unification" branding. Microsoft made an architectural bet: in production, you want explicit control over which agent runs when. Not emergent conversation patterns.

They're right, and anyone who's debugged a multi-agent system at 2 AM knows why.

Conversation-centric agents — the kind AutoGen popularized — work beautifully in demos. Agent A writes copy, Agent B reviews it, they go back and forth until consensus. Elegant. The problem surfaces when you need to answer three questions production systems always ask:

Where is the money going? Conversational agents generate unpredictable token counts. Two agents might converge in 3 rounds or 30. Your CFO will not find "emergent consensus" charming when the inference bill lands.

What happened at step 4? When a directed graph fails, you get a node ID, input state, and output state. When a conversation fails, you get a chat log and best wishes. Graphs give you stack traces. Conversations give you narratives.

Can I replay this? Graph-based workflows support checkpointing and hydration natively. Microsoft's framework lets you snapshot mid-execution and resume hours later on a different machine. Conversations are stateful blobs that resist serialization — try checkpointing a freeform chat thread where two agents have been riffing off each other for twelve turns.

The trade-off is real though. Directed graphs kill emergence. If your use case benefits from agents discovering novel collaboration patterns at runtime — and some research workflows genuinely do — you've lost that capability. The graph model enforces explicit transitions. Every agent-to-agent handoff is a deliberate architectural decision, not a runtime discovery.

For 95% of production workloads, that's the right call. For the remaining 5%, you'll miss what AutoGen was.

Fifty Lines to Say Hello

The developer experience carries a tax. A single-agent setup requires kernel configuration, connector setup, agent instantiation, and graph definition before your agent actually does anything useful. Reviews peg the minimum at around 50 lines. CrewAI does the equivalent in 15.

from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
from azure.identity import AzureCliCredential

agent = Agent(
    client=FoundryChatClient(
        project_endpoint="https://your-project.services.ai.azure.com",
        model="gpt-5.3",
        credential=AzureCliCredential(),
    ),
    name="HelloAgent",
    instructions="You are a friendly assistant."
)

That's the simple version. Add workflow graphs, middleware hooks, and multi-agent orchestration, and the boilerplate compounds. Classic enterprise SDK pattern: the extra layers pay off in complex systems but punish you on day one.

YAML-based declarative configuration helps — you can define agent graphs in config files. But now you're debugging YAML graph definitions alongside Python execution, and the mental model splits in two.

The Azure Shadow

Microsoft claims model-agnostic support. And technically it's true — OpenAI, Anthropic, Google, Ollama, Amazon Bedrock all work. But the AzureAIAgent class ships with file search and code interpreter capabilities that the generic ChatCompletionAgent doesn't have. Documentation defaults to Azure examples. Managed hosting is Azure-exclusive.

Not unusual for a vendor-backed framework, but worth naming. On AWS or GCP, you're a second-class citizen who gets the agent runtime but not the managed infrastructure. And the gap between "runs agents" and "operates agents" is where production reliability actually lives.

When to Walk Away

Pick something else if your situation matches any of these:

  • Solo dev or small team — Claude Agent SDK or CrewAI gets you a working prototype in an afternoon. Agent Framework gets you there by Thursday.

  • TypeScript or Java stack — Python and .NET only. Wrapping it in a REST service adds latency and a deployment surface you don't need.

  • You want emergent multi-agent behavior — The graph model is allergic to surprise. If agents need to discover collaboration patterns at runtime, this framework will actively fight you.

  • Your agents are simple — One agent, a few tools, a chat interface. A directed graph engine for that is a bulldozer for a flower bed.

The Bet

Microsoft is wagering that the agent framework market consolidates around enterprise needs: predictable execution, auditable workflows, managed infrastructure. Semantic Kernel's architecture is the vehicle. AutoGen's ideas are passengers.

That bet will probably pay off for the same reason enterprise Java beat scripting languages in 2005 — not because it was better, but because it was governable. CTOs can approve directed graphs. They cannot approve "the agents will figure it out."

Whether governance matters more than velocity is the open question. LangGraph iterates fast. CrewAI is dead-simple. Anthropic's Agent SDK is opinionated in ways that slash boilerplate. The open-source agent ecosystem moves at a pace that punishes frameworks shipping complexity as a feature.

Agent Framework 1.0 is production-ready. Whether your team is ready for the production it demands is a different question entirely.