Managed Agent Runtimes, Compared at the API Call

TL;DR 3 cards

The category shape what all three do

Every managed agent runtime ships the same five primitives. The names differ; the mechanics don't.

The differentiators live in how each vendor exposes these primitives: SDK shape, sandbox partners, pricing formula, protocol support, and the model ecosystem you can plug in.

OpenAI OpenAI Agents API

The newest entry. Public beta since Sept 10, 2026. Exposes the same Codex harness that powers Codex Cloud and ChatGPT for Work through a single API namespace.

Core primitives

SDK call — create a multi-agent session

from openai import OpenAI
client = OpenAI()

session = client.beta.agents.sessions.create(
    model="gpt-5.6",
    multi_agent={
        "enabled": True,
        "max_concurrent_subagents": 3,
    },
    tools=[
        {"type": "mcp", "server": "github"},
        {"type": "code_interpreter"},
    ],
    sandbox="openai-hosted",          # or "self-hosted" or a partner slug
    workspace="/workspace",
    instructions=(
        "Investigate service-api's elevated 5xx rate over the last 30 minutes. "
        "Delegate deployment, error, and dependency analysis to subagents. "
        "Save findings, evidence, and recommended mitigation in /workspace/outputs."
    ),
)

# Stream events
for event in client.beta.agents.sessions.stream(session.id):
    print(event.type, event.data)

What you get out of the box

• Managed Codex harness — same harness that runs Codex Cloud. No building your own agent loop.
• Subagent fan-out — declarative max_concurrent_subagents; results aggregate automatically.
• Context compaction — built into the harness; long sessions don't blow the context window.
• Recovery — sessions resume after disconnection, crash, or model error.
• Code execution in sandbox — full Python + Node runtime, file ops, package install, artifact generation.
• MCP connectivity — connect any MCP server to bring external tools.
• 9 partner sandboxes on day one — Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop, Vercel.

What you don't get

• Zero Data Retention — explicitly unavailable. Sessions are persistent.
• EU data residency — US-only at launch.
• Multi-model — pinned to OpenAI models. No Claude, Gemini, or Llama.
• Long-term memory primitives — session state exists; cross-session Memory Bank analog is not announced.

Production validation (verbatim from the announcement)

• Nash.ai (CTO Aziz Alghunaim): "we deploy thousands of long-running AI agents that manage hundreds of millions of deliveries across global logistics networks… This lets our agents reason, act, recover, and collaborate across complex workflows that can span hours or days."
• Hypha (Lead Engineer Serhii Shchoholiev): "By separating the agent harness from the sandbox, we reduced failed agent responses by 86%."
• SafetyKit (Member of Technical Staff Bhavyansh Sabharwal): "60% reduction in cost per case, lower latency, and significantly improved token efficiency."
• Ciridae (CTO Jack Weissenberger): "evaluation score went from 0.71 to 0.85… 4x latency reduction."

Pricing formula

From the announcement: "billed at standard model rates plus container rates." The OpenAI changelog entry: "Build agents with a managed Codex harness while OpenAI handles session orchestration, context compaction, and recovery." No per-session-hour fee is published; container rates come from the sandbox partner you choose.

Anthropic Claude Managed Agents

The first-mover. Public beta since April 8, 2026. The platform behind Claude Code Cloud. Four core primitives documented in the official docs: Agent, Environment, Session, Events.

Core primitives

SDK call — create an agent and start a session

import anthropic

client = anthropic.Anthropic()  # picks up ANTHROPIC_API_KEY + beta header

# 1. Define the agent ONCE — model, system prompt, tools, MCP servers, skills
agent = client.beta.agents.create(
    model="claude-opus-4-6",
    system="You are a financial analyst. Use the available tools to read SEC filings.",
    tools=[
        {"type": "bash_20250909", "name": "bash"},
        {"type": "file_edit_20250909", "name": "file_edit"},
        {"type": "web_search_20250909", "name": "web_search"},
        {"type": "mcp", "server_url": "https://mcp.sec.gov"},
    ],
    skills=["financial-modeling-v3"],
)

# 2. Create an environment (where the sandbox lives)
env = client.beta.environments.create(
    type="anthropic-cloud-sandbox",
    region="us-east-1",
)

# 3. Launch a session that references both
session = client.beta.sessions.create(
    agent={"type": "agent", "id": agent.id, "version": "latest"},
    environment=env.id,
)

# 4. Send a user message as an event
event = client.beta.sessions.events.create(
    session_id=session.id,
    type="user.message",
    content="Pull Q2 10-Q for NVDA, summarize the data-center segment commentary.",
)

