Microsoft Agent Framework 1.0: Building Enterprise AI Agents

On April 3, 2026, Microsoft released Microsoft Agent Framework 1.0 into General Availability. The release came with an announcement that changed the decision calculus for every enterprise team building AI agents in the Microsoft ecosystem: AutoGen and Semantic Kernel were placed into maintenance mode simultaneously. Two frameworks that had collectively accumulated more than 75,000 GitHub stars, three years of enterprise field experience, and adoption across thousands of production deployments would receive no new features, no new orchestration patterns, and no future investment. Everything moved into a single unified successor.

This was not a minor SDK update. The consolidation resolved a real engineering problem that had persisted since both frameworks gained widespread adoption. AutoGen gave developers an expressive, flexible model for multi-agent conversation and orchestration experimentation. Semantic Kernel gave enterprise developers session-based state management, type safety, middleware filters, and first-class Azure integration. Neither framework delivered both things at once, so teams chose based on which limitation they could accept.

Microsoft Agent Framework 1.0 closes that gap. It delivers a unified SDK across Python and .NET with stable, long-term-supported APIs that merge AutoGen's agent programming model with Semantic Kernel's enterprise infrastructure. At Microsoft BUILD 2026 in early June, the team shipped four major additions on the 1.0 base: the Agent Harness for first-class production execution, CodeAct for cutting orchestration latency, Foundry Hosted Agents for managed cloud deployment, and the Agent Control Specification for portable governance. This guide covers how each of these components works, what specific problems they solve, and what enterprise AI practitioners need to evaluate before committing to MAF in production.

Why the AutoGen and Semantic Kernel Split Needed to End

AutoGen and Semantic Kernel were built by different teams with different design goals, and those differences made them incompatible at the architecture level. Understanding where each succeeded and where each created production friction explains the design decisions inside MAF 1.0.

AutoGen, released by Microsoft Research, was optimized for multi-agent conversation and orchestration experimentation. An AssistantAgent could be configured in a few lines of code. GroupChat and GroupChatManager let multiple agents coordinate through a shared conversation thread. The framework was expressive and fast to iterate on. Its production limitations were equally clear: observability hooks, durable session state, and human-in-the-loop approval flows were application-layer responsibilities requiring substantial custom engineering. The AutoGen v0.4 API rewrite also created a community split, with the v0.2 lineage continuing independently as AG2, introducing migration uncertainty for teams considering long-term commitment.

Semantic Kernel addressed exactly those gaps. It shipped first-class middleware pipelines, type-safe function definitions, kernel filters for content safety and compliance logging, and deep Azure AI service integration. The tradeoff was a heavier, less flexible programming model for multi-agent coordination. Its agent abstractions were less expressive than AutoGen's for orchestration scenarios where conversation dynamics drove routing decisions. Building a GroupChat-equivalent pattern in Semantic Kernel required substantially more engineering effort.

The AutoGen Semantic Kernel successor in MAF 1.0 is not simply a code merger. It places AutoGen's clean agent abstractions on top of Semantic Kernel's enterprise infrastructure layer, then extends both with graph-based workflow orchestration and a production execution layer that neither predecessor provided. Teams on either predecessor now have explicit migration guides with step-by-step API translations, and new projects have one clear path forward.

What Microsoft Agent Framework 1.0 Is and How It Is Structured

Microsoft Agent Framework 1.0 is an MIT-licensed, open-source SDK and runtime for building AI agents and multi-agent workflows across Python and .NET. The same concepts, the same API shapes, and the same execution semantics operate in both languages, which matters for enterprise teams maintaining mixed-language codebases. Organizations looking to build customized enterprise AI agents using frameworks like Microsoft Agent Framework require specialized AI development expertise to design, develop, integrate, and deploy production-ready AI systems. 

The Core Programming Model

Four primary abstractions define the MAF programming model.

• Chat clients provide a consistent interface to seven model providers, abstracting over Azure OpenAI, OpenAI, Anthropic Claude, Amazon Bedrock, Google Gemini, Ollama, and Microsoft Foundry. Swapping the underlying model provider requires a one-line configuration change, not a change to agent logic.

• Agents are stateful execution units that combine a chat client, a set of tools, a middleware pipeline, and instructions into an actor capable of autonomous reasoning and tool-based action. These are not prompt wrappers; they maintain session state and participate in multi-agent workflows as governed execution units. These intelligent systems often combine machine learning models with autonomous reasoning capabilities to improve decision-making, prediction, and automation. 

• Workflows are graph-based orchestration engines that compose agents and functions into deterministic, repeatable execution paths. They give developers explicit control over agent topology, which is the property that makes multi-agent systems auditable in regulated enterprise environments.

• Middleware hooks intercept agent behavior at every execution stage. Content safety filters, compliance audit logging, and custom business rules attach without modifying agent prompts or tool definitions.

The Stable Component Surface at 1.0

The 1.0 release commits these capabilities to stable, backward-compatible, long-term-supported APIs.

• Single agent and multi-agent orchestration abstractions are consistent across both .NET and Python runtimes, giving teams language flexibility without framework fragmentation.

• The Agent Harness production execution layer ships as stable, with context compaction, memory providers, and human-in-the-loop support available as built-in defaults rather than optional extras.

• The graph-based workflow engine supports sequential, concurrent, handoff, and group collaboration patterns, all stable at 1.0 and ready for production load.

• Native Model Context Protocol and Agent-to-Agent protocol support ships at 1.0, making both interoperability standards first-class rather than experimental extensions.

• OpenTelemetry distributed tracing flows automatically into Application Insights, covering every model call, every tool invocation, and every inter-agent transition.

The Agent Harness: Production Execution as First-Class Infrastructure

The Agent Harness is the most significant production addition in Microsoft Agent Framework 1.0 relative to both predecessors. It solves the question that every enterprise team eventually confronts after a working demo: what happens when an agent runs for hours, calls dozens of tools, needs persistent state across restarts, and must pause for human approval before taking a consequential action? Previous frameworks left all of these requirements to the application layer. The Harness makes them framework infrastructure.

Context Compaction and the Provider Architecture

Context compaction monitors token usage across long tool-calling chains and automatically compacts chat history mid-loop before the context window is exhausted. This is not a manual summarization step. It is an internal mechanism the Harness manages continuously, preserving the reasoning thread while reducing the active context to a safe operating window. The agent continues executing without interruption and without losing position in a complex task.

Providers extend the Harness with specific runtime capabilities. FileMemoryProvider gives agents persistent file-based memory across sessions, essential for long-running tasks where intermediate findings must survive process restarts. FileAccessProvider grants controlled filesystem access within declared path boundaries. TodoProvider enables structured task tracking across multi-step workflows, giving agents a mechanism to maintain a task list as they decompose and execute complex objectives. AgentSkillsProvider injects modular domain-specific capabilities at runtime from files, inline code, or packaged skill classes.

Approval Policies and Human-in-the-Loop Controls

The ToolApprovalAgent provides configurable approval policies for tool invocations. Developers specify which tool calls require human confirmation, which can be auto-approved via "don't ask again" rules based on prior approval history, and which are categorically blocked. For enterprise AI agent production deployment, this is a foundational control surface. Agents that can modify databases, send external communications, or initiate business processes need approval policies that are programmable, consistently enforced across all sessions, and fully auditable through a complete invocation log.

CodeAct and Hyperlight: Eliminating Orchestration Overhead

CodeAct, introduced as part of the Microsoft BUILD 2026 release, solves a concrete performance problem that emerges in any agent designed around sequential tool calling. It is the most architecturally novel feature shipped alongside the 1.0 base, and its performance characteristics are large enough to influence how teams should design agent task loops from the start.

In the standard tool-calling model, each invocation is a separate model inference turn. The model selects a tool, the framework executes it, the result is appended to the conversation, and the model generates the next response. For a task requiring twelve sequential tool calls, this means twelve complete roundtrips through the inference layer, an overhead that scales poorly as task complexity grows.

The Execution Model and Performance Characteristics

CodeAct addresses this directly. The model writes a short Python program that calls all required tools through a call_tool() interface and runs the entire program once in a sandbox. All tool results return in a single consolidated response. On representative multi-step workloads benchmarked by the MAF team, CodeAct achieves 52.4% latency reduction and 63.9% token savings compared to the traditional sequential tool-calling approach. For agentic pipelines running at enterprise scale, these figures translate directly into reduced per-task cost and faster response times for time-sensitive workflows.

What the Sandbox Does and Does Not Protect

CodeAct Hyperlight agent execution uses Microsoft's Hyperlight micro-VM technology to run model-generated code in a fresh, locally isolated VM per invocation. Hyperlight provides strong execution isolation at essentially zero overhead. The generated program cannot access host environment state beyond what the tool interfaces explicitly expose.

The architectural distinction enterprise teams must understand: the Hyperlight sandbox protects the host from unsafe model-generated code, but it does not automatically make the tools themselves safe. If a registered tool can update a database record, send an email, or trigger a deployment, the permission model for that tool must still be governed through the ToolApprovalAgent and middleware pipeline. CodeAct removes inference overhead. It does not replace tool-level authorization. Both layers are required in production systems, and confusing what each one protects creates security gaps in production environments.

Multi-Agent Workflow Orchestration Patterns in Microsoft Agent Framework 1.0

Multi-agent workflow orchestration is where MAF 1.0 most clearly extends beyond either predecessor. The framework ships four production-ready orchestration patterns through its graph-based workflow engine, each designed for a distinct class of problem.

Sequential workflows connect agents in a defined order where each agent's output becomes the next agent's input. This pattern suits tasks with a clear linear structure: a data retrieval agent gathers source material, an analysis agent processes it, and a formatting agent produces the deliverable. The topology is fixed, the execution path is deterministic, and developers control every stage explicitly. Enterprise AI workflows become more effective when supported by advanced analytics, predictive modelling, and data-driven insights delivered through modern data science solutions. 

Concurrent workflows run multiple agents simultaneously against independent subproblems and merge outputs at a joining step. This pattern is well-suited for scenarios like competitive intelligence gathering across multiple sources or parallel document processing across a large corpus, where wall-clock time reduction from parallelism matters operationally.

The Handoff Pattern: Developer-Controlled Topology with Agent-Driven Routing

The Handoff pattern is the most architecturally important orchestration model in Microsoft Agent Framework 1.0. The developer declares a set of agents and the directed edges permitted between them. The framework injects handoff tools into each agent based on the declared topology. The key design principle is the separation of topology from routing: developers define where routing is allowed at design time, and agents decide which permitted path to take at runtime based on the task state they observe. This separation provides the governance guardrails production systems require while preserving the runtime flexibility that makes multi-agent coordination useful for open-ended enterprise tasks.

Magentic-One and Group Collaboration

Magentic-One, Microsoft Research's architecture for complex autonomous task completion, ships as a stable built-in pattern in MAF 1.0. It pairs an orchestrator agent with specialized subagents for web browsing, file access, code execution, and terminal operations. Teams building research agents or document processing pipelines can instantiate it directly without rebuilding the orchestrator-plus-specialists pattern from scratch. Group collaboration, derived from AutoGen's GroupChat model, supports multiple agents exchanging messages in a shared thread with a manager agent selecting the next speaker, and suits tasks that benefit from iterative multi-perspective review before an action is approved.

From Local Prototype to Production: Foundry Hosted Agents

Getting from a working local agent to a reliably running production deployment has historically required significant infrastructure engineering outside the framework itself. Identity management, session state persistence, scaling configuration, and observability pipelines all needed separate engineering effort before an agent could serve real enterprise traffic.

Foundry Hosted Agents in Foundry Agent Service provides a direct deployment path that removes most of that work. The developer packages the MAF agent as a container, deploys it to Foundry-managed infrastructure, and inherits a production capability set without additional configuration plumbing.

Scale-to-zero behavior eliminates idle compute cost. When no requests are active, the agent instance scales to zero and incurs no charges. When the next request arrives, the agent starts within sub-100-millisecond cold start times with filesystem state intact, continuing exactly where it stopped.

Per-session VM isolation ensures separate user sessions operate in their own sandboxed environments with independent persistent state. Sessions cannot share or observe each other's execution context or filesystem, the isolation model required for multi-tenant enterprise deployments where data boundaries must be enforced at the infrastructure level.

The observability integration requires no additional configuration. MAF's OpenTelemetry traces, covering every model call, every tool invocation, every sub-agent hop, and every Handoff transition, flow automatically into Application Insights through the Foundry Control Plane. Tracing and evaluation for hosted agents reached General Availability in June 2026, completing the build-deploy-observe loop the platform targets.

Protocol Interoperability, Governance, and the Agent Control Specification

