All articles
    context-runtime
    aws
    strands
    bedrock-agentcore
    crewai
    sidekick
    agentic-ai
    mission-runtime
    iac
    governance

    The Context Runtime Meets the AWS Agent Stack

    July 22, 2026redevops.io
    The Context Runtime Meets the AWS Agent Stack

    A competitive teardown that ends in a handshake.

    A year ago the pitch was build agents. Today, with Bedrock AgentCore, AWS Context, Knowledge Bases, the DevOps Agent, Transform and Continuum, AWS's message is build production agent systems, which validates the layer we were built for. AWS provides the substrate; Context Runtime complements it by optimizing the decisions AWS intentionally leaves application-specific: retrieval strategy, reasoning policy, verification depth, model routing and execution planning. Different abstractions: AgentCore 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 AWS deployment, and what stays put.

    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          Strands · CrewAI   the loop · the tools   │
     │        (+ LangGraph, OpenAI SDK …)          · multi-agent patterns  │
     ├───────────────────────────────────────────────────────────────────┤
     │ Managed substrate        Bedrock AgentCore  runtime · memory ·     │
     │        (+ AWS Context, Knowledge Bases)     gateway · identity      │
     └───────────────────────────────────────────────────────────────────┘
    
    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
    AWS Strands AgentsOpen-source SDKA model-driven SDK: the LLM plans and calls tools in a loop. Agent = model + tools + prompt. Four multi-agent primitives, deep tool + MCP + A2A ecosystem.Apache-2.0 · GA
    Bedrock AgentCoreManaged AWS platformSix independently-adoptable services (Runtime, Memory, Gateway, Identity, Tools, Observability) that operate agents from any framework (LangGraph, CrewAI, OpenAI Agents SDK, Strands …) at scale.Proprietary · GA
    CrewAIMulti-agent frameworkRole-based agent teams (Crews) plus an event-driven engine (Flows), unified memory + Knowledge RAG, and a paid enterprise control plane.MIT + AMP

    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 RuntimeStrandsAgentCoreCrewAI
    Orchestration model● Deterministic planner → execution graph, simulation-gated◐ Model-driven loop; Graph/Workflow for control○ Agnostic: hosts your framework● Crews + Flows (seq / hierarchical / event)
    Cost-based, learned planning● Core thesis: cost model + knapsack + contextual bandit○ The LLM decides○ None○ Planning is an LLM step
    Knowledge-representation routing● Routes document / graph / temporal / analytical / vision / code○ Retrieval is a tool○ Not a concept○ RAG = attached knowledge
    Reasoning strategies◆ Single-shot ships; plan-worker-critic / debate are seams● Reflect / think / parallel branches○ Via hosted framework● Planner + hierarchical delegation

    Retrieval and context

    CapabilityContext RuntimeStrandsAgentCoreCrewAI
    Native retrieval engines● In-tree (Go+Py): BM25, dense, hybrid-RRF, HippoRAG graph, temporal, pgvector◐ Via tools: Bedrock KB, mem0◐ Bring your own◐ Knowledge over Chroma / Qdrant
    Multimodal retrieval● Native CLIP image + video (ONNX)◐ Image / video tools◐ Multimodal payloads◐ Vision tools
    Decision transparency (EXPLAIN)● Ranked candidates + calibrated P(relevant) + reward provenance◐ OTEL traces◐ CloudWatch spans◐ Event bus / traces

    Memory and world state

    CapabilityContext RuntimeStrandsAgentCoreCrewAI
    Agent memory◐ Bi-temporal + 3-index (recency / semantic / entity), routed◐ SessionManager (S3) + tools● Managed short + long-term, LLM extraction● Unified Memory (LanceDB)
    World / belief state● Event-sourced + belief fusion w/ conflict flags · Observed→Verified→Believed→Committed○ Conversation only○ Not a concept○ Flow state (dict)

    Missions, workflows and multi-agent

    CapabilityContext RuntimeStrandsAgentCoreCrewAI
    Multi-agent patterns◐ Capability graph + supervision (Sidekick); no swarm/mesh● agents-as-tools · Swarm · Graph · A2A◐ Hosts any + A2A● Crews + Flows
    Durable / resumable execution● Event-sourced missions: replay, rehydrate, survive restarts○ Session persistence◐ Managed sessions to 8 h◐ Flow checkpoints
    Saga / compensation● Unwinds committed side-effects newest-first○ None○ None○ None
    Human-in-the-loop approvals● Policy-driven, risk-scored evidence packet (impact, alts, rollback)◐ handoff_to_user○ Via framework◐ human_input

    Governance, policy and verification

    CapabilityContext RuntimeStrandsAgentCoreCrewAI
    Policy-constrained planning● Infeasible plans pruned pre-ranking; app→row→column→object◐ Bedrock Guardrails◐ IAM + Identity scoping◐ AMP RBAC (paid)
    Verification / evidence plane● Append-only evidence + verification gate the Commit; citation verifier○ Hooks, no plane○ None◐ Task guardrails
    Identity & delegated access◐ Permissions plane; no OAuth broker◐ AWS IAM● OAuth 2/3-legged, token vault, Google/GitHub/Slack◐ AMP SSO
    Content guardrails◐ Tool approval gate; no content filter● Bedrock Guardrails● Bedrock Guardrails● LLM + function guardrails

    Tools, runtime and maturity

    CapabilityContext RuntimeStrandsAgentCoreCrewAI
    Tool ecosystem◐ 15 capability apps + tool seam (small)● 60+ prebuilt tools● Gateway: API/Lambda/OpenAPI → MCP● Large crewai-tools
    MCP support◐ Client, behind the approval gate● Client + dev server● Gateway is MCP◐ Adapter (tools)
    Sandboxed code / browser○ Disposable scan containers only◐ code_interpreter / browser● Managed sandbox + browser + web search◐ CodeInterpreterTool
    Runtime / session isolation◐ Self-hosted containers (compose + Ansible)◐ You host (Lambda / Fargate / EKS)● Firecracker microVM per session, scale-to-zero, 8 h◐ You host / AMP
    Self-hostable, no lock-in● Fully self-hosted on your own GPUs (vLLM / NVFP4)◐ Open SDK, AWS-gravitational○ AWS-managed only● OSS self-host
    Maturity◆ Reference impl + live demos; pre-GA● GA 1.0, runs Amazon Q Dev● GA, 9 regions● ~55k★, 100k+ devs

    The read

    What Context Runtime optimizes that the others treat as fixed is a query-planner for context: cost model, knapsack selection and contextual bandits treating "which model, which retrieval, which representation" as a learned optimization objective beyond fixed config and LLM guesses, under a mission kernel with world + belief state, an Observed→Verified→Believed→Committed discipline, saga compensation that unwinds committed side-effects, and governance by construction (policy as feasibility, an evidence-and-verification plane gating commits, EXPLAIN with calibrated relevance).

    What it leans on is AWS's home turf: AgentCore's managed substrate (Firecracker microVM isolation, scale-to-zero, OAuth identity, a Gateway that turns any API into an MCP tool), the large tool ecosystems and multi-agent breadth of Strands and CrewAI (Swarm, Graph, hierarchical delegation), sandboxed code and browser. All three are GA and widely adopted; we are a reference implementation whose reasoning strategies, SQL adapter and cost-model learner are unshipped seams. Same problem, different layer: our reliability comes from an event-sourced state machine with verification and compensation, theirs from output validation, guardrails and managed session isolation; these stack.

    The ending: complement

    Context Runtime learns which combinations of AWS's building blocks produce the best outcome for each class of mission, the one thing the managed stack, by design, does not do. Which execution strategy works, optimizing over managed retrieval, identity, inference and guardrails, so nothing migrates. 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
           ▼
      AWS AgentCore        managed runtime           - microVM · memory · gateway · identity
           │
           ▼
      Bedrock · Knowledge Bases · OpenSearch · AWS Context · MCP · S3 · Lambda
                           production infrastructure
    

    Everything already inside AWS stays put: Bedrock, Knowledge Bases, OpenSearch, AWS Context and AgentCore remain the substrate; Context Runtime only decides how and when to use them, so nothing migrates. AWS Context owns the authoritative context (a governed enterprise knowledge graph with matching access controls); Context Runtime owns the decision of how it's used, and since AgentCore is framework-agnostic (LangGraph, CrewAI, the OpenAI Agents SDK, Strands), it slots in whatever wrote the agent.

    This reaches production at deployment: agent logic starts as Infrastructure-as-Code on a laptop (Terraform, CloudFormation, CDK) and must travel into a locked-down AWS VPC, exactly where governance falls off. Sidekick and the Mission Runtime close that gap:

      YOUR LAPTOP                 SIDEKICK + MISSION RUNTIME               AWS VPC
     ┌──────────────┐   plan       ┌───────────────────────────┐  deploy  ┌────────────────┐
     │ Terraform    │ ───────────► │  governed mission:         │ ───────► │ AgentCore /    │
     │ Ansible      │              │  plan · simulate · GATE    │          │ Strands agents │
     │ CR config    │ ◄─────────── │  · verify · saga rollback  │ ◄─────── │ in the cluster │
     └──────────────┘   health +   └───────────────────────────┘  health  └────────────────┘
                        agent comms       (every step evidence-backed)      + telemetry
    

    A deployment becomes a governed mission: Sidekick drives Terraform and Ansible, but each step is planned, gated on a human approval with an evidence packet, verified against the live cluster, and unwound by a saga on failure: the Observed→Verified→Believed→Committed discipline that governs a retrieval now governing a terraform apply. Once agents are up, Context Runtime rides along as the context-serving layer:

     ┌──────────────────────────── AWS VPC ────────────────────────────────┐
     │                                                                      │
     │   Bedrock AgentCore                Agents built with                 │
     │   ┌─────────────────────┐         Strands / CrewAI                   │
     │   │ Runtime (microVM)   │         ┌───────────────────┐              │
     │   │ Memory · Gateway    │◄────────┤  agent loop +      │             │
     │   │ Identity (OAuth)    │  tools  │  60+ tools · MCP   │             │
     │   └─────────▲───────────┘         └─────────▲─────────┘              │
     │             │                               │                        │
     │             │   context bundles: routed KR, calibrated P(relevant),  │
     │             │   cost-optimal model + retrieval, EXPLAIN provenance   │
     │   ┌─────────┴───────────────────────────────┴─────────┐             │
     │   │            CONTEXT RUNTIME (planner + kernel)       │            │
     │   │   picks representation & model BEFORE each call     │            │
     │   └────────────────────────────────────────────────────┘            │
     └──────────────────────────────────────────────────────────────────────┘
    

    AgentCore keeps microVM isolation, identity and Gateway; Strands and CrewAI keep the loop and tools; Context Runtime slots underneath as a unified context-serving unit, picking the knowledge representation, retrieval engine and model tier per call and returning a cost-optimal bundle with a calibrated relevance score and EXPLAIN trace. Sidekick keeps watching after ship, reading health and telemetry through the same governed channel, pausing at a gate, requesting approval, or triggering a saga rollback if a signal goes red.

    AWS gives the substrate, frameworks and tools; the Mission Runtime gives governed execution: plan, gate, verify, roll back; Context Runtime gives the optimization: which strategy, model and retrieval, learned per mission; and Sidekick bridges a governed mission from local IaC into the VPC and keeps a hand on it there. Self-hosted where you want sovereignty, integrated where you want AWS 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 across clouds. Integrating a cloud is a set of adapters behind existing plugin seams. AWS is the first cloud where those adapters are built.

    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

    AWS provider work: adapters over the seam (mostly shipped)

    • Native model adapter: Bedrock (converse), registered as cost tiers · shipped
    • Managed retrieval adapter: OpenSearch + Bedrock Knowledge Bases; analytical text-to-SQL over Athena · shipped
    • Cloud monitoring integration: CloudWatch → governed response missions in Sidekick · shipped
    • Guardrails integration: Bedrock Guardrails via a provider-neutral wrapper · shipped
    • Identity integration: AgentCore Identity · planned (deferred to an AgentCore-enabled account)

    The remaining work is provider integration, and on AWS most of it is already done.


    Context Runtime is open-core (AGPL) and self-hostable; the AWS integration described here composes the shipping mission kernel with managed AWS services: nothing migrated out of the VPC. 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