# 5. Stream events back (server-sent events)
for evt in client.beta.sessions.events.stream(session_id=session.id):
    if evt.type == "tool.call":
        print(f"[tool] {evt.tool_name}({evt.input})")
    elif evt.type == "session.status":
        print(f"[status] {evt.status}")  # idle / running / rescheduling / terminated

Built-in tools (no extra wiring)

• bash — run shell commands in the sandbox (with package install)
• file_edit / file_read / file_glob / file_grep — file system access
• web_search / web_fetch — search and retrieve URLs (allowlist/blocklist supported)
• MCP servers — any external tool provider via Model Context Protocol

Advanced features

• Multi-agent coordination (Agent Teams) — agents spin up and direct subagents. Research preview as of docs; request access.
• Scheduled execution — recurring agent runs on a cron schedule through scheduled deployments.
• Self-hosted sandboxes — for compliance or data-residency requirements.
• MCP tunnels — connect to MCP servers behind your firewall. Research preview.
• Dreaming / outcomes — agents learn across sessions and improve themselves. Research preview.
• Versioning and pinning — sessions can start with "latest agent version" or pin to a specific {type:"agent", id, version}.
• Built-in prompt caching — 1.25x write / 0.1x read multipliers; same as Messages API.
• Built-in compaction — automatically summarizes earlier conversation turns when context grows.

State machine — sessions are explicit

The four states (idle, running, rescheduling, terminated) are the most operationally useful primitive across the three vendors. You can poll for status, receive webhook events, and use the transition logic for cost control (billing only accrues during running).

What you don't get

• Zero Data Retention — explicitly unavailable (sessions are stateful by design).
• HIPAA Business Associate Agreement — not currently eligible.
• Batch API discount — 50% Batch API discount does not apply inside Managed Agents.
• Multi-model — pinned to Claude.

Pricing formula (verbatim from docs)

Rate limits: 60 RPM create endpoints, 600 RPM read endpoints (org-level). Standard tier-based model rate limits layer on top.

Google Vertex AI Agent Engine

The most mature. GA since 2025 (formerly "Reasoning Engine"). Sessions + Memory Bank + Code Execution began billing February 11, 2026. The runtime is part of the rebranded Gemini Enterprise Agent Platform as of Cloud Next 2026.

Core primitives

SDK call — build with ADK and deploy

from vertexai.preview import agent_engines
from vertexai.preview.reasoning_engines import LangchainAgent
import vertexai

# 1. Initialize
vertexai.init(project="my-project", location="us-central1", staging_bucket="gs://my-bucket")

# 2. Define your agent locally with ADK (or any framework — LangChain, custom, etc.)
from google.adk.agents import Agent
from google.adk.tools import VertexAISearchTool, CodeExecutionTool

local_agent = Agent(
    name="research_agent",
    model="gemini-2.5-pro",
    instruction="You are a research analyst. Use Vertex AI Search to ground answers.",
    tools=[VertexAISearchTool(corpus="company-filings"), CodeExecutionTool()],
)

# 3. Deploy to Agent Engine (managed runtime)
remote_app = agent_engines.create(
    agent_engine=LangchainAgent(agent=local_agent),
    requirements=["google-cloud-aiplatform[agent_engines]", "langchain"],
    display_name="research-agent-v1",
    description="Research analyst grounded in company filings",
)

# 4. Create a session and send a query
session = remote_app.create_session(user_id="alice")
print(session)
# {'session_id': '...', 'user_id': 'alice'}

events = remote_app.stream_query(
    session_id=session["session_id"],
    message="Summarize NVIDIA's Q2 2026 data-center revenue growth.",
)

for event in events:
    print(event)  # {'content': '...', 'author': 'research_agent'}

Why Vertex is the most enterprise-ready

• Native IAM — agents are first-class principals in Cloud IAM. Scoped permissions, audit logs, conditions.
• A2A protocol — native inter-agent communication across vendors (adopted by AWS, Microsoft, others).
• Memory Bank GA — predictable per-memory pricing; structured long-term recall across sessions.
• Observability — Cloud Trace + native dashboard for latency, token consumption, error rates.
• Agent Designer — low-code visual builder in Preview. No-code agent creation for non-engineers.
• Multi-model — Gemini tiers (Flash, Pro, Ultra) + Anthropic Claude via Vertex Model Garden + Llama + Mistral.
• VPC + CMEK + Private Service Connect — compliance-grade network isolation.

Pricing formula

The Sessions + Memory + Code Execution prices started accruing on January 28, 2026; runtime was already metered from the earlier GA.

API-call comparison side by side

