Microsoft Agent Framework Hit 1.0 in April and Shipped Three Things at Build That Make Every Other Agent Framework Look Underbaked

Hey guys, Mr. Technology here.

For eighteen months the open-source agent framework market has been a parade of graph engines with attitude. LangGraph has a beautiful state machine. CrewAI has nice role-based abstractions. Atomic Agents has Pydantic discipline. None of them are what Microsoft just shipped.

On April 2, 2026, Microsoft Agent Framework (MAF) hit 1.0 GA and finally did the thing the community has been begging for since 2024: it absorbed AutoGen's multi-agent experimentation story and Semantic Kernel's enterprise plumbing into a single, MIT-licensed, Python-and-.NET SDK. Then on June 2 at Build 2026, the team shipped three features on top of that 1.0 foundation that, taken together, are the most ambitious thing any major framework has shipped this year.

Agent Harness is a production runtime layer any chat client can opt into with a single method. Foundry Hosted Agents deploys your local agent to a VM-isolated sandbox in two lines of code with scale-to-zero billing. CodeAct is a code-execution-as-tool pattern with sandboxed execution that finally treats the LLM as something an agent can give actual work to.

Why The Merge Was The Whole Ballgame

Building with Microsoft stack in 2024 and 2025 meant choosing between two incompatible worlds. Semantic Kernel had the enterprise plumbing — thread-based state, type safety, plugin architecture, content filtering, telemetry. The responsible choice. Also a pain to build a multi-agent demo in. AutoGen had the magic — group chat, debate, reflection, dynamic speaker selection. A research framework with no production story.

MAF 1.0 ends that fork. The same Agent class, the same Workflow class, the same ChatAgent interface exists in both agent_framework (PyPI) and Microsoft.Agents.AI (NuGet). AutoGen's group-chat manager and dynamic speaker selection are first-class Workflow nodes. Semantic Kernel's memory providers, prompt templates, function calling, content safety, and enterprise connectors are first-class agent features. There are migration guides for both predecessors — documented, supported, first-class concerns. Unprecedented from a hyperscaler.

What Agent Harness Actually Does

The thing every agent framework gets wrong is the gap between the agent's reasoning loop and the production runtime that runs it. Almost every framework treats the harness as a thing the user writes — the while True: llm.call(tools) loop, the tool dispatcher, the context compaction, the human-in-the-loop approval flow, the OpenTelemetry spans. Six months later you have a custom harness that does not match the one your colleague wrote.

Agent Harness ships these as default. From the June 3 Build 2026 devblog: automatic context compaction that watches token usage mid-loop; FileMemoryProvider / FileAccessProvider / TodoProvider for session-scoped memory, file IO, and work-item tracking; AgentModeProvider for plan-vs-execute separation; AgentSkillsProvider so a SKILL.md dropped in a folder is auto-discovered; ToolApprovalAgent middleware with "don't ask again" rules; OpenTelemetryAgent that emits GenAI semantic conventions without any instrumenting.

The whole thing is one method: chatClient.AsHarnessAgent(MaxContextWindowTokens, MaxOutputTokens, new HarnessAgentOptions { ... }) in C#, create_harness_agent(client=client, max_context_window_tokens=128_000, max_output_tokens=16_384, name=..., description=...) in Python. Defaults are good. Middleware is swappable. Storage is pluggable.

The other agent frameworks are still selling you a graph engine. MAF is selling you a production runtime. The graph engine is one piece. The harness is the rest.

Foundry Hosted Agents: Two Lines To Production

The answer to "I have a local agent — how do I run it for actual users without writing a deployment pipeline?"

csharp using Microsoft.Agents.AI.Foundry.Hosting; var builder = WebApplication.CreateBuilder(args); builder.Services.AddFoundryResponses(agent); var app = builder.Build(); app.MapFoundryResponses(); app.Run();

Scale to zero, per-session VM-isolated sandbox, filesystem persists across scale-to-zero, OpenTelemetry traces flow into Application Insights. The free tier runs through the end of 2026, no per-seat cap. This is a deliberate land grab.

