Microsoft Agent Framework 1.0 GA — The AutoGen Successor Goes Production-Grade

Microsoft Agent Framework (MAF) hit 1.0 general availability at Build 2026 on April 2, 2026. This is not another preview announcement — MAF unifies AutoGen and Semantic Kernel into a single cross-platform SDK for .NET and Python, with production-grade features that address the gaps most agent frameworks ignore.

For Malaysian enterprises already invested in the Microsoft ecosystem, MAF 1.0 changes the build-vs-buy calculus for AI agent systems. Here is what matters architecturally, what the key features actually deliver, and how MAF compares to alternatives in 2026.

What MAF 1.0 Actually Unifies

AutoGen was Microsoft's research-oriented multi-agent framework — powerful but experimental. Semantic Kernel was the enterprise SDK for integrating LLMs into .NET applications — production-ready but single-agent focused. MAF merges both into a coherent framework:

The Four Key Features That Matter

1. Agent Harness

The Agent Harness is MAF's runtime environment for agents. It provides built-in capabilities that every production agent needs but most frameworks leave to the developer:

Context compaction. Automatically summarizes long conversations to stay within context windows. Instead of truncating or failing when context grows, the harness compresses older exchanges into summaries while preserving critical information.

File memory. Agents can read and write files as persistent memory — no need for external vector databases for simple memory patterns.

TodoProvider. Built-in task tracking for agents that need to manage multi-step workflows. The agent can create, update, and complete tasks within the harness.

BackgroundAgentsProvider. Enables agents to spawn background subtasks that run independently — useful for long-running operations that should not block the main agent loop.

Why this matters: Most agent frameworks give you the LLM call and leave everything else to you. The Harness provides the operational infrastructure that makes agents production-ready.

2. CodeAct

CodeAct is a pattern where a single model call generates executable code that performs the desired action — instead of the traditional tool-call pattern where the model emits a tool name and parameters, the runtime executes the tool, and the model processes the result.

Traditional tool calling:

Model → {"tool": "search", "query": "Azure pricing"}
Runtime → executes search
Model ← search results
Model → processes results
Total: 3 LLM calls

CodeAct:

Model → code that calls search API, processes results, returns answer
Runtime → executes code
Total: 1 LLM call

Performance impact: Microsoft reports 52% latency reduction and 64% token reduction for multi-step tasks. Note: CodeAct is currently available in the agent-framework-hyperlight package (alpha), which runs generated code in Hyperlight micro-VMs for sandboxed execution. The model generates a single code block that chains multiple operations, eliminating the round-trip overhead of sequential tool calls.

When CodeAct works best: - Tasks with deterministic tool sequences (search → filter → summarize) - High-volume execution where latency matters - Tasks where the model can reliably generate correct code for tool interactions

When CodeAct is risky: - Tasks requiring dynamic decision-making at each step - Environments where generated code execution needs sandboxing - Scenarios where the model might generate incorrect API calls

3. Foundry Hosted Agents

MAF agents can be deployed as Foundry Hosted Agents — Microsoft's managed agent runtime:

Scale-to-zero. Agents only consume resources when processing requests. No idle VM costs.

VM-isolated sessions. Each agent session runs in its own VM, providing strong isolation for agents that execute code or access sensitive resources.

Managed lifecycle. Foundry handles scaling, patching, and session state. You define the agent; Foundry runs it.

Integration with Azure AI Foundry. Hosted agents can access the full Foundry model catalog, evaluation tools, and governance features.

Why this matters for Malaysian enterprises: If you are already on Azure, hosted agents eliminate the infrastructure management overhead that makes self-managed agent deployments operationally expensive.

4. Multi-Agent Orchestration Patterns

MAF provides built-in orchestration patterns for multi-agent workflows:

Handoff pattern. Route work between specialist agents — a triage agent delegates to billing or technical support agents based on the request. The HandoffBuilder in agent_framework.orchestrations makes this straightforward.

