Microsoft Agent Framework Harness & Hosted Agents GA: The Complete Guide for Agentic AI Architects (2026)

On August 3, 2026, Microsoft quietly crossed a line that changes how enterprise teams ship AI agents. The Agent Framework Harness and Foundry Hosted Agents both reached general availability — and the significance isn’t about a new SDK feature. It’s about a shift in what Microsoft is actually selling: not a library for building agents, but a governed platform for running them. If you’ve been watching the agentic AI space from the RPA side — especially if you’re navigating the RPA to agentic AI transition — this is the moment Microsoft’s agent story stopped being a developer preview and started being infrastructure.

Here’s why that matters to you, and what you need to know to evaluate it against the rest of the stack.

The Timeline: From Open-Source Merge to Production Runtime

The Agent Framework didn’t appear from nowhere. It’s the production-ready convergence of two projects that Microsoft Research had been running in parallel: Semantic Kernel (the .NET-first orchestration SDK) and AutoGen (the Python-first multi-agent research framework). In October 2025, Microsoft merged them under a single open-source umbrella — the Microsoft Agent Framework.

The key milestones since then:

That August GA announcement is what we’re unpacking here. It’s the moment the framework moved past “here’s a library, figure out the rest” and into “here’s the runtime, the hosting, and the governance layer.”

What the Agent Harness Actually Is (and Why It Matters More Than You Think)

A model on its own generates text. To make it call tools, work through multi-step tasks, recover from errors, and persist state across turns, you need a runtime that wraps the model in an execution loop. That runtime is the harness.

Before this GA, every enterprise team building agents on Microsoft’s stack was essentially rebuilding this harness from scratch — tool routing, history persistence, context window management, approval workflows, observability hooks. The Agent Framework Harness ships all of this as a supported, configurable default.

What Ships Out of the Box

The harness includes the following capabilities, each enabled by default and individually removable:

More Read

Gemini 3.6 Flash for Agent Builders: Complete Guide

RPA to Agentic AI: The Complete Transition Guide for Automation Professionals (2026)

Ensuring RPA Security: Best Practices and Guidelines

The developer experience is deliberately minimal. You supply a chat client, instructions, and tools; the harness handles everything else through a single call:

from agent_framework import create_harness_agent
from agent_framework.clients import FoundryChatClient
from azure.identity import AzureCliCredential

client = FoundryChatClient(credential=AzureCliCredential())

agent = create_harness_agent(
    client=client,
    agent_instructions="You are a research assistant. Plan your work, then execute it.",
    tools=[],  # add your own callable tools here
)

response = await agent.run("Research the outlook for renewable energy stocks.")

The 98/2 Rule: Why the Harness Is Most of the System

If you think the harness sounds like “just plumbing,” consider a number from a peer-reviewed analysis. In April 2026, researchers from MBZUAI’s VILA-Lab published “Dive into Claude Code,” a study that classified roughly 512,000 lines of code from Anthropic’s Claude Code agent. Their finding: approximately 98.4% of the codebase is harness infrastructure — permissions, context management, sandboxing, tool routing, and recovery — and only about 1.6% is the AI decision logic itself.

The authors are careful to note caveats: the analysis was performed on a leak-derived bundle that includes generated and minified code, so the exact ratio should be taken with a grain of salt. But the directional insight is corroborated by independent analysis of other coding agents (Codex CLI, Aider), which all converged on the same harness-heavy architecture. The implication: when you build an agent, you’re mostly building the harness, not the AI. A supported, production-grade harness eliminates the majority of that engineering effort.

CodeAct: Collapsing Multi-Step Tool Calls into a Single Execution

Standard agentic tool calling follows a slow, sequential pattern: the model selects a tool, waits for the result, selects the next tool, waits again. Each round trip burns latency and tokens. CodeAct takes a fundamentally different approach.

Instead of one-tool-at-a-time selection, CodeAct has the model write a short Python program that calls multiple tools via call_tool(…), runs the entire program in a sandbox, and returns a consolidated result. One model turn, one execution, multiple tool calls resolved.

The measured impact, per Microsoft’s benchmarks:

