For two years the question about Microsoft's agent tooling was which one: AutoGen, the research-flavored multi-agent library, or Semantic Kernel, the enterprise SDK. In April that question ended the only way it could — Microsoft deprecated both and merged them into Agent Framework 1.0, one supported SDK and runtime with the same concepts across .NET and Python. So the interesting thing about what shipped at Build 2026 is not that there is a new framework. It is that none of the three headline launches is a framework at all. All of them sit below the orchestration layer Microsoft spent two years competing on.
The harness, as a product#
The first launch is an Agent Harness. The name is not Microsoft's coinage — the field has spent the spring naming the harness as the deterministic code wrapped around an unreliable model: the loop, the tool validation, the retries, the traces. What Microsoft did is turn that pattern into a supported surface. The Agent Harness gives a model shell and filesystem access, human-in-the-loop approval flows, and context management across long-running sessions, and it makes the unglamorous production patterns first-class — context compaction, instruction merging, todo tracking, pluggable providers.
That list is the giveaway. Two years ago an agent library's value proposition was we tell the model what to do next. The pieces Microsoft is now selling all assume the model already knows what to do next, and concern themselves with the restraints around it — the same shift from framework to harness the rest of the ecosystem has been making, but shipped by a hyperscaler with a support contract attached.
A home that scales to zero without forgetting#
The second launch answers the question every harness eventually raises: where does this thing actually run? Hosted Agents in Foundry Agent Service take your own code, package it as a container, and deploy it onto managed infrastructure with identity, automatic scaling, managed session state, observability, and versioning baked in.
The detail worth stopping on is the scaling behavior. A Hosted Agent scales to zero — idle, it costs nothing — and then, on the next request, it resumes with its filesystem intact. Files, disk state, and session identity persist across the scale-to-zero boundary, so the agent restarts exactly where it left off. That is a genuinely awkward primitive to find, and it is the one most agent deployments are missing. Stateless serverless gives you scale-to-zero but throws away the disk; durable-execution engines preserve state by replaying your logic deterministically, which constrains how you write it. Hosted Agents take a third path: keep the literal disk and session across a cold start, no replay required. It is closer to pausing a sandbox than to checkpointing a graph — and it is the kind of thing only the party that owns the cloud can ship cheaply.
CodeAct quietly retires the tool-call loop#
The third launch is the one with consequences past Microsoft's stack. CodeAct changes how an agent executes tools. The default model of the last two years is a tool-call loop: the model emits one tool call, waits for the result, reasons, emits the next, waits again — every step a full round-trip through the model, every intermediate result spent back into the context window. CodeAct collapses that. Instead of choosing tools one at a time, the model writes a single short Python program that calls each tool via call_tool(...), runs the whole thing once in a sandbox, and gets back a consolidated result.
Microsoft's numbers for the change are large enough to be the headline: roughly 50% lower end-to-end latency and more than 60% fewer tokens on representative workloads, without giving up isolation. Those gains are not a Microsoft trick. They are the same arithmetic behind the broader move toward code execution over direct tool calls — when a plan has six steps, expressing it as one program instead of six round-trips removes five trips through the most expensive component you own. What Build 2026 marks is that pattern arriving as a first-class, supported execution mode inside a major framework rather than a clever thing you wire up yourself.
What the three have in common#
Read together, the launches describe a single bet. The framework — the part that orchestrates, that picks the next step — is treated as solved enough to stop selling. The new product is everything underneath it: the harness that holds the model's hands, the runtime that gives the agent a cheap persistent home, and an execution mode that changes the unit of work from one tool call per turn to one program per task.
It is worth being precise about who this serves. Hosted Agents and the Foundry plumbing are a bet on Azure; the harness and CodeAct are open in the framework and portable in principle. If you are choosing a stack today, the honest read is the same as it was for the framework comparison: the orchestration layer is increasingly a commodity, and the question that actually decides your bill and your blast radius is where the agent runs and how it executes its tools. Microsoft just shipped strong answers to both — and bolted them to its cloud.
