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 │
└───────────────────────────────────────────────────────────────────┘
| 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 |
| AWS Strands Agents | Open-source SDK | A 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 AgentCore | Managed AWS platform | Six 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 |
| CrewAI | Multi-agent framework | Role-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
| Capability | Context Runtime | Strands | AgentCore | CrewAI |
|---|---|---|---|---|
| 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
| Capability | Context Runtime | Strands | AgentCore | CrewAI |
|---|---|---|---|---|
| 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
| Capability | Context Runtime | Strands | AgentCore | CrewAI |
|---|---|---|---|---|
| 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
| Capability | Context Runtime | Strands | AgentCore | CrewAI |
|---|---|---|---|---|
| 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
| Capability | Context Runtime | Strands | AgentCore | CrewAI |
|---|---|---|---|---|
| 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
| Capability | Context Runtime | Strands | AgentCore | CrewAI |
|---|---|---|---|---|
| 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.