Microsoft Agent Framework 1.0 and Foundry Agent Service: The Complete Guide for Agentic AI Architects (2026)

Standing up an AI agent prototype takes an afternoon. Getting it to survive inside an enterprise workflow — with session isolation, durable state, real-time observability, and governed tool access — takes months of custom engineering. That gap between demo and production is exactly where most agent projects stall. According to a 2025 Gartner estimate, fewer than 30% of enterprise AI agent pilots reach production within twelve months of inception.

Microsoft’s answer is a vertically integrated agentic AI stack that shipped across the first half of 2026: Microsoft Agent Framework 1.0 (the open-source SDK that merged AutoGen and Semantic Kernel into one production-grade runtime), Foundry Agent Service (the managed cloud runtime with session-isolated sandboxes and zero-idle-cost autoscaling), Foundry IQ (a knowledge layer that replaces hand-built RAG pipelines with 54% better recall), and Toolboxes in Foundry (a single MCP-compliant endpoint for every tool an agent needs). Together with Copilot Studio’s multi-agent orchestration reaching general availability in August 2026, Microsoft now offers the most complete build-deploy-operate platform for agentic AI in the enterprise market.

This guide walks through the entire stack — architecture, orchestration patterns, production deployment, observability, and certification — so you can evaluate whether it fits your automation roadmap and start building if it does.

Why Microsoft Merged AutoGen and Semantic Kernel

Until early 2026, Microsoft maintained two separate agent frameworks with overlapping ambitions. Semantic Kernel, born inside the Microsoft 365 Copilot team, provided enterprise-grade plumbing: type-safe connectors, telemetry, filters, and a deep plugin ecosystem. AutoGen, a Microsoft Research project, pioneered multi-agent orchestration patterns — group chat, handoff, and the Magentic-One system for open-ended collaborative problem-solving. Developers building production agents frequently needed both, stitching them together with glue code that neither team officially supported.

On April 3, 2026, Microsoft shipped Microsoft Agent Framework 1.0 for both .NET and Python. The release unified Semantic Kernel’s enterprise foundations — session-based state, type safety, middleware pipeline, full connector ecosystem — with AutoGen’s multi-agent orchestration, under a single Microsoft.Agents.AI namespace. This wasn’t a rename. The internal architecture was refactored so that Semantic Kernel serves as the foundation layer, with AutoGen’s graph-based multi-agent orchestration built on top.

The practical consequence for teams already invested in either framework: existing Semantic Kernel plugins and connectors carry forward directly. AutoGen orchestration patterns (sequential, concurrent, handoff, group chat, Magentic-One) are now stable and supported under the same API. You no longer need to choose between enterprise plumbing and multi-agent flexibility — they ship as one package.

Architecture: What Ships in Agent Framework 1.0

Agent Framework 1.0 is organized around five core abstractions that mirror how production agents actually operate:

Multi-Model, Multi-Protocol by Default

Agent Framework 1.0 ships with first-party connectors for six model providers — Azure OpenAI, OpenAI, Anthropic Claude, Amazon Bedrock, Google Gemini, and Ollama — swappable with a single configuration line. This isn’t just about model flexibility; it’s about cost optimization. A production agent might use GPT-4.1 for complex reasoning steps, Claude Haiku for classification, and a local Ollama model for PII detection — all within the same workflow, all managed by the same harness.

More Read

🔒UiPath AI Trust Layer: A New Era of Responsible AI-Powered Automation

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

IBM watsonx Orchestrate Agentic Control Plane: The Complete Guide for Agentic AI Architects

Two interoperability protocols are native at 1.0, not bolt-on additions:

• Model Context Protocol (MCP) — agents dynamically discover and invoke external tools exposed over MCP-compliant servers. If you’ve already built MCP servers for your organization’s tools, Agent Framework connects to them without wrapper code.
• Agent-to-Agent (A2A) — agents register as each other’s tools, enabling cross-framework and cross-organization collaboration. A LangGraph agent running on AWS can invoke a Microsoft Agent Framework agent running on Azure via A2A, and vice versa, through natural language delegation.

