All articles
    context-runtime
    gcp
    gemini-enterprise
    vertex-ai
    agent-engine
    adk
    a2a
    sidekick
    agentic-ai
    mission-runtime
    governance

    The Context Runtime Meets the Google Agent Stack

    July 23, 2026redevops.io
    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      │
     └───────────────────────────────────────────────────────────────────┘
    
    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
    Agent Development Kit (ADK)Open-source SDKA 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 EngineManaged Google platformThe managed runtime that handles deployment, scaling, session management and persistent memory for agents built with ADK or any supported framework.Proprietary · GA
    A2A protocolOpen interop standardAn 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

    CapabilityContext RuntimeADKAgent EngineA2A
    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

    CapabilityContext RuntimeADKAgent EngineVertex 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

    CapabilityContext RuntimeADKAgent EngineA2A
    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

    CapabilityContext RuntimeADKAgent EngineModel 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.

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