LangGraph Cloud is in limited access. CrewAI's deployment story is "bring your own Docker." Agno has AgentOS but it is a control plane you still operate. MAF gives you a managed control plane backed by Azure, billed by the second, free through January 1, 2027. That is the deployment story every other framework is going to be compared against for the next 18 months.

CodeAct: The LLM As A Programmer

The third and most interesting Build 2026 announcement is CodeAct. Most frameworks treat tools as discrete functions: the model emits a tool_call, the framework dispatches, the function returns a value, the model incorporates, repeat. It works. It also leaves a huge amount of model capability on the floor.

CodeAct flips it. The agent writes code, executes it in a sandbox, observes the result, and iterates. The code can call multiple tools, chain them, branch on results, retry on failure, do arithmetic, parse structured data, transform inputs — all in a single tool call. The model is not picking from a menu. The model is programming.

The technical core is Hyperlight, a WebAssembly-based microVM with sub-millisecond cold start and sandboxed execution. Skywork's analysis pegs Hyperlight + CodeAct at roughly 52% lower latency for multi-tool workflows. Function-calling has the model emit JSON, parse JSON, dispatch, run, format, read, decide — each step a model round-trip. CodeAct collapses the multi-step function-calling into a single code execution, with the model round-trip only at the boundaries where it is actually needed.

This is the architectural shift I have been waiting for. Function-calling is a 2023 abstraction. The 2026 model is good enough to write the orchestration code itself. The framework should run that code safely, not parse JSON-shaped tool calls. MAF is the first major framework to bet on this, and the bet is the right one.

The provider breadth is the quiet win on top: the README lists Foundry, Azure OpenAI, OpenAI, Anthropic, the GitHub Copilot SDK, Ollama, and more — the broadest of any major framework. Prototype with GPT-4.1, swap to Claude Opus 4.8 for production, fall back to a local Ollama instance for offline work, and the agent code does not change.

The Take

The agent framework market has had the same shape for eighteen months: graph engine, tool dispatcher, prompt loop, and a state machine dressed up as an "autonomous agent." The frameworks competed on whose graph engine had the cleanest API. None of them competed on the runtime — the part of the stack that runs the agent in production, with persistence, observability, context management, human-in-the-loop, tool approval, and the boring enterprise plumbing that determines whether the agent actually ships.

Microsoft Agent Framework is the first major framework to compete on the runtime. Agent Harness ships the boring plumbing as defaults. Foundry Hosted Agents ships the deployment story. CodeAct ships the right abstraction for what a 2026 model can actually do. The merger ships the multi-agent and enterprise stories in the same SDK. The MIT license ships the open-source story.

For the team shipping an agent to actual users in the second half of 2026, that wants one framework for prototyping and production, that does not want to write a custom harness, that wants to deploy without writing a Dockerfile, and that wants to swap model vendors without rewriting agent code — Microsoft Agent Framework is the only major framework in 2026 that ships all of this in a single MIT-licensed SDK.

The boring enterprise choice just became the most ambitious one. Most of the coverage has missed why. You have not.

— Mr. Technology

*Microsoft Agent Framework: github.com/microsoft/agent-framework — v1.0 GA (April 2, 2026), Build 2026 feature wave (June 3, 2026), MIT-licensed, Python and .NET with full parity. Python: pip install agent-framework. .NET: dotnet add package Microsoft.Agents.AI. Foundry integration: Microsoft.Agents.AI.Foundry (NuGet) or agent_framework.foundry (PyPI). Docs: learn.microsoft.com/agent-framework. Migration guides: from Semantic Kernel, from AutoGen. Build 2026 announcements: Microsoft Agent Framework at Build 2026. Hosted Agents: From Local to Production with Foundry Hosted Agents. AF Labs (experimental): reinforcement learning, benchmarking, research initiatives. AF Skills: discovery + execution from the file system. AF Workflows: graph-based sequential, concurrent, handoff, and group collaboration patterns with checkpointing, streaming, human-in-the-loop, and time-travel.*