Microsoft Agent Framework 1.0 ships native support for both the Model Context Protocol and the Agent-to-Agent protocol. By mid-2026, MCP had crossed 200 server implementations. In MAF 1.0, any MCP server connects as a tool source without custom integration code. A Postgres database, a GitHub repository, a Jira project, or any MCP-compatible enterprise service becomes available to an MAF agent through a standardized configuration object. Tool additions do not require changes to agent logic, and when a tool's server is updated, the agent picks up the changes automatically through schema re-discovery.

A2A, now the standard for cross-framework inter-agent coordination under Linux Foundation governance, allows any Foundry-hosted MAF agent to be exposed as an A2A endpoint. Other agents built on LangGraph, CrewAI, or any A2A-compatible SDK can discover the MAF agent through its Agent Card and invoke it without sharing a runtime environment, making MAF viable as one component in a heterogeneous multi-vendor agent architecture.

The teams at KriraAI, which builds and deploys production AI systems for enterprise clients across financial services, healthcare, and operations-intensive industries, evaluate protocol support as a primary adoption criterion because native MCP and A2A means tool integrations and inter-agent collaborations built today remain portable as the ecosystem evolves, avoiding the migration costs that proprietary connector approaches create.

Governance in production agent systems operates at a different level than content filtering in conversational AI. MAF 1.0 addresses this through the middleware pipeline for execution-level policy enforcement, the ToolApprovalAgent for tool-level authorization and auditing, and the Agent Control Specification open-sourced at BUILD 2026. ACS is a portable, vendor-neutral specification for runtime agent governance that organizations can apply consistently across agents running on any framework, giving enterprises a unified compliance layer that is not limited to a single vendor's toolchain.

Practical Adoption: Who Should Build on MAF and When

Microsoft Agent Framework 1.0 is the right choice for a well-defined set of scenarios, and understanding which ones apply is more useful than evaluating it on feature count alone.

MAF 1.0 is the natural fit for teams already operating in the Azure ecosystem. Foundry hosting, Application Insights observability, and Microsoft Entra identity integration all provide direct operational value without additional infrastructure work. According to Gartner, 33% of enterprise software applications will include agentic AI by 2028, up from less than 1% in 2024.

It is also the clear migration path for teams currently running AutoGen or Semantic Kernel workloads. Both frameworks entered maintenance mode when MAF 1.0 went GA. Microsoft provides migration guides that map AutoGen's AssistantAgent to MAF's ChatAgent, translate Semantic Kernel's FunctionTool to the @ai_function decorator, and convert event-driven orchestration models to graph-based Workflow APIs. Continuing to build on either predecessor means accumulating technical debt against a codebase that will not receive new orchestration capabilities.

KriraAI evaluates every major framework release against three practical criteria: production observability depth out of the box, governance surface area for controlling agent actions in enterprise environments, and the engineering distance between a local prototype and a managed, monitored, scaled production deployment. On all three dimensions, Microsoft Agent Framework 1.0 is a measurable improvement over both of its predecessors. For Azure-connected enterprise organizations building production multi-agent systems, it is the strongest option currently available in that ecosystem.

Conclusion

Three conclusions from Microsoft Agent Framework 1.0 are worth carrying forward as durable takeaways. First, the framework demonstrates that consolidating fragmented agent infrastructure into a coherent, long-term-supported SDK creates compounding value: observability, governance, deployment, and orchestration share a common abstraction layer rather than requiring custom bridges between incompatible predecessors. Second, the Agent Harness, CodeAct, and Foundry Hosted Agents address the specific bottlenecks that prevent agent prototypes from becoming production systems, covering context overflow in long sessions, latency from sequential tool chains, and the infrastructure gap between local development and managed cloud deployment. Third, teams building multi-agent systems should base framework commitments on production maturity rather than research novelty, and MAF 1.0's stable APIs and long-term support commitment are a clear signal of readiness.

KriraAI builds and deploys production AI systems for enterprise clients across multiple industries and evaluates infrastructure at this layer carefully because the quality of agent execution infrastructure determines the reliability of every application built on top of it. KriraAI applies emerging frameworks when they are demonstrably ready for enterprise use. The April 2026 GA release and the June BUILD announcements together meet that bar for Microsoft-ecosystem organizations. If you are assessing what production-grade multi-agent AI should look like for your organization, KriraAI can help you navigate the architecture and framework decisions that will determine your outcomes.