AX: Google’s Open Orchestrator for Agentic Workflows

AX is an open-source agentic orchestrator from Google designed to run, scale, and manage autonomous AI tasks as stateful actors. Unlike traditional orchestrators built for stateless microservices, AX provides a declarative control plane that supports sub-second suspension and resumption of agent sessions, enabling developers to manage billions of concurrent tasks per cluster.

Why Developers Need AX for Agentic Workloads

Agentic workloads differ significantly from standard microservices or batch jobs because they are stateful, bursty, and often long-running. Agents frequently compute intensely for short periods before waiting on model responses, tool outputs, or human intervention. AX addresses these specific needs by treating agents as lightweight actors rather than persistent, resource-heavy containers.

While AI coding agents are becoming common in development workflows, managing their infrastructure remains a challenge. AX provides a standardized way to handle the high density and fast stateful lifecycles required for these workflows. By using a "dense multiplexing" approach, dozens of tasks share worker resources, which reduces costs by ensuring you only pay for active compute time during model thinking or code execution.

The Four Core Primitives of AX

AX abstracts the complexities of agent infrastructure into four declarative primitives. These primitives allow developers to define the execution environment, security boundaries, and model configurations in a single task.yaml file.

These primitives ensure that every agentic task is reproducible and secure. For example, the Gateway primitive prevents agents from making unauthorized network calls, which is a critical security layer when running untrusted code or third-party tools.

Scaling to Billions of Tasks with Agent Substrate

AX is built on top of Agent Substrate, a compute runtime optimized for massive density. This architecture allows AX to handle billions of concurrent agent sessions without the overhead typically associated with traditional orchestrators like Kubernetes.

The system achieves this efficiency through sub-second resumption. When an agent is idle—waiting for a response from a Large Language Model (LLM) or a tool—AX checkpoints and suspends the task. It can then bring the task back online in under a second with zero cold-start delay when the required input arrives.

Generative Workspaces and Tool Integration

One of the standout features of AX is the "Generative Workspace." Instead of manually writing complex Dockerfiles or setup scripts, developers can describe the desired environment in plain English. AX uses an internal agent to interpret this goal, install the necessary toolchains (such as a specific Python or Go version), and verify dependencies on the first boot.

This capability is particularly useful when integrating with the Model Context Protocol (MCP). Developers can list required MCP servers in the workspace spec, and AX will wire up the workspace automatically. This reduces the friction of setting up interactive coding agents or headless browser testing environments.

Example: Declarative Task Definition

A typical AX task is defined in YAML, specifying the workspace goal and the repository to be used:

apiVersion: ax.io/v1alpha1
kind: Workspace
metadata:
  name: golang-env
spec:
  git:
    - repo: https://github.com/golang/go.git
---
apiVersion: ax.io/v1alpha1
kind: Task
metadata:
  name: build-test
spec:
  workspaces:
    - name: golang-env
  goal: "Ensure that Go tool chain is available and is built from source"

Comparing AX to Managed Agent Frameworks

AX provides a more "infrastructure-first" approach compared to managed offerings like the OpenAI Agents API. While managed APIs handle the orchestration behind a black box, AX gives developers a local or cluster-based control plane where they can ssh into tasks, inspect filesystems, and manage network policies directly.

This level of control makes AX suitable for:

1. Research: Collecting trajectories and running reinforcement learning loops at scale.
2. Production: Running long-running agent servers or interactive coding environments.
3. Security: Using tools like Google Mantis for agentic vulnerability scanning within fenced networks.

According to the official documentation at agentexecutor.io, AX is designed to be a minimal and lightweight runtime that avoids the "cost-prohibitive" nature of keeping idle sandboxes running in traditional cloud environments.

How to Get Started with AX

To begin using AX, developers typically interact with the ax Command Line Interface (CLI). The workflow follows a standard "apply and watch" pattern similar to other cloud-native tools.

1. Install the AX CLI: Follow the instructions on the official AX website to set up the runtime.
2. Define your Task: Create a task.yaml file defining your workspace and the agent's goal.
3. Deploy the Task: Run ax apply -f task.yaml to create the workspace and task resources.
4. Monitor Execution: Use ax watch task [name] to see the phase transitions (Pending, Running, Suspended).
5. Interact with the Sandbox: Use ax ssh [name] -- [command] to run commands directly inside the agent's isolated environment.

For developers building complex, multi-agent systems, AX offers the ability to compose as many tasks as needed, either as standalone units or as part of a larger orchestrated workflow. This flexibility, combined with the power of Agent Substrate, positions AX as a foundational tool for the next generation of agentic infrastructure.