Hyperlight: Micro-VM Isolation at the Granularity of a Single Call

The safety story is what makes CodeAct production-viable rather than a research curiosity. CodeAct ships in the agent-framework-hyperlight package (currently alpha), which runs the model-generated Python code in a fresh Hyperlight micro-VM per call. Hyperlight is a lightweight hypervisor runtime designed for very small, very fast, strongly isolated guests — so strong isolation is essentially free at the granularity of a single tool call.

A critical caveat that Microsoft’s own docs emphasize: CodeAct sandboxing protects the host from unsafe generated code, but it does not automatically make your tools safe. If your tool can send an email, delete a file, approve a refund, or trigger a deployment, you still need tool-level permissions, approval policies, and auditability. The harness’s built-in tool approval system handles the second concern; Hyperlight handles the first.

Platform support at launch: Linux and Windows. macOS is on the roadmap.

Foundry Hosted Agents: The Managed Deployment Target

Building an agent locally is one problem. Running it in production — with identity, scaling, session isolation, and billing — is a different problem entirely. Foundry Hosted Agents is Microsoft’s managed answer.

Architecture

The deployment model follows a three-layer pattern that Microsoft calls “Build in GitHub, Run in Foundry, Reach users across Microsoft 365”:

• Build layer: Code is developed locally or in GitHub, using the Agent Framework SDK in .NET or Python.
• Run layer: The agent is packaged as a container and deployed onto Foundry-managed infrastructure, with built-in identity (Entra ID), automatic scaling, managed session state, observability, and versioning.
• Reach layer: Agents surface in Microsoft 365 Copilot, Teams, and other M365 surfaces.

Session Isolation and Scale-to-Zero

Each logical agent session gets its own VM-isolated sandbox with hypervisor-level per-session isolation. The key feature for cost management: agents scale to zero with no cost while idle, and resume with filesystem intact. Files and session identity persist across scale-to-zero events, so an agent can pick up exactly where it left off when a user returns.

Sandbox sizes are configurable from 0.25 to 2 vCPU and 0.5 to 4 GiB RAM.

Pricing

Foundry Hosted Agents uses consumption-based billing (billing began April 22, 2026):

Model inference is billed separately through your Azure OpenAI or third-party model provider. A practical note from the docs: oversizing your sandbox multiplies cost by your concurrency, since billing is based on CPU + memory consumed across all active sessions.

Multi-Agent Orchestration: Five Patterns, One API

The orchestration patterns that reached stable release alongside the harness cover the major coordination styles enterprise teams need. All five share a single API surface, so teams can switch coordination styles without rewriting agent code.

Pattern 1: Sequential

Agents execute in a defined order, each passing its output to the next. The classic pipeline: data extraction → validation → enrichment → report generation.

Pattern 2: Concurrent

Multiple agents execute in parallel, with results aggregated at the end. Useful for research tasks where multiple sources need to be queried simultaneously.

Pattern 3: Handoff

An agent recognizes it’s not the right specialist for a sub-task and transfers control to a more appropriate agent, along with shared context. This is the pattern closest to how RPA orchestrators handle queue-based routing.

Pattern 4: Group Chat

Multiple agents collaborate in a shared conversation, debating and building on each other’s contributions. Useful for code review, design critique, and complex analysis where multiple perspectives improve quality.

Pattern 5: Magentic

Derived from Microsoft Research’s Magentic-One system, this is the most sophisticated pattern. A dedicated Orchestrator agent coordinates a team of specialists, dynamically selecting which agent should act next based on evolving context and task progress. The Orchestrator maintains shared context, tracks progress, and re-plans to recover from errors.

Magentic-One’s 2024 evaluation benchmarks, which Microsoft self-reported: 38% on GAIA, 27.7% on AssistantBench, and 32.8% on WebArena — statistically comparable to the state of the art on the first two and competitive on WebArena.

Coding-Agent Connectors: GitHub Copilot SDK and Claude Agent SDK

One of the most underreported features of the Build 2026 announcements is the coding-agent connectors. An Agent Framework orchestration can now delegate to the GitHub Copilot SDK or the Claude Agent SDK without custom adapters. Each connector runs its own autonomous loop (planning, tool execution, file edits, session management), wrapped so a coding agent composes alongside Azure OpenAI, Anthropic, or custom agents in one multi-agent workflow.

