All articles
    context-runtime
    azure
    microsoft-foundry
    agent-framework
    semantic-kernel
    autogen
    sidekick
    agentic-ai
    mission-runtime
    governance

    The Context Runtime Meets the Azure Agent Stack

    July 23, 2026redevops.io
    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        │
     └───────────────────────────────────────────────────────────────────┘
    
    SystemKindCore ideaLicense
    ReDevOps CR / rAIlsOptimization + mission runtimeA 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 FrameworkOpen-source SDKThe 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 ServiceManaged Azure platformHosted, 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 retrievalA 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

    CapabilityContext RuntimeAgent FrameworkFoundry Agent ServiceAI 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

    CapabilityContext RuntimeAgent FrameworkFoundry Agent ServiceAI 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

    CapabilityContext RuntimeAgent FrameworkFoundry Agent ServiceAI 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

    CapabilityContext RuntimeAgent FrameworkFoundry Agent ServiceAI 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.

    Want ReDevOps in your Google Top Stories & AI results?Follow ReDevOps on Google