What is the difference between Google AX and the OpenAI Agents API?

They solve the same problem — running long-lived, tool-using agents reliably — from opposite ends. Google AX (v0.3.0, September 20, 2026) is an Apache-2.0 orchestrator you run on your own Kubernetes cluster with Agent Substrate: you supply the agent harness and model, and AX supplies sandboxing, egress allowlists, suspend/resume and fleet scheduling. OpenAI's Agents API (public beta since September 10, 2026) is a hosted service where OpenAI runs the Codex harness for you — sandbox, context compaction, subagents and resumable sessions — billed at normal token rates plus tool and container time, US-only data residency and no Zero Data Retention. AX is infrastructure you operate; the Agents API is infrastructure you rent.

Are Claude Code Projects and Cursor Projects the same kind of product as Google AX?

No. Claude Code Projects (September 17, 2026) and Cursor Projects (September 10, 2026) are end-user coding products: a persistent coordinator conversation that plans work, delegates to parallel cloud subagents, keeps shared project memory and returns pull requests. You do not choose the sandbox, the scheduler or the model provider. Google AX and the OpenAI Agents API are developer platforms underneath that layer — you could build something like Claude Code Projects on either. Pick Projects if you want the outcome (PRs) today; pick AX or the Agents API if you are building your own agent product or need control over where code runs.

Which option keeps code and data inside my own network?

Only Google AX, as of September 2026. AX runs on your Kubernetes cluster, keeps state in your Redis, sandboxes on Agent Substrate you operate, and fences outbound traffic with a Gateway host allowlist — model API calls are the only thing that has to leave. OpenAI's Agents API retains session state on OpenAI's side and is not ZDR-eligible even with a self-hosted sandbox. Claude Code Projects is cloud-only on Anthropic's infrastructure. Cursor Projects runs subagents in Cursor's cloud with a local agent spun up only for tests that need your machine.

What do these agent platforms cost in 2026?

Google AX is free software; you pay for your cluster, Redis and whichever model API the tasks call. OpenAI's Agents API adds no platform fee — you pay model tokens (GPT-6 Astra at $10 per million input and $50 per million output), built-in tools, and OpenAI container time if you use its sandbox, or partner sandbox fees otherwise. Claude Code Projects has no separate price but requires Claude Pro ($20/month) or Max ($100 or $200/month), and parallel threads consume usage quickly. Cursor Projects is included in Cursor subscriptions with cloud-agent usage billed against plan limits.

Quick Answer

Google AX vs OpenAI Agents API vs Claude Code Projects 2026

Published: September 21, 2026

Four answers to “where do my agents run?”

September 2026 produced four launches within eleven days that all address the same operational gap — agents that run for hours, need memory, and must be stopped, resumed and observed — but at very different layers of the stack:

	Google AX	OpenAI Agents API	Claude Code Projects	Cursor Projects
Launched	v0.1.0 May 20, 2026; v0.3.0 Sep 20, 2026	Public beta Sep 10, 2026	Sep 17, 2026 (beta)	Sep 10, 2026 (beta)
Layer	Self-hosted orchestrator (Kubernetes)	Hosted harness + API	End-user coding product	End-user coding product
Who runs the sandbox	You (Agent Substrate on your cluster)	OpenAI or partner sandboxes (E2B, Modal, Daytona, Vercel, etc.)	Anthropic cloud	Cursor cloud + optional local agent
Harness	Bring your own (ADK, LangGraph, Antigravity, Codex, Claude SDK)	OpenAI’s Codex harness	Claude Code	Cursor’s coordinator + subagents
Model choice	Any (Model object with K8s secret creds)	OpenAI models	Claude	Multiple frontier models via Cursor
Persistence	`ax suspend` / `ax resume`, snapshot on Substrate	Resumable sessions on OpenAI’s side	Shared project memory	Synced shared-context files
Egress control	Gateway host allowlist	Sandbox policy set by OpenAI/partner	Not user-configurable	Not user-configurable
Data residency / ZDR	Your cluster	US-only, no ZDR	Anthropic policies	Cursor policies
Licence / price	Apache-2.0; pay for infra + tokens	No platform fee; tokens + tools + container time	Claude Pro/Max subscription	Cursor subscription
Maturity	`v1alpha1`, breaking changes expected	Beta, no GA date	Beta, cloud-only, Pro/Max only	Beta, rolling out