Why this matters for enterprise teams: the connectors honor the identity, content safety, and observability policies already configured for the agent fleet. Coding-agent traffic lands in the same OpenTelemetry traces and Foundry dashboards as everything else, rather than becoming a separate integration with its own access model.

This is the same governance concern visible in AWS’s Loom reference platform and in the broader AI agent control planes movement: the controlling question shifts from what an agent can do to who ran it, under which policy, and where the trace lands.

Migration: What Happens to Semantic Kernel and AutoGen Projects?

If you have existing Semantic Kernel or AutoGen agents in production, here’s the current state:

For Semantic Kernel teams: The main change is moving away from Kernel-centered construction toward agent and chat-client APIs built on Microsoft.Extensions.AI (or the Python agent_framework package). Your existing SK plugins remain compatible — Agent Framework is built on top of SK’s plugin and kernel infrastructure.

For AutoGen teams: The bigger shift is orchestration style, moving from event-driven multi-agent patterns toward a more typed, graph-based workflow model that is easier to reason about, govern, and resume in production.

How This Compares to Other Enterprise Agent Platforms

Microsoft isn’t the only vendor shipping a governed agent runtime in 2026. AWS recently completed its own Bedrock Agents Classic sunset and migration to AgentCore, and Google launched Gemini 3.6 Flash with agent-builder tooling. Here’s how the landscape looks for practitioners evaluating their options (for a deeper multi-framework comparison, see our LangGraph vs. CrewAI vs. Microsoft Agent Framework vs. Google ADK breakdown):

Microsoft’s differentiator is the three-layer integration: the same agent runs locally during development, in a container during testing, and on Foundry-managed infrastructure in production — with the same binary, the same policies, and the same traces. Most competitors require separate configuration or even separate SDKs for local vs. cloud execution.

What This Means for RPA and Automation Architects

If you’re coming from the RPA world — UiPath, Automation Anywhere, Power Automate — here’s the practical translation:

The harness is the new orchestrator. In RPA, the orchestrator (UiPath Orchestrator, AA Control Room) manages execution, queueing, retries, and governance. The Agent Framework Harness fills that role for AI agents: it manages execution loops, tool routing, approval workflows, and observability. The mental model transfers directly.

Foundry Hosted Agents is the new unattended robot fleet. Scale-to-zero with stateful resume is functionally equivalent to having unattended robots that spin up on demand, execute their tasks, and release their license when idle — except the “license” is now consumption-billed compute at $0.0994/vCPU-hour instead of a fixed per-bot annual fee.

Multi-agent orchestration is the new process designer. The five orchestration patterns (sequential, concurrent, handoff, group, magentic) map to workflow patterns that automation architects already think in. The handoff pattern in particular mirrors RPA queue-based routing, where a dispatcher assigns work items to specialized workers based on type.

For teams already in the Microsoft ecosystem — running Power Automate flows, using Copilot Studio, or building on Azure — the Agent Framework provides a natural on-ramp to agentic AI without abandoning existing investments. The Copilot Studio integration means low-code agent builders and pro-code Agent Framework agents can coexist in the same governance model.

Getting Started: A Practical Checklist

If you want to evaluate the Agent Framework Harness for your team, here’s a concrete starting path:

1. Install the SDK: pip install agent-framework (Python) or the NuGet package for .NET. The GitHub repo has working samples for both languages.
2. Run the harness sample locally: The dotnet/samples/02-agents/Harness directory contains a complete working example. No Azure account required for local execution.
3. Try CodeAct: Install agent-framework-hyperlight (alpha). Test with a multi-tool task to see the latency/token reduction firsthand. Linux or Windows required.
4. Evaluate orchestration patterns: Start with sequential (simplest mental model), then try handoff (most useful for RPA-like routing).
5. Deploy to Foundry: When ready for managed hosting, containerize your agent and deploy to Foundry Agent Service. Start with the smallest sandbox (0.25 vCPU / 0.5 GiB) and scale up based on actual workload profiling.
6. Connect observability: The built-in OpenTelemetry integration means traces flow to whatever collector you already use — Jaeger, Azure Monitor, Datadog, or Grafana.

FAQs

What is the Microsoft Agent Framework Harness?

The Agent Framework Harness is a production runtime that wraps AI models in an execution loop with built-in tool routing, history persistence, context management, approval workflows, and OpenTelemetry observability. It ships as part of Microsoft Agent Framework and eliminates the need for teams to build their own agent runtime infrastructure.

How does CodeAct reduce agent latency?

CodeAct has the model write a single Python program that calls multiple tools in one execution, rather than selecting and waiting for tools one at a time. This collapses multi-step plans into a single executable block, cutting end-to-end latency by approximately 50% and token usage by over 60% in representative workloads, while running in a Hyperlight micro-VM for isolation.

What happens to my existing Semantic Kernel or AutoGen projects?

Semantic Kernel agent abstractions will receive critical bug fixes for at least one year after Agent Framework GA. AutoGen has entered maintenance-only mode with no new features. Microsoft provides migration guides for both. New projects should start on Agent Framework.

How much does Foundry Hosted Agents cost?

Foundry Hosted Agents uses consumption-based pricing: $0.0994 per vCPU-hour for compute and $0.0118 per GiB-hour for memory. Agents scale to zero when idle, so there’s no cost when agents aren’t actively processing. Model inference is billed separately through your model provider.

Can I use non-Microsoft models with the Agent Framework?

Yes. Agent Framework supports multi-provider model access. You can use Azure OpenAI, Anthropic (via the Claude Agent SDK connector), and other providers. The framework’s chat client abstraction decouples agent logic from model provider. The framework also supports MCP (Model Context Protocol) for standardized tool connectivity.

Key Takeaways

• Microsoft Agent Framework Harness and Foundry Hosted Agents reached GA in August 2026, marking the shift from an SDK for building agents to a governed platform for running them.
• The harness provides a production-grade runtime with tool routing, history persistence, context compaction, approval workflows, and OpenTelemetry — capabilities that represent roughly 98% of a typical agent codebase.
• CodeAct collapses multi-step tool calls into a single Python execution, cutting latency by ~50% and tokens by ~60%, with Hyperlight micro-VM isolation.
• Foundry Hosted Agents offers scale-to-zero managed hosting at $0.0994/vCPU-hour — consumption-billed, with hypervisor-level session isolation.
• Five multi-agent orchestration patterns (sequential, concurrent, handoff, group, magentic) share one API, so teams change coordination styles without rewriting agent code.
• Coding-agent connectors for GitHub Copilot SDK and Claude Agent SDK let coding agents participate in governed multi-agent workflows alongside other agent types.
• Semantic Kernel gets at least one year of bug-fix support; AutoGen is maintenance-only. All new agent work should start on Agent Framework.
• For RPA architects: the harness maps to the orchestrator, Hosted Agents maps to unattended robot fleets, and multi-agent patterns map to workflow designs you already use.

References

1. Microsoft Agent Framework Harness and Hosted Agents Reach General Availability — InfoQ, August 3, 2026
2. Microsoft Agent Framework at BUILD 2026: Agent Harness, Hosted Agents, CodeAct, and more — Microsoft DevBlog
3. Microsoft Agent Framework Version 1.0 — Microsoft DevBlog, April 2, 2026
4. CodeAct in Agent Framework: Faster Agents with Fewer Model Turns — Microsoft DevBlog
5. Build and run agents at scale with Microsoft Foundry at Build 2026 — Microsoft Foundry Blog
6. Microsoft Agent Framework Overview — Microsoft Learn
7. Hosted Agents in Foundry Agent Service — Microsoft Learn
8. Dive into Claude Code — MBZUAI VILA-Lab, arXiv, April 2026
9. Foundry Agent Service Pricing — Microsoft Azure
10. Migrate your Semantic Kernel and AutoGen Projects to Microsoft Agent Framework — Microsoft DevBlog
11. Magentic-One: A Generalist Multi-Agent System — Microsoft Research