{"slug": "google-ax-google-s-open-agentic-orchestrator", "title": "Google/ax: Google's open agentic orchestrator", "summary": "Google released AX, an open-source declarative orchestrator for running autonomous agent workloads at scale, built on top of Agent Substrate for sandboxed execution and designed to run billions of tasks per cluster. AX is expressed through ax.io/v1alpha1 manifests with four primitives — Task, Workspace, Gateway, and Model — and is installed via `go install github.com/google/ax/cmd/ax@latest`, requiring a Kubernetes cluster, ko, a container registry, and a reachable Agent Substrate Control API. Google warns the project is still actively refining its core concepts, protocols, and specifications and will likely introduce major breaking changes prior to a stable release.", "body_md": "Warning\n\nWe are still actively refining our core concepts, protocols, and specifications. We will likely to introduce major breaking changes prior to a stable release.\n\n**Declare an agentic task with workspaces and gateway specifications. AX sandboxes it, wires up its workspace, fences its network, and helps running it at scale.**\n\nAX is a high-throughput, declarative orchestrator to run billions of autonomous agent workloads in a cluster. It runs on top of [Agent Substrate](https://github.com/agent-substrate/substrate) for sandboxed execution and is built to run billions of tasks per cluster. If you have used Kubernetes, `ax` will feel similar.\n\n```\n# task.yaml\napiVersion: ax.io/v1alpha1\nkind: Workspace\nmetadata:\n  name: golang\nspec:\n  git:\n    - repo: https://github.com/golang/go.git\n      branch: \"my-fix\"\n---\napiVersion: ax.io/v1alpha1\nkind: Task\nmetadata:\n  name: test\nspec:\n  workspaces:\n    - name: golang\n      goal: \"Ensure that Go tool chain is available and is built from source\"\n  debug: true   # lets you `ax ssh` into the sandbox\n```\n\nThen apply it, watch it come up, and look over the agent's shoulder:\n\n```\nax apply -f task.yaml\nax watch task test\nax ssh test -- ls -al /workspace\n```\n\nAgents are a new kind of workload. They are neither stateless microservices nor run-to-completion batch jobs. They accumulate state, need strict isolation, call out to model APIs and tool servers, and can burn money in a loop if nobody is watching. AX gives you four small primitives that handle all of that declaratively:\n\n| You want to... | AX gives you | \n|---|---|\n| Run untrusted agent code in an isolated sandbox with CPU/memory limits | **`Task`** | \n| Pre-wire Git repos, MCP servers, and skill packages so every agent starts warm | **`Workspace`** | \n| Lock outbound traffic down to an explicit host allowlist | **`Gateway`** | \n| Configure which LLM the platform itself uses, with credentials from a Kubernetes secret | **`Model`** | \n| Pause an idle agent and pick up exactly where it left off | `ax suspend` /`ax resume` | \n| Shell into a running agent to see what it is doing | `ax ssh` | \n\nEverything is expressed as `ax.io/v1alpha1` manifests and applied with a single command.\n\n```\ngo install github.com/google/ax/cmd/ax@latest\n```\n\nThis puts the `ax` binary in `$(go env GOPATH)/bin`. Make sure that directory is on your `PATH`.\n\nYou need a Kubernetes cluster, [`ko`](https://ko.build/) (` brew install ko`), a container registry your cluster can pull from, and a reachable Agent Substrate Control API (in-cluster default: `api.ate-system.svc.cluster.local:443`).\n\n```\nmake deploy AX_IMAGE_REPO=<your-registry>\n```\n\nThis deploys Redis, then builds and deploys the control plane images with `ko`. Everything lands in the `ax-system` namespace.\n\n```\nax apply -f examples/task.yaml       # Task + Workspace + Gateway + Model in one file\nax get tasks\n# NAME      ATESPACE   PHASE     ACTOR           WORKER-IP    AGE\n# task123   default    Running   task123         10.20.3.67   1m\n\nax watch task task123                # stream phase and condition changes live\nax ssh task123 -- ls -la /workspace  # poke around inside the sandbox\nax suspend task task123              # checkpoint and pause\nax resume task task123               # pick up where it left off\n```\n\nWant to see the whole lifecycle end to end? Run [`./demo.sh`](https://github.com/google/ax/blob/main/demo.sh). It applies a custom workspace, waits for readiness, runs commands over `ax ssh`, and suspends the task.\n\n| Guide | Read it to... | \n|---|---|\n| [Concepts](https://github.com/google/ax/blob/main/docs/concepts.md) | Learn what a `Task` ,`Workspace` ,`Gateway` , and`Model` each do, and how a task moves through phases and conditions. | \n| [Manifests](https://github.com/google/ax/blob/main/docs/manifests.md) | Write your own YAML, with an annotated example of every kind. | \n| [Sandbox](https://github.com/google/ax/blob/main/docs/sandbox.md) | See what the runner does on boot and what your command can rely on: metadata server, guest services, environment. | \n| [Runners](https://github.com/google/ax/blob/main/docs/runner.md) | Understand the contract between the control plane and the task container, and build your own runner image to replace the default. | \n| [Networking](https://github.com/google/ax/blob/main/docs/networking.md) | Reach a running task through the atenet router from the cluster, your laptop, or a gRPC client. | \n| [Architecture](https://github.com/google/ax/blob/main/DESIGN.md) | Understand how the control plane fits together, plus the [API reference](https://github.com/google/ax/blob/main/DESIGN.md#api-reference) . | \n| [Development](https://github.com/google/ax/blob/main/docs/development.md) | Build, test, and ship changes to AX itself. | \n\n`ax` talks to the control plane over gRPC. It is deliberately `kubectl`-shaped: `apply`, `get`, `describe`, `watch`, `delete`, plus a few agent-specific verbs.\n\n```\n# Apply anything (multi-document YAML, file or stdin)\nax apply -f examples/task.yaml\n\n# Tasks\nax get tasks                          # list\nax get tasks -a my-atespace           # list in another atespace\nax get task task123                   # full spec + live status as YAML\nax describe task task123              # human-readable detail\nax watch task task123                 # stream status and condition transitions\nax suspend task task123               # checkpoint actor state and pause\nax resume task task123                # resume a suspended task\nax delete task task123\n\n# Shell into the running sandbox\nax ssh task123                        # interactive shell (task needs spec.debug: true)\nax ssh task123 -- ls -la /workspace   # one-off command\nax ssh task123 -- python3 main.py\n\n# Gateways, workspaces, models follow the same pattern\nax get gateways\n# NAME              ATESPACE   LISTENERS             EGRESS-HOSTS\n# default-gateway   default    8494/gRPC,8080/HTTP   *\nax describe gateway default-gateway\nax delete gateway default-gateway\n\nax get workspaces\n# NAME                ATESPACE   GIT-REPOS   MCP-SERVERS\n# default-workspace   default    1           1\nax describe workspace default-workspace\nax delete workspace default-workspace\n\nax get models\n# NAME            ATESPACE   PROVIDER   MODEL\n# default-model   default    google     gemini-3.8-flash\nax describe model default-model\nax delete model default-model\n\n# Connection plumbing\nax ctx                                # active kube context and how ax is reaching the control plane\nax tunnel list                        # background tunnels (state lives in ~/.ax/tunnels)\nax tunnel stop\nax version\n```\n\n`ax` follows your active Kubernetes context. Switch clusters and `ax` resolves and tunnels to that cluster's control plane in the background.\n\n```\nkubectx staging-cluster\nax get tasks\n\nkubectx prod-cluster\nax get tasks\n\n# Or target a context without switching\nax --context=dev-cluster get tasks\n```\n\n| Flag | Description | Default | \n|---|---|---|\n| `-a` ,`--atespace` | Atespace scope for the command | `default` | \n| `-n` ,`--namespace` | Kubernetes namespace where AX is installed | `ax-system` | \n| `--context` | Kubernetes context to target | active `kubectx` /`current-context` | \n| `--server` | Control plane address, bypassing auto-detection | derived from kube context, or `$AX_SERVER` | \n\nApache License 2.0. See [LICENSE](https://github.com/google/ax/blob/main/LICENSE) for details.", "url": "https://wpnews.pro/news/google-ax-google-s-open-agentic-orchestrator", "canonical_source": "https://github.com/google/ax", "published_at": "2026-09-20 07:30:50+00:00", "updated_at": "2026-09-20 07:52:48.489723+00:00", "lang": "en", "topics": ["ai-agents", "ai-infrastructure", "developer-tools", "agent-protocols"], "entities": ["Google", "AX", "Agent Substrate", "Kubernetes", "ko", "Redis", "ax.io/v1alpha1"], "alternates": {"html": "https://wpnews.pro/news/google-ax-google-s-open-agentic-orchestrator", "markdown": "https://wpnews.pro/news/google-ax-google-s-open-agentic-orchestrator.md", "text": "https://wpnews.pro/news/google-ax-google-s-open-agentic-orchestrator.txt", "jsonld": "https://wpnews.pro/news/google-ax-google-s-open-agentic-orchestrator.jsonld"}}