Procedural Memory: Agents That Learn How to Work

The most architecturally significant addition in 1.0 is procedural memory (public preview). User memory remembers facts (“this user prefers metric units”). Session memory maintains conversation context. Procedural memory is different: it captures how the agent performed a task and applies that learned procedure to future runs. Microsoft’s Tau-bench evaluations show +7–14% absolute success-rate gains at near-baseline cost when procedural memory is enabled.

The practical scenario: a PR-review agent is coached once — “check test coverage first, then flag new dependencies, then look for breaking API changes.” Weeks later, on an entirely different pull request, the agent runs the same sequence autonomously. This is closer to how human experts actually develop work patterns, and it’s a meaningful step beyond the stateless agent architectures that dominate most frameworks today. For teams building agents that handle memory and retrieval-augmented generation, procedural memory adds a third dimension beyond what RAG alone provides.

Multi-Agent Orchestration: Five Patterns, One API

Agent Framework 1.0 ships five stable orchestration patterns. Each supports streaming, checkpointing, human-in-the-loop approvals, and pause/resume for long-running workflows. Choosing the right pattern is the most consequential architectural decision you’ll make — it determines latency, cost, and failure modes.

Magentic-One deserves special attention. Developed by Microsoft Research as part of the AutoGen project, it reached stable release in Agent Framework 1.0. Unlike the other four patterns, Magentic-One doesn’t follow a fixed flow. The manager agent maintains a ledger of what each specialist can do, what’s been tried, and what failed, then dynamically reassigns work. This makes it the right choice for tasks where you genuinely don’t know the optimal sequence upfront — complex document processing, multi-system investigations, or research tasks that require pivoting strategies mid-execution.

Foundry Agent Service: The Production Runtime

Agent Framework gives you the SDK. Foundry Agent Service gives you the runtime. It’s the managed cloud environment where your agents actually execute in production, reaching general availability in mid-2026.

Session-Isolated Sandboxes

Every agent session runs in its own sandbox with dedicated compute, memory, and filesystem. This isn’t container-level isolation — it’s session-level, meaning two concurrent users of the same agent get completely separate execution environments. The runtime handles autoscaling with zero idle cost: when no sessions are active, you’re not paying for dormant infrastructure.

Framework-Agnostic Deployment

Foundry Agent Service doesn’t lock you into Microsoft Agent Framework. Agents built with LangGraph, GitHub Copilot SDK, Claude Agent SDK, or any other framework can be deployed without rewrites. Two protocols are supported: the Responses API for OpenAI-compatible stateful interactions, and the Invocations protocol for schema-free pass-through scenarios where you control the request/response format entirely.

This matters for organizations running heterogeneous agent stacks. Your legacy LangChain agents, your new Microsoft Agent Framework agents, and your experimental Claude Agent SDK prototypes can all run on the same managed runtime — unified observability, unified billing, unified governance.

Long-Running Agents and Routines

Most agent runtimes assume a request-response lifecycle. Foundry Agent Service also supports long-running autonomous agents with durable state and filesystem access, plus routines (public preview) — agents that run on a timer or a schedule. The canonical example: an agent monitors a GitHub repository overnight, triages new issues by morning, and posts a summary to Microsoft Teams before standup. This is the kind of always-on automation that bridges traditional RPA scheduling with agentic intelligence.

Autopilot Agents: Agents With Identity

Perhaps the most forward-looking feature: autopilot agents (public preview) act independently with their own Entra ID, email address, Teams presence, and place in the organizational chart. They can initiate conversations, work on shared files, follow up on action items, and collaborate with humans over time. Every action is attributable, auditable, and governed through Agent 365 in Microsoft Admin Center.

For RPA teams, this is conceptually equivalent to an unattended robot in UiPath or Automation Anywhere — but operating at the knowledge-worker layer rather than the UI-automation layer. The agent doesn’t click buttons; it reads documents, sends emails, updates project plans, and joins meetings. If your automation roadmap includes evaluating how classic RPA platforms compare to agentic approaches, autopilot agents represent the opposite end of the spectrum from screen-scraping bots.