Verified September 21, 2026 against the google/ax repository, OpenAI’s Agents API documentation, Anthropic’s Claude Code Projects announcement and Cursor’s Projects announcement.

Google AX: own the data plane

AX is the only one of the four you install. You write ax.io/v1alpha1 manifests — a Task (sandboxed run with CPU/memory limits), a Workspace (pre-cloned Git repos, MCP servers, skill packages), a Gateway (outbound host allowlist) and a Model (provider + credentials from a Kubernetes secret) — and ax apply them. A stateless gRPC server persists to Redis; controllers consume a Redis Stream and provision sandboxes on Agent Substrate, which snapshots idle agents and restores them in under 500 ms. ax ssh drops you into a running sandbox; ax suspend checkpoints it.

What you get: total control over where code executes, which hosts it can reach, and which model it calls — including non-Google models. What you give up: someone has to run the cluster, Redis and Substrate, the API is alpha, and there is no harness in the box. AX is what you choose when your constraint is compliance or scale (millions of short tasks), not time-to-first-agent.

OpenAI Agents API: rent the Codex harness

The Agents API exposes the same harness that runs Codex and ChatGPT Work: one call creates a session with model, instructions, tools, MCP servers and an environment, and OpenAI runs the loop — sandboxed commands, context compaction, parallel subagents, mid-turn steering, later resumption. The harness code is the open-source Codex repo; the hosted version is OpenAI’s. No platform fee — tokens (GPT-6 Astra $10/$50 per MTok), tools, and container time — and you can point it at partner sandboxes (Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop, Vercel).

The limits are the story for regulated teams: US-only data residency, no Zero Data Retention even with a self-hosted sandbox, sessions retained on OpenAI’s side, public beta with no GA date. See Agents API vs Agents SDK vs Responses API.

Claude Code Projects: the coordinator as product

Claude Code Projects adds a persistent coordinator conversation above multiple Claude Code cloud sessions. You brief it; it splits the work into parallel worker threads on separate branches, each returning a PR, and keeps a shared project memory of decisions so you can steer from a phone days later. It is included with Claude Pro ($20) or Max ($100/$200) and parallel threads burn usage fast. It is cloud-only and Anthropic runs everything. You are buying outcomes, not infrastructure.

Cursor Projects: same idea, editor-native

Cursor Projects launched a week earlier with the same shape: a coordinator that “doesn’t write code itself but directs other agents that do,” as many cloud subagents as the job needs, a synced shared-context file set that grows with the project, a local agent when something must run on your machine, and subscriptions that let it watch a Slack channel, run on a schedule or follow your PRs and fix CI. Multi-model. Also beta.

How to choose

You are building an agent product and must keep execution in your VPC (finance, healthcare, government, EU residency): Google AX. Nothing else on this list offers self-operated sandboxes with egress allowlists today. Pair with the egress lock-down guide.
You are building an agent product and want to ship this quarter with OpenAI models: Agents API — unless you need ZDR or non-US residency, in which case build your own loop (hosted harness vs DIY).
You want pull requests, not a platform: Claude Code Projects if you live in Claude Max and want one long-running conversation across repos; Cursor Projects if your team already uses Cursor and wants the coordinator plus Slack/schedule triggers. Both are beta; the coordinator-agent comparison goes deeper.
You have a Kubernetes platform team and hundreds of agents to schedule: AX, with the caveat that v1alpha1 means you will rewrite manifests before GA.

The pattern underneath

All four converge on the same primitives — sandbox, durable session, parallel subagents, suspend/resume, egress policy — which is why the September 2026 agent-harness value paper (planning text vs. verifier, and which dominates depending on liability) reads like a design brief for every one of them. The difference is ownership: Google is giving the layer away as open source and monetising GKE; OpenAI is renting it; Anthropic and Cursor are hiding it behind a coordinator. Which one you should adopt is less about capability than about who you want holding the sandbox when something goes wrong — see Plugin4Shell for what that looks like in practice.