Sequential and concurrent workflows. Chain agents in sequence for ordered processing, or run them in parallel for fan-out tasks with checkpointing and streaming support.

Group collaboration. Multiple agents collaborate on a shared task, with built-in human-in-the-loop approval flows for sensitive operations.

Why this matters for Malaysian enterprises: These patterns cover the common multi-agent architectures — from simple router-to-specialist flows to complex orchestrated pipelines — without requiring custom orchestration code.

MAF vs. The Competition

MAF vs. LangGraph

When to choose MAF: .NET teams, Azure-native shops, enterprises needing managed hosting and governance.

When to choose LangGraph: Python-first teams, organizations not on Azure, teams that want maximum open-source flexibility.

MAF vs. CrewAI

When to choose MAF: Enterprise deployments requiring governance, .NET integration, or Azure-native operations.

When to choose CrewAI: Rapid prototyping, Python-centric teams, scenarios where the role-based crew pattern maps naturally to the problem.

MAF vs. Custom Orchestration

Many teams (including mine) have built custom multi-agent orchestration using direct API calls. The tradeoff:

MAF advantages over custom: - Built-in context management, memory, and error handling - Hosted deployment eliminates infrastructure management - Azure governance integration (Entra ID, RBAC, monitoring) - Microsoft support and SLA

Custom advantages over MAF: - Full control over every aspect of the agent loop - No framework dependency or version upgrade risk - Can use any LLM provider without MAF's model abstractions - Simpler debugging when you own the entire stack

Practical recommendation: If you are starting a new multi-agent project on Azure, evaluate MAF first. If you have a working custom system, the migration cost may not justify the benefit unless you need Foundry hosted deployment or Azure governance integration.

Migration from AutoGen

For teams already using AutoGen, MAF 1.0 provides migration guidance:

1. Identify agent patterns. Map your AutoGen agents to MAF equivalents (single agent, multi-agent, supervisor).
2. Adopt the Harness. Replace custom context management, memory, and error handling with Agent Harness built-ins.
3. Evaluate CodeAct. Identify agent chains where CodeAct could reduce latency and cost.
4. Update deployment. Move from self-managed AutoGen to MAF with optional Foundry hosting.

Migration effort estimate: For a typical AutoGen deployment with 3-5 agents, expect 2-4 weeks of migration work including testing.

Getting Started

# Install MAF SDK
pip install agent-framework

# Or for .NET
dotnet add package Microsoft.Agents.AI

First agent example (Python):

from agent_framework import Agent, tool

# Define a tool
@tool
def search_web(query: str) -> dict:
    """Search the web for information."""
    return {"results": f"Results for: {query}"}

# Create a harness agent with built-in context, memory, and task management
agent = create_harness_agent(
    client=client,
    max_context_window_tokens=128000,
    name="ResearchAgent",
    instructions="You research topics and provide structured summaries.",
    tools=[search_web],
)

result = await agent.run(
    "Research Azure landing zone best practices for Malaysian enterprises"
)

Key Takeaways

1. MAF 1.0 is production-ready — it is not a research preview. The Agent Harness provides the operational infrastructure (context management, memory, error handling) that most frameworks leave to developers.
2. CodeAct delivers real performance gains — 52% latency reduction and 64% token reduction for multi-step tasks by eliminating sequential tool-call round trips.
3. Foundry Hosted Agents eliminate infrastructure overhead — scale-to-zero, VM isolation, and managed lifecycle make agent deployment operationally simple on Azure.
4. MAF is the strongest choice for .NET and Azure-native teams — Python-first teams not on Azure should evaluate LangGraph or CrewAI as alternatives.
5. Migration from AutoGen is straightforward — map agent patterns to MAF equivalents, adopt the Harness, and evaluate CodeAct for performance-critical chains.

The agent framework landscape in 2026 is consolidating around a few production-grade options. MAF 1.0 is Microsoft's entry, and for enterprises already in the Azure ecosystem, it is the most complete choice for building, deploying, and governing multi-agent systems at scale.