The Context Runtime Meets the Google Agent Stack

A competitive teardown that ends in a handshake.
A year ago the pitch was build agents. Today, with the Gemini Enterprise Agent Platform (the former Vertex AI, consolidated with Agentspace), the open-source Agent Development Kit, the managed Agent Engine runtime, Vertex AI Search, Model Armor and the Agent2Agent (A2A) protocol now stewarded by the Linux Foundation, Google's message is build production agent systems that interoperate, which validates the layer we were built for. Google provides an excellent production stack: managed runtime, open framework, strong retrieval, managed guardrails, and an open wire protocol for agents to find and delegate to each other. Context Runtime complements it by optimizing the decisions Google intentionally leaves application-specific: retrieval strategy, reasoning policy, verification depth, model routing and execution planning. Different abstractions, complementary platforms: Agent Engine runs agents, our Mission Runtime runs missions, Context Runtime optimizes the decisions inside them.
This post is the honest comparison, then where Context Runtime and the Mission Runtime slot into a Google Cloud deployment. Google's real differentiator is worth naming: A2A. Google standardized how agents communicate; Context Runtime optimizes what each agent actually does, complementary by design, and most of this post is about that seam.
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 ADK · Agent Studio the loop · the tools │
│ (+ A2A for interop) · multi-agent patterns │
├───────────────────────────────────────────────────────────────────┤
│ Managed substrate Agent Engine runtime · memory · │
│ (+ Vertex AI Search, Model Armor) tools · guardrails │
└───────────────────────────────────────────────────────────────────┘
| 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 |
| Agent Development Kit (ADK) | Open-source SDK | A code-first Python framework for custom logic, multi-agent orchestration and tool integration, open-source and free; you pay for the runtime that hosts what you build. | Apache-2.0 · GA |
| Agent Engine | Managed Google platform | The managed runtime that handles deployment, scaling, session management and persistent memory for agents built with ADK or any supported framework. | Proprietary · GA |
| A2A protocol | Open interop standard | An open envelope for one agent to discover, authenticate and delegate to another, regardless of framework, "HTTP for agents", donated to the Linux Foundation. | Open · v1.2 |
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 | ADK | Agent Engine | A2A |
|---|---|---|---|---|
| Orchestration model | ● Deterministic planner → execution graph, simulation-gated | ● Code-first multi-agent orchestration | ○ Hosts your framework | ◐ Cross-agent delegation envelope |
| Cost-based, learned planning | ● Core thesis: cost model + knapsack + contextual bandit | ○ The LLM decides | ○ None | ○ Not a concept |
| Knowledge-representation routing | ● Routes document / graph / temporal / analytical / vision / code | ○ Retrieval is a tool | ○ Not a concept | ○ Out of scope |
Retrieval and context
| Capability | Context Runtime | ADK | Agent Engine | Vertex AI Search |
|---|---|---|---|---|
| Native retrieval engines | ● In-tree: BM25, dense, hybrid-RRF, HippoRAG graph, temporal, pgvector | ◐ Via tools | ◐ Via Vertex AI Search | ● Managed vector + semantic search |
| Multimodal retrieval | ● Native CLIP image + video | ◐ Via Gemini tools | ◐ Multimodal payloads | ◐ Multimodal search |
| Decision transparency (EXPLAIN) | ● Ranked candidates + calibrated P(relevant) + reward provenance | ◐ Traces | ◐ Cloud Monitoring spans | ◐ Search metadata |
Memory, missions and multi-agent
| Capability | Context Runtime | ADK | Agent Engine | A2A |
|---|---|---|---|---|
| Multi-agent patterns | ◐ Capability graph + supervision (Sidekick) | ● ADK multi-agent | ◐ Hosts any | ● Cross-platform agent delegation |
| World / belief state | ● Event-sourced + belief fusion · Observed→Verified→Believed→Committed | ○ Session state | ● Managed memory | ○ Not a concept |
| Durable / resumable execution | ● Event-sourced missions: replay, rehydrate, survive restarts | ○ Session persistence | ● Managed sessions | ○ Stateless envelope |
| Saga / compensation | ● Unwinds committed side-effects newest-first | ○ None | ○ None | ○ None |
Governance, identity and tools
| Capability | Context Runtime | ADK | Agent Engine | Model Armor / A2A |
|---|---|---|---|---|
| Policy-constrained planning | ● Infeasible plans pruned pre-ranking; app→row→column→object | ◐ Framework filters | ◐ IAM scoping | ○ None |
| Verification / evidence plane | ● Append-only evidence + verification gate the Commit; citation verifier | ○ Hooks | ○ None | ○ None |
| Human-in-the-loop approvals | ● Policy-driven, risk-scored evidence packet | ◐ Framework hooks | ◐ Via framework | ○ None |
| Identity & delegated access | ◐ Permissions plane; leans on the cloud broker | ◐ Via IAM | ● IAM + workload identity | ● A2A attested agent identity |
| Content guardrails | ◐ Tool approval gate + optional filter | ◐ Prompted | ◐ Configurable | ● Model Armor |
| Maturity | ◆ Reference impl + live demos; pre-GA | ● GA, open-source | ● GA | ● GA, 150+ orgs |
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, separate from fixed config or an LLM guess. Google's stack is unusually strong on interoperability (A2A is a genuinely important open standard we should not reinvent), but it governs how one agent talks to another, and which context and model an agent should use to do its own work well is a separate choice. Context Runtime lives one level in, optimizing the decision inside an agent, orthogonal to how agents delegate across the mesh.
What the Google stack does that Context Runtime leans on and reuses is Google's home turf. A2A is the connective tissue for multi-agent systems; we speak it as our bus. Model Armor is a managed guardrail we apply on model I/O. Agent Engine brings managed runtime, scaling and memory; ADK mature code-first multi-agent orchestration; Vertex AI Search a strong managed retriever; Gemini and 200-plus hosted models the model plane. 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, ADK's from framework structure and Model Armor, Agent Engine's from managed sessions. You want all three, and they stack.
The ending: complement
Context Runtime learns which combination of Google's building blocks (and its open protocol for agents to cooperate) 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 and reuse, 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
▼
Agent Engine managed runtime - compute · memory · A2A identity
│
▼
Vertex AI Search · Model Armor · Gemini · A2A · MCP · GCS · Cloud Functions
production infrastructure
Everything already inside Google Cloud stays there: Vertex AI Search, Model Armor, Gemini, Agent Engine and IAM remain the substrate; Context Runtime only decides how and when to use them, so do I have to migrate my data? answers itself: no. A2A is the seam: it is how agents find and delegate to each other, deliberately silent on how any single agent should reason, and Context Runtime becomes the optimization layer behind an A2A endpoint: when a task is delegated, the receiving agent calls Context Runtime to decide which representation, retrieval engine and model tier answer it best for the least spend. A2A moves the work; Context Runtime makes the work good. On identity, A2A carries attested agent identity and IAM carries workload identity, both planes we consume and reuse: Context Runtime and Sidekick use whatever delegated identity the platform issues (STS on AWS, A2A-attested on Google).
This reaches production at deployment: agent logic starts as Infrastructure-as-Code on a laptop (Terraform, a Cloud Build config, a Cloud Deploy pipeline) and must travel into a locked-down Google Cloud project and VPC, exactly where governance falls off. Sidekick and the Mission Runtime close that gap:
YOUR LAPTOP SIDEKICK + MISSION RUNTIME GCP PROJECT
┌──────────────┐ plan ┌───────────────────────────┐ deploy ┌────────────────┐
│ Terraform │ ───────────► │ governed mission: │ ───────► │ Agent Engine + │
│ Ansible │ │ plan · simulate · GATE │ │ ADK agents, │
│ CR config │ ◄─────────── │ · verify · saga rollback │ ◄─────── │ A2A endpoints │
└──────────────┘ health + └───────────────────────────┘ health └────────────────┘
agent comms (every step evidence-backed) + Cloud Monitoring
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 project, 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: for every call it picks the knowledge representation, retrieval engine (Vertex 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.
┌──────────────────────────── GCP PROJECT ────────────────────────────┐
│ Agent Engine Agents built with │
│ ┌─────────────────────┐ the ADK │
│ │ Managed runtime │ ┌───────────────────┐ │
│ │ Memory · sessions │◄────────┤ agent loop + │ │
│ │ A2A identity │ tools │ A2A · MCP tools │ │
│ └─────────▲───────────┘ └─────────▲─────────┘ │
│ │ │ │
│ │ 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 Cloud Monitoring health through the same governed channel and turning a fired alert into a governed response mission with a hand on the rollback.
Google gives the substrate, framework, tools and interop protocol; 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 project and keeps a hand on it there. Self-hosted where you want sovereignty, integrated where you want Google 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 Google Cloud 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). Google Cloud is the next set over the identical kernel, and Context Runtime sits inside an agent, so it composes with A2A.
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
Google Cloud provider work: adapters on the existing architecture (planned)
- Native model adapter: Gemini (and the 200-plus hosted models on the platform)
- Managed retrieval adapter: Vertex AI Search; analytical retrieval over BigQuery
- Cloud monitoring integration: Cloud Monitoring + Cloud Trace as Sidekick's post-deploy backend
- Identity integration: A2A attested agent identity + workload identity
- Guardrails integration: Model Armor
The architecture stays cloud-agnostic; each provider integration reuses the same planning and execution engine, a rollout.
Context Runtime is open-core (AGPL) and self-hostable; it plugs into Google Cloud through the same provider seam that backs its shipping AWS adapters: Gemini/Vertex models, Vertex AI Search retrieval and Model Armor guardrails as a drop-in adapter, speaking A2A behind its endpoints. Capability claims marked ◆ are specified in the whitepapers and not yet GA.