Foundry IQ: Replacing DIY RAG Pipelines

Foundry IQ (generally available) replaces the chunking-indexing-retrieval pipeline that every RAG implementation forces you to build from scratch. It turns Azure AI Search into an agentic retrieval engine that plans multi-step queries, reasons across knowledge bases, and enforces enterprise-grade security at the retrieval layer — not as an afterthought.

The architecture unifies five knowledge source types behind one SLA-backed retrieval endpoint:

Microsoft’s benchmarks show that combining a smaller agent model with agentic retrieval through Foundry IQ improves evidence recall by up to 54% compared to traditional RAG, while controlling costs and increasing agent responsiveness. The “agentic retrieval” distinction is important: instead of a single vector-similarity search, Foundry IQ plans multi-step retrieval strategies — decomposing complex questions, querying different knowledge bases for different sub-questions, and synthesizing results before returning them to the agent.

For teams already managing RAG architectures, Foundry IQ offers a path to significantly reduce custom plumbing. The tradeoff is platform commitment — Foundry IQ is deeply integrated with Azure infrastructure, and migrating away later means rebuilding the retrieval layer.

Toolboxes in Foundry: One Endpoint for Every Tool

The integration tax is real. Each tool an agent needs — an API, a database connector, a document processor — brings its own authentication flow, protocol, and lifecycle. Toolboxes in Foundry (public preview) consolidates this: configure your tools once, point any MCP client at one URL, and let Foundry handle auth, lifecycle, and governance.

Three capabilities stand out:

Skills as first-class resources: Skills are versioned in a project-scoped catalog and discoverable as MCP resources by any agent in the project. This means your “check-credit-score” skill or your “query-SAP-inventory” skill is registered once and available to every agent in the organization, with version control and access policies.

Tool search: Instead of surfacing every available tool to the model (which wastes tokens and invites hallucinated tool calls), tool search intelligently selects the right tools for each specific task. Early adopters report significant reductions in unnecessary tool invocations.

Microsoft IQ integrations: Toolbox connects directly to Work IQ, Fabric IQ (with Fabric data agents, ontology, and semantic models), and Foundry IQ — so agents tap enterprise data without custom plumbing between the tool layer and the knowledge layer.

Observability and Optimization: The Operate Layer

Most agent platforms stop at deployment. Microsoft’s strongest differentiator may be the operate layer — the closed-loop system that turns production failures into ranked improvements.

End-to-End Tracing

Tracing and evaluation for hosted agents (GA as of June 2026) pipes every model call, tool invocation, sub-agent hop, and handoff through a single OpenTelemetry pipeline. Evaluations link directly back to the trace that produced them in the Foundry Control Plane. When a regression surfaces, you move from the score to the exact production trace that caused it — not a separate dashboard, not a log file, the actual trace.

For teams coming from UiPath’s Orchestrator-centric monitoring or IBM watsonx’s control plane approach, Microsoft’s tracing is notable for being standards-based (OpenTelemetry) rather than proprietary.

Agent Optimizer: A Closed Improvement Loop

Agent optimizer (public preview, rolling out mid-2026) replaces the manual guess-and-check cycle of agent improvement with an evidence-backed loop:

1. Observe — consume production traces and evaluation scores from hosted agents
2. Evaluate — score every run against your defined rubric (task success, tone, safety, cost, latency)
3. Optimize — generate ranked candidate improvements across prompts and skills, validate each against your scenarios
4. Deploy — promote the winner with full lineage, diffs, audit trail, and rollback capability

Three components feed into this loop:

• ASSERT generates adversarial tests from your policies, surfacing where the agent fails before users do
• Agent Control Specification turns those risks into enforceable runtime guardrails across input, model, state, tool execution, and output
• Rubric (public preview) defines what “good” looks like with weighted evaluation criteria, scoring every run against them

This is the kind of continuous-improvement infrastructure that enterprise automation teams are used to from process mining tools (Celonis, UiPath Process Mining) — but applied to agent behavior rather than business processes.

Distribution: From Code to Microsoft 365 in One Step

