On August 3, 2026, the Microsoft Agent Framework Harness and Foundry Hosted Agents both reached general availability. The headline isn't a new SDK feature — it's that Microsoft is now selling a governed runtime for running agents, not just a library for building them. For platform teams that means a supported production host with per-session isolation and a billing model that charges you nothing while an agent is idle.
The August GA That Turned a Library Into a Runtime
The Agent Framework is the October 2025 convergence of Semantic Kernel and AutoGen under a single repo (github.com/microsoft/agent-framework), with both predecessors moved to maintenance mode. The track since then: February 2026 release candidate with migration guides, April 2, 2026 1.0 GA with the .NET and Python SDKs, June 2–3 Build 2026 promoting the harness, hosted agents, CodeAct and orchestration patterns to stable, and now the August 3 GA of the harness plus the managed hosting layer.
The distinction matters. A model on its own just emits text; the harness is the execution loop around it — tool routing, history persistence, context compaction, error recovery. Before this GA, teams building on Microsoft's stack reimplemented that loop themselves. Now it ships as a configurable default.
What the Harness Hands You by Default
Enabled out of the box, each individually removable: function invocation, history persistence, context compaction, a todo list (plan-and-execute with checkpointing), file memory, skills, a Bing-backed web search tool, tool approval for human-in-the-loop gating, and OpenTelemetry tracing/metrics/logging. Shell tooling, filesystem access, and background sub-agents are opt-in with a warning. You get all of that through one 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=[],
)
response = await agent.run("Research the outlook for renewable energy stocks.")
Why the harness is the real product: an April 2026 analysis from MBZUAI's VILA-Lab ("Dive into Claude Code", arXiv:2604.14228) classified ~512,000 lines of Claude Code and found ~98.4% is harness infrastructure — permissions, context management, sandboxing, tool routing, recovery — and ~1.6% is AI decision logic. The authors flag that the leak-derived bundle includes generated and minified code, so take the ratio with salt. But the direction matches Codex CLI and Aider. When you build an agent, you're mostly building the harness — a supported one removes most of that work.
CodeAct: One Program, Many Tools, Per-Call Isolation
Standard agent tool calling is sequential: pick a tool, wait, pick the next. CodeAct flips it — the model writes a short Python program that calls multiple tools via call_tool(...), runs the whole thing in a sandbox, and returns one consolidated result. Per Microsoft's benchmarks, that's roughly 50% lower end-to-end latency and ~60% fewer tokens versus standard tool calling.
The safety story is what makes it production-viable. CodeAct ships in the agent-framework-hyperlight package (alpha), running each generated program in a fresh Hyperlight micro-VM per call — strong isolation at the granularity of a single tool call. Linux and Windows at launch, macOS on the roadmap. The caveat Microsoft's own docs stress: sandboxing protects the host from generated code, not your tools from themselves. If a tool can send email, delete files, or trigger a deployment, you still need tool-level permissions and approval policies on top.
The Managed Layer: Scale-to-Zero and the Price Tag
Foundry Hosted Agents follows the "Build in GitHub, Run in Foundry, Reach users across Microsoft 365" model. Each logical session gets its own VM-isolated sandbox with hypervisor-level per-session isolation, in sizes from 0.25 to 2 vCPU and 0.5 to 4 GiB RAM. Agents scale to zero with no cost while idle and resume with filesystem intact — session identity and files survive the scale-down.
Consumption billing began April 22, 2026:
| Resource | Price |
|---|---|
| Compute (vCPU) | $0.0994 / vCPU-hour |
| Memory (GiB) | $0.0118 / GiB-hour |
| Short-term memory | $0.25 / 1K events stored |
| Long-term memory | $0.25 / 1K memories / month |
| Memory retrieval | $0.50 / 1K retrievals |
Inference is billed separately through Azure OpenAI or a third-party provider. The docs note the real cost trap: oversizing your sandbox multiplies cost by your concurrency, since you pay for CPU + memory across all active sessions.
All five orchestration patterns — sequential, concurrent, handoff, group chat, and Magentic (the Magentic-One orchestrator pattern) — share one API surface, so teams switch coordination style without rewriting agent code. The same governance story applies to the GitHub Copilot SDK and Claude Agent SDK connectors: delegated coding agents land in the same OpenTelemetry traces and Foundry dashboards as the rest of the fleet.
Migration Path Out of Semantic Kernel and AutoGen
Semantic Kernel and AutoGen projects have a documented forward path — migration guides landed with the February 2026 RC. If you have production agents on either, the question is no longer whether Microsoft's stack is production-ready, but whether you want to run your own harness or let Foundry's consumption-billed, scale-to-zero runtime pay for itself only when agents are actually working.
Sources: