The Context Runtime Meets the Azure Agent Stack

A competitive teardown that ends in a handshake.
A year ago the pitch was build agents. Today, with Foundry Agent Service, the Microsoft Agent Framework (Semantic Kernel and AutoGen, finally one SDK), Entra Agent ID, Azure AI Search agentic retrieval and MCP-native Toolboxes, Microsoft's message is build production agent systems, which validates the layer we were built for. Azure provides an excellent production stack: hosted runtime, converged framework, per-agent identity, managed retrieval and governance. Context Runtime complements it by optimizing the decisions Azure intentionally leaves application-specific: retrieval strategy, reasoning policy, verification depth, model routing and execution planning. Different abstractions, complementary platforms: Foundry runs agents, our Mission Runtime runs missions, Context Runtime optimizes the decisions inside them.
This post gives the honest comparison, then where Context Runtime and the Mission Runtime slot into a production Azure deployment. If you already live in the Microsoft ecosystem (Entra, Microsoft 365, Azure DevOps), this is the lowest-friction place to add an optimization layer: Context Runtime consumes Entra Agent ID and Foundry as capabilities to optimize over.
What each one actually is
LAYER SYSTEM WHAT IT OWNS
┌───────────────────────────────────────────────────────────────────┐
│ Optimization / planning Context Runtime which retrieval, model, │
│ (+ Mission Runtime for execution) strategy - learned │
├───────────────────────────────────────────────────────────────────┤
│ Agent framework Agent Framework the loop · the tools │
│ (Semantic Kernel + AutoGen) · multi-agent patterns │
├───────────────────────────────────────────────────────────────────┤
│ Managed substrate Foundry Agent Svc runtime · memory · │
│ (+ AI Search, Entra Agent ID) identity · tools │
└───────────────────────────────────────────────────────────────────┘
| System | Kind | Core idea | License |
|---|---|---|---|
| ReDevOps CR / rAIls | Optimization + mission runtime | A cost-based decision runtime that picks the knowledge representation, retrieval engine and model before the call - under a durable event-sourced Mission Runtime that executes objectives with governance and verification. | AGPL · self-host |
| Microsoft Agent Framework | Open-source SDK | The convergence of Semantic Kernel and AutoGen into one Python/.NET SDK: enterprise foundations plus multi-agent orchestration, with a Process Framework for deterministic workflows. | MIT · GA |
| Foundry Agent Service | Managed Azure platform | Hosted, secure, scalable compute for agents - runtime, memory, per-agent Entra identity, and Toolboxes (a single managed endpoint for tools, skills, MCP clients and enterprise data). | Proprietary · GA |
| Azure AI Search (agentic retrieval) | Managed retrieval | A knowledge base that decomposes a complex query into subqueries, runs them across knowledge sources, and returns ranked results - each knowledge base is itself an MCP server. | Proprietary · GA |
The capability matrix
Legend: ● native / first-class · ◐ partial, via tools, or thinner · ○ not present · ◆ ReDevOps spec: whitepaper, not yet shipped.
Planning and the execution model
| Capability | Context Runtime | Agent Framework | Foundry Agent Service | AI Search |
|---|---|---|---|---|
| Orchestration model | ● Deterministic planner → execution graph, simulation-gated | ● Framework orchestration + Process Framework | ○ Hosts your framework | ◐ Query decomposition pipeline |
| Cost-based, learned planning | ● Core thesis - cost model + knapsack + contextual bandit | ○ The LLM decides | ○ None | ○ Fixed pipeline |
| Knowledge-representation routing | ● Routes document / graph / temporal / analytical / vision / code | ○ Retrieval is a tool | ○ Not a concept | ◐ Subquery planning within search |
Retrieval and context
| Capability | Context Runtime | Agent Framework | Foundry Agent Service | AI Search |
|---|---|---|---|---|
| Native retrieval engines | ● In-tree: BM25, dense, hybrid-RRF, HippoRAG graph, temporal, pgvector | ◐ Via tools | ◐ Via AI Search | ● Vector + semantic ranking + subquery decomposition |
| Query decomposition | ◐ Per-representation planning | ○ Prompted | ○ Via AI Search | ● Native - splits complex queries into subqueries |
| Decision transparency (EXPLAIN) | ● Ranked candidates + calibrated P(relevant) + reward provenance | ◐ Traces | ◐ Azure Monitor spans | ◐ Retrieval metadata |
Memory, missions and multi-agent
| Capability | Context Runtime | Agent Framework | Foundry Agent Service | AI Search |
|---|---|---|---|---|
| World / belief state | ● Event-sourced + belief fusion · Observed→Verified→Believed→Committed | ○ Conversation / process state | ● Managed memory | ○ Not a concept |
| Durable / resumable execution | ● Event-sourced missions - replay, rehydrate, survive restarts | ◐ Process Framework checkpoints | ● Managed sessions | ○ Stateless |
| Saga / compensation | ● Unwinds committed side-effects newest-first | ○ None | ○ None | ○ None |
| Human-in-the-loop approvals | ● Policy-driven, risk-scored evidence packet | ◐ Framework hooks | ◐ Via framework | ○ None |
Governance, identity and tools
| Capability | Context Runtime | Agent Framework | Foundry Agent Service | AI Search |
|---|---|---|---|---|
| Policy-constrained planning | ● Infeasible plans pruned pre-ranking; app→row→column→object | ◐ Framework filters | ◐ RBAC + Entra scoping | ◐ Index-level ACLs |
| Verification / evidence plane | ● Append-only evidence + verification gate the Commit; citation verifier | ○ Hooks | ○ None | ○ None |
| Identity & delegated access | ◐ Permissions plane; leans on the cloud broker | ◐ Via Azure | ● Entra Agent ID - a dedicated, auditable identity per agent | ◐ Managed identity |
| Content guardrails | ◐ Tool approval gate + optional filter | ● Content Safety | ● Azure AI Content Safety | ◐ Via pipeline |
| MCP support | ◐ Client + retrieval tool | ● Client | ● Toolboxes (MCP clients) | ● Each KB is an MCP server |
| Maturity | ◆ Reference impl + live demos; pre-GA | ● GA 1.0 | ● GA | ● GA |
The read
What Context Runtime optimizes that the others treat as fixed is a query-planner for context: a cost model, knapsack selection and contextual bandits treating "which model, which retrieval, which representation" as a learned optimization objective distinct from fixed config and an LLM guess. The honest line for Azure: AI Search already decomposes a query into subqueries (real query planning), but it does not learn, per mission and under a cost budget, which knowledge representation and model tier win. Decomposition asks "what sub-questions answer this?"; Context Runtime asks "which strategy answers this best for the least spend, and did that choice pay off?" And its analytical representation reaches structured data through a guarded text-to-SQL adapter over Azure SQL, Microsoft Fabric or Synapse, picked only when the question is really an aggregation.
What the Azure stack does that Context Runtime leans on is Microsoft's home turf. Entra Agent ID gives every agent a first-class, auditable identity: we consume it as the identity provider. Azure AI Content Safety is a managed guardrail we apply on model I/O. The Agent Framework brings mature multi-agent orchestration and a converged SDK; Foundry brings hosted, secure compute; AI Search brings a strong managed retriever that is itself an MCP server. All GA and widely adopted; we are a reference implementation, and say so plainly. Same problem, different layer: our reliability comes from an event-sourced state machine with verification and compensation, the Agent Framework's from process orchestration and Content Safety, Foundry's from managed session isolation: you want all three, and they stack.
The ending: complement, not compete
Context Runtime learns which combination of Azure's building blocks produces the best outcome for each class of mission: the one thing the managed stack, by design, does not do. Learning which execution strategy works. It treats managed retrieval, identity, inference and guardrails as capabilities to optimize over, so organizations adopt it without migrating data. Five layers, five different jobs:
Applications
│
▼
Mission Runtime governed execution - plan · gate · verify · saga
│
▼
Context Runtime optimization & planning - retrieval strategy, reasoning
│ policy, verification depth, routing
▼
Foundry Agent Svc managed runtime - hosted compute · memory · Entra Agent ID
│
▼
Azure AI Search · Content Safety · Azure OpenAI · MCP · Blob · Functions
production infrastructure
Everything already inside Azure stays there: Azure AI Search, Content Safety, Azure OpenAI, Entra and Foundry remain the substrate; Context Runtime only decides how and when to use them, so do I have to migrate my data? answers itself: no. Microsoft went all-in on MCP (Foundry Toolboxes are MCP clients, every AI Search knowledge base an MCP server), and Context Runtime is a first-class MCP citizen too: it consumes MCP tools behind its approval gate and exposes its own retrieval planner as an MCP tool, so a Foundry-hosted agent can call it for a cost-optimal context bundle over the same protocol. Identity is a plane we deliberately don't rebuild: where AWS gives STS roles and Azure gives Entra Agent ID, Context Runtime and Sidekick consume the delegated, per-agent identity the platform issues: one owns who the agent is, the other what context it uses to act.
This reaches production at deployment: agent logic starts as Infrastructure-as-Code on a laptop (Bicep, Terraform, an Azure DevOps pipeline) and must travel into a locked-down Azure tenant, exactly where governance falls off. Sidekick and the Mission Runtime close that gap:
YOUR LAPTOP SIDEKICK + MISSION RUNTIME AZURE TENANT
┌──────────────┐ plan ┌───────────────────────────┐ deploy ┌────────────────┐
│ Bicep / TF │ ───────────► │ governed mission: │ ───────► │ Foundry agents │
│ Ansible │ │ plan · simulate · GATE │ │ + Agent │
│ CR config │ ◄─────────── │ · verify · saga rollback │ ◄─────── │ Framework │
└──────────────┘ health + └───────────────────────────┘ health └────────────────┘
agent comms (every step evidence-backed) + Azure Monitor
A deployment becomes a governed mission: Sidekick drives Bicep, Terraform and Ansible, but each step is planned, gated on a human approval with an evidence packet, verified against the live tenant, and unwound by a saga on failure: the Observed→Verified→Believed→Committed discipline that governs a retrieval now governing a resource-group deploy. Once agents are up, Context Runtime rides along as the context-serving layer: for every call it picks the knowledge representation, retrieval engine (AI Search, a graph, a local hybrid) and model tier, then returns a cost-optimal bundle with a calibrated relevance score and EXPLAIN trace: sharper, cheaper context without leaving the platform.
┌────────────────────────── AZURE TENANT ─────────────────────────────┐
│ Foundry Agent Service Agents built with │
│ ┌─────────────────────┐ the Agent Framework │
│ │ Hosted compute │ ┌───────────────────┐ │
│ │ Memory · Toolboxes │◄────────┤ agent loop + │ │
│ │ Entra Agent ID │ tools │ MCP · Toolboxes │ │
│ └─────────▲───────────┘ └─────────▲─────────┘ │
│ │ │ │
│ │ context bundles: routed KR, calibrated P(relevant), │
│ │ cost-optimal model + retrieval, EXPLAIN provenance │
│ ┌─────────┴───────────────────────────────┴─────────┐ │
│ │ CONTEXT RUNTIME (planner + kernel) │ │
│ │ picks representation & model BEFORE each call │ │
│ └────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────────┘
And the loop closes back to the laptop: Sidekick keeps watching the deployment after it ships: reading Azure Monitor health through the same governed channel and turning a fired alert into a governed response mission with a hand on the rollback.
Azure gives the substrate, framework and tools; the Mission Runtime gives governed execution; Context Runtime gives the optimization: which strategy, model and retrieval, learned per mission; and Sidekick bridges a governed mission from local IaC into the tenant and keeps a hand on it there. Self-hosted where you want sovereignty, integrated where you want Azure scale.
Part of a four-part series comparing Context Runtime with each cloud's agent stack. For the side-by-side, see Choosing an Agent Stack in 2026.
Engineering reality
Context Runtime, the Mission Runtime and Sidekick are provider-neutral infrastructure: one kernel for all clouds. Integrating Azure is a set of adapters behind existing plugin seams: the same seam already carries shipping AWS adapters (Bedrock model, OpenSearch, Knowledge Bases, Athena text-to-SQL, Guardrails, CloudWatch). Azure is the next set over the identical kernel.
Production today: provider-neutral, in use
- Context Runtime: cost-based planner, knowledge-representation routing, the learning loop, EXPLAIN
- Mission Runtime: event-sourced missions, approval gates, saga compensation
- Sidekick: governed IaC deploys + post-deploy monitoring
Azure provider work: adapters on existing architecture (planned)
- Native model adapter: Azure OpenAI
- Managed retrieval adapter: Azure AI Search agentic retrieval; analytical retrieval over Azure SQL / Fabric / Synapse
- Cloud monitoring integration: Azure Monitor as Sidekick's post-deploy backend
- Identity integration: Entra Agent ID
- Guardrails integration: Azure AI Content Safety
The remaining work is provider integration on existing architecture: a provider rollout.
Context Runtime is open-core (AGPL) and self-hostable; it plugs into Azure through the same provider seam that backs its shipping AWS adapters: Azure OpenAI models, AI Search retrieval and Content Safety guardrails as drop-in adapters. Capability claims marked ◆ are specified in the whitepapers and not yet GA.