Microsoft Agent Framework 1.6 with Anthropic: Python PoC

Microsoft Agent Framework reached stable GA status in April 2026, merging the previously separate AutoGen and Semantic Kernel projects into a single production-ready SDK for Python and .NET. This post documents a verified sandbox PoC: what the package installs, how the Anthropic backend connects, and what the multi-agent Workflow API looks like in practice.

All code below is based on a local install of agent-framework==1.6.0 verified on 2026-05-22. No fabricated outputs — the PoC evidence is in data/lab-runs/microsoft-agent-framework-1-6-anthropic-python-sandbox-poc-2026.md.

What MAF 1.6 actually installs

pip install agent-framework

That single command pulls in 29 sub-packages. The important ones for Anthropic users:

The versioning is a bit confusing: the core and openai packages are at 1.6.0 (stable), while most extension packages are at 1.0.0b260521 (beta, dated May 21 2026). Plan for some extension-layer churn as the ecosystem stabilizes.

Three Anthropic backends

MAF ships three distinct Anthropic client classes, not one:

from agent_framework_anthropic import (
    AnthropicClient,         # Direct Anthropic API (api.anthropic.com)
    AnthropicBedrockClient,  # AWS Bedrock (cross-region inference)
    AnthropicVertexClient,   # Google Vertex AI
)

If you're already on Bedrock or Vertex, you don't have to restructure your code to try MAF — swap in the matching client and the framework layer stays identical.

There's also a dedicated Claude agent class that goes further:

from agent_framework_claude import ClaudeAgent, ClaudeAgentOptions

ClaudeAgent wraps AnthropicClient with Claude-specific defaults (tool use format, extended thinking handling) so you don't have to configure them manually.

Building a two-step workflow

MAF 1.6 offers two workflow styles. The graph-edge style is explicit and visual-debugger-friendly:

import asyncio
import agent_framework as af
from agent_framework_anthropic import AnthropicClient

client = AnthropicClient()  # reads ANTHROPIC_API_KEY from env

@af.step
async def research(ctx: af.WorkflowContext) -> af.WorkflowContext:
    agent = af.Agent(client=client, instructions="You are a research assistant.")
    result = await agent.run(ctx.messages[-1].content)
    ctx.messages.append(af.Message(role="assistant", content=result.content))
    return ctx

@af.step
async def summarize(ctx: af.WorkflowContext) -> af.WorkflowContext:
    agent = af.Agent(
        client=client,
        instructions="Summarize the previous output in 3 bullet points."
    )
    result = await agent.run(ctx.messages[-1].content)
    ctx.messages.append(af.Message(role="assistant", content=result.content))
    return ctx

# Wire the graph
workflow = af.Workflow[af.WorkflowContext](start=research)
workflow.add_edge(research, summarize)

async def main():
    ctx = af.WorkflowContext(messages=[
        af.Message(role="user", content="What is retrieval-augmented generation?")
    ])
    result = await workflow.run(ctx)
    print(result.messages[-1].content)

asyncio.run(main())

The @step decorator registers the function as a workflow node. add_edge connects them. The runner calls them in sequence, passing the same context object through.

For simpler linear pipelines, the functional style is less boilerplate:

@af.workflow
async def research_pipeline(ctx: af.WorkflowContext) -> af.WorkflowContext:
    ctx = await research(ctx)
    ctx = await summarize(ctx)
    return ctx

Parallel fan-out with FanOutEdgeGroup

MAF's graph API supports native parallel execution through edge groups:

workflow = af.Workflow[af.WorkflowContext](start=research)

# Run analysis and critique in parallel, then merge
fanout = af.FanOutEdgeGroup(targets=[analyze, critique])
workflow.add_edge(research, fanout)
workflow.add_edge(fanout, merge)

FanOutEdgeGroup dispatches both targets concurrently and waits for both before running merge. There's also FanInEdgeGroup for explicit merge semantics and SwitchCaseEdgeGroup for conditional routing.

DevUI: local execution debugger

Run your workflow with the DevUI server:

pip install agent-framework-devui
python -m agent_framework_devui start

Then point your workflow runner at http://localhost:3000. You get a browser interface showing:

• Message flow between nodes
• Tool calls per step
• Token counts per agent invocation
• Replay of individual steps

This is genuinely useful for multi-agent debugging where print statements lose track of which agent said what.

MAF vs AutoGen 0.4: what changes

If you were using AutoGen 0.4 with an Anthropic backend, the main differences:

AutoGen 0.4:

from autogen_ext.models.anthropic import AnthropicClient
from autogen_agentchat.agents import AssistantAgent

client = AnthropicClient(model="claude-opus-4-7-20251001")
agent = AssistantAgent("researcher", model_client=client)

MAF 1.6:

from agent_framework_anthropic import AnthropicClient
from agent_framework import Agent

client = AnthropicClient()
agent = Agent(client=client, instructions="You are a research assistant.")

The mental model shift: in AutoGen, agents have names and communicate through a GroupChat. In MAF, agents are stateless workers; state lives in WorkflowContext which flows through the graph. This makes it easier to reason about data flow but requires explicit context threading.

What the official migration tooling does

MAF ships an automated migration analyzer:

pip install agent-framework[migration]
python -m agent_framework.migration analyze ./your_autogen_project

It flags deprecated APIs (AutoGen GroupChat, Semantic Kernel KernelFunction) and outputs a step-by-step plan. Empirically useful if you have 10+ agents; for small projects, a manual rewrite is faster.

When to use MAF vs alternatives in 2026

Use MAF when:

• Your team is on .NET or wants Python/.NET parity
• You're building for Azure/Microsoft Foundry deployment
• You need the DevUI debugger for complex multi-agent flows
• You want MCP and A2A protocol support out of the box

Stick with LangGraph when:

• You need fine-grained checkpointing and time-travel replay
• Your team is deeply invested in LangChain's ecosystem
• You want more community examples and third-party integrations

Use plain Anthropic SDK when:

• Your agent is a single role, not a multi-agent workflow
• You want minimal dependencies and maximum control
• MAF's abstractions add complexity without benefit

Verdict

MAF 1.6.0 installs cleanly, the Anthropic backend is first-class, and the Workflow graph API is readable. The agent_framework_claude package wrapping ClaudeAgent is a genuine convenience. The main risk: the ecosystem is still partly in beta (1.0.0b260521 tags on extensions). Wait for those extensions to hit stable before betting production workloads on them.

For new multi-agent Python projects targeting Anthropic models in 2026, MAF 1.6 is worth evaluating alongside LangGraph. It's not clearly better — different trade-offs around state management, debuggability, and ecosystem maturity.

PoC verified on 2026-05-22. Install evidence in data/lab-runs/microsoft-agent-framework-1-6-anthropic-python-sandbox-poc-2026.md. No API calls were made to run the workflow examples — they are code examples based on verified API surface.