Publishing agents to Microsoft Teams and Microsoft 365 Copilot is generally available. Any Foundry agent deploys directly into the apps employees already use, with identity, permissions, and policy flowing through automatically.

Three agent modes are now supported for distribution:

For organizations already using Copilot Studio’s rebuilt agent platform, Foundry Agent Service agents and Copilot Studio agents can now interoperate through A2A and MCP — Copilot Studio handles the low-code, business-user-facing orchestration, while Foundry Agent Service handles the developer-built, production-grade agents that require custom code and framework-level control.

How Microsoft’s Stack Compares to Competitors

Every major cloud provider now offers an agentic AI platform. Here’s how Microsoft’s stack compares at a glance:

Microsoft’s strongest differentiators are the M365 distribution path (no other vendor can deploy agents directly into Teams, Outlook, and Copilot), the agent optimizer closed loop (no competitor has an equivalent automated improvement cycle), and the breadth of orchestration patterns (five stable patterns vs. most competitors offering one or two). The tradeoff is ecosystem commitment — the deeper you integrate with Foundry IQ, Toolboxes, and M365 distribution, the harder it becomes to migrate to another cloud provider’s agent platform.

Getting Started: Your First Production Agent

The fastest path from zero to a production-deployed agent follows this sequence:

Step 1: Choose your runtime. .NET or Python — same concepts, same API surface, first-class support on both. Pick based on your team’s existing skills and the rest of your stack.

Step 2: Set up the development environment. Install Foundry Toolkit for VS Code (GA). This gives you agent templates, local testing with full trace visualization, step-by-step debugging, Toolbox connectivity, and one-click deployment to Foundry Agent Service — all without leaving the editor.

Step 3: Build with the Quickstart. Follow Microsoft’s hosted agent quickstart, which walks through creating, testing, and deploying a production-ready hosted agent end to end. The Azure Developer CLI handles provisioning, identity, and admin approval in a single workflow.

Step 4: Choose your orchestration pattern. Start with sequential for predictable pipelines or handoff for routing scenarios. Graduate to Magentic-One only when your task genuinely requires adaptive, dynamic collaboration — the orchestration overhead isn’t justified for simple workflows.

Step 5: Connect knowledge and tools. Wire up Foundry IQ for knowledge grounding and Toolboxes for tool access. Start with one knowledge source and one or two tools, then expand as you validate the agent’s behavior.

Step 6: Deploy and monitor. Deploy to Foundry Agent Service, enable tracing, and define your evaluation rubric. Let the agent optimizer suggest improvements based on real production traces.

The Agentic Business Solutions Certification Path

Microsoft’s partner ecosystem is restructuring around agentic AI. The Low Code Application Development and Intelligent Automation specializations have merged into a new Agentic Business Solutions specialization as of August 2026. Two new certifications anchor this path:

• AB-100: Agentic AI Business Solutions Architect — covers end-to-end solution design across Agent Framework, Foundry Agent Service, Copilot Studio, and Power Platform
• AB-620: AI Agent Builder Associate — covers hands-on agent development with Agent Framework, MCP/A2A integration, and Foundry deployment

For partners, achieving the specialization requires demonstrating real customer deployments: at least two customers, including one using Power Automate with a production flow and one using a Power Apps application with minimum five production users (Pathway One), or two Copilot Studio deployments with minimum $10,000 TTM each (Pathway Two). Customer references have been replaced with a third-party capabilities audit that requires real customer examples, valid for two years.

This certification restructuring signals where Microsoft expects enterprise agent budgets to flow. If you’re an automation professional considering the transition from classic RPA to agentic AI, the AB-100 and AB-620 certifications are the clearest investment in Microsoft-ecosystem skills.

Frequently Asked Questions

Is Microsoft Agent Framework the same as Semantic Kernel?

No, but it includes Semantic Kernel. Agent Framework 1.0 merged Semantic Kernel (enterprise plumbing: connectors, telemetry, filters) with AutoGen (multi-agent orchestration) into a single SDK. Existing Semantic Kernel plugins and connectors carry forward directly — you’re upgrading, not replacing.

Can I use Agent Framework with non-Microsoft models like Claude or Gemini?

Yes. Agent Framework 1.0 ships first-party connectors for Azure OpenAI, OpenAI, Anthropic Claude, Amazon Bedrock, Google Gemini, and Ollama. Model providers are swappable with a one-line configuration change.

How does Foundry Agent Service compare to running agents on my own Kubernetes cluster?

Foundry Agent Service provides session-level isolation (not just container-level), automatic memory management, built-in tracing via OpenTelemetry, and zero-idle-cost autoscaling out of the box. On self-managed Kubernetes, you’d build all of these yourself. The tradeoff is control vs. operational overhead — Foundry handles the infrastructure, but you’re committed to Azure as your runtime.

Does Agent Framework support human-in-the-loop approvals?

Yes. All five orchestration patterns — sequential, concurrent, handoff, group chat, and Magentic-One — support human-in-the-loop approvals, pause/resume for long-running workflows, and checkpointing for recovery.

What’s the difference between Copilot Studio agents and Foundry Agent Service agents?

Copilot Studio is the low-code, business-user-facing agent builder with a visual Workflow Designer. Foundry Agent Service is the developer-built, code-first runtime for agents that need custom orchestration, framework-level control, and production-grade infrastructure. They interoperate via A2A and MCP — Copilot Studio agents can invoke Foundry agents as tools, and vice versa.

Key Takeaways

• Agent Framework 1.0 unifies AutoGen + Semantic Kernel into one open-source SDK for .NET and Python, with stable multi-agent orchestration and MCP/A2A native at 1.0.
• Five orchestration patterns — sequential, concurrent, handoff, group chat, and Magentic-One — cover everything from simple pipelines to complex open-ended tasks.
• Foundry Agent Service provides the production runtime with session-isolated sandboxes, zero-idle-cost autoscaling, and framework-agnostic deployment.
• Foundry IQ replaces DIY RAG pipelines with agentic retrieval that improves recall by up to 54%, unifying five knowledge source types behind one endpoint.
• Autopilot agents get their own Entra identity, email, Teams presence, and org-chart position — the knowledge-worker equivalent of an unattended RPA robot.
• Agent optimizer closes the observe-evaluate-optimize-deploy loop automatically, replacing manual prompt tweaking with evidence-backed improvements.
• M365 distribution is the unique Microsoft advantage — no other cloud vendor can deploy agents directly into Teams, Outlook, and Copilot.
• New certifications (AB-100 Architect, AB-620 Builder) and the Agentic Business Solutions specialization mark where Microsoft expects the partner ecosystem to invest.

References

1. Microsoft Foundry Blog, “Build and run agents at scale with Microsoft Foundry at Build 2026” (June 2, 2026) — devblogs.microsoft.com
2. Microsoft Agent Framework Blog, “Microsoft Agent Framework Version 1.0” (April 3, 2026) — devblogs.microsoft.com
3. Microsoft Agent Framework Blog, “Agent Framework’s Orchestration Patterns Reach 1.0” (2026) — devblogs.microsoft.com
4. InfoQ, “Microsoft Foundry Adds Runtime, Tooling, and Governance for Production Agents” (June 2026) — infoq.com
5. Microsoft Azure Blog, “Introducing Microsoft Agent Framework” (2026) — azure.microsoft.com
6. Microsoft Foundry Blog, “Foundry IQ: Build smarter agents faster with unified knowledge and serverless retrieval” (2026) — devblogs.microsoft.com
7. itnext.io, “From Classic RAG to Agentic Retrieval: Inside Microsoft’s Foundry IQ Architecture” (2026) — itnext.io
8. Microsoft Tech Community, “Foundry IQ: Improve recall by up to 54% with knowledge bases” (2026) — techcommunity.microsoft.com
9. HubSite365, “Copilot Studio: Autonomous Agent Flows — August 2026 Updates” (August 2026) — hubsite365.com
10. Microsoft Learn, “Agentic AI Business Solutions Architect Certification” (August 2026) — learn.microsoft.com