The three SDKs are different shapes. This is what a create-session call looks like in each.

Side-by-side anatomy

Beta header — every call must carry one

Capability matrix what a developer can build

This is the developer-facing capability table — what each platform lets you build without bolting on external infrastructure.

Advanced agentic patterns what sophisticated workloads require

Beyond the primitives, the real question for "sophisticated agentic workloads" is which platform lets you build the patterns production agents actually need.

Pattern 1 — Long-horizon task with crash recovery

Goal: A multi-day research task that survives network failures, model errors, and tooling outages.

Winner for this pattern: OpenAI's session-resume is the most operationally proven (Nash.ai runs thousands in production). Anthropic has the cleanest state-machine model but caps are still being characterized. Google is configurable but more devops burden.

Pattern 2 — Subagent orchestration for parallel work

Goal: A coordinator agent fans work out to N specialists, each with its own tools.

# OpenAI — declarative in the session create call
session = client.beta.agents.sessions.create(
    model="gpt-5.6",
    multi_agent={
        "enabled": True,
        "max_concurrent_subagents": 5,    # ← explicit concurrency cap
    },
    instructions="Coordinate 5 subagents to investigate the outage.",
)

# Anthropic — Agent Teams (research preview)
# Each subagent is its own session with its own runtime + tokens
# Sub-agents inherit the parent's tools or override via agent spec
team = client.beta.agent_teams.create(
    coordinator_agent_id=coordinator.id,
    members=[
        {"agent_id": db_specialist.id, "role": "investigator"},
        {"agent_id": deploy_specialist.id, "role": "remediator"},
    ],
)

# Google — A2A protocol with Agent Engine instances
# Each agent runs in its own Agent Engine; coordinator dispatches via A2A
coordinator.send_message(
    target_agent=db_specialist_app.resource_name,
    message="Investigate elevated 5xx rates.",
)

Winner for this pattern: OpenAI's declarative subagent config is the simplest. Anthropic's Agent Teams is the most flexible but still research preview. Google's A2A is the most interoperable across vendors.

Pattern 3 — Long-term memory across sessions

Goal: An agent that remembers the user's preferences, project state, and prior conversations indefinitely.

Winner for this pattern: Google. Memory Bank is the only GA, production-priced, cross-session memory primitive across the three.

Pattern 4 — Data-residency / compliance

Goal: Run agents inside your VPC, on data that never leaves your region.

Winner for this pattern: Google, narrowly. Anthropic on AWS Bedrock is a close second. OpenAI is US-only with no ZDR — disqualifying for many enterprise workloads.

Pattern 5 — Tooling interop (bring your own MCP server)

Goal: Connect to internal tools (GitHub Enterprise, Salesforce, internal APIs) via MCP.

All three support MCP natively. The differentiator is the governance layer around MCP:

• OpenAI — MCP server registered inline in the tools array at session create. Sandbox-level isolation.
• Anthropic — MCP tunnel (research preview) for servers behind your firewall; otherwise inline registration.
• Google — Native Agent Gateway routes MCP egress to Google MCP servers, external MCP servers, or VPC-internal servers. IAP-secured. Model Armor for content inspection.

Winner for this pattern: Google, by a wide margin, for enterprise MCP governance. The Agent Gateway with VPC egress is a year ahead of where OpenAI/Anthropic are.

Pattern 6 — Cost predictability for bursty workloads

Goal: Cap spend during spikes; only pay for actual compute.

Winner for this pattern: Anthropic, by a hair. The four-state session model with idle-time metering is the cleanest cost primitive. Google's per-second vCPU/RAM is comparable but you need to model your workload to predict spend.

Pricing models the formula converges

All three vendors converged on the same formula: tokens + runtime + memory. The only divergence is whether runtime is metered per active session-hour (Anthropic) or per active compute unit (Google).

Worked example — a 2-hour agent with 5 tool calls

Assume: Sonnet 4.6, 200K input tokens + 50K output tokens, 5 web searches, 1-hour idle waiting for human approval, 1-hour active tool execution.

Anthropic wins on this workload because the $0.08/hour is dramatically cheaper than per-vCPU-hour billing, and idle time is free. For workloads with heavy concurrent compute, the math flips.

Reference architectures infrastructure

OpenAI Agents API

Anthropic Claude Managed Agents

Google Vertex AI Agent Engine

Decision matrix which one to pick

If you're a developer building sophisticated agentic workloads, the choice is rarely "which is best in absolute terms" — it's "which matches my constraints." Use this matrix.

Primary sources

All claims above trace to one of the following primary documents. Beta docs are flagged where applicable.