Declare an agentic task. AX runs it at scale.
AX sandboxes your task, wires up its workspace, fences its network, and helps you run billions of them per cluster. Either use a single task per agent, or compose as many as your agent needs.
$ cat task.yaml
apiVersion: ax.io/v1alpha1
kind: Workspace
metadata:
name: golang
spec:
git:
branch: "my-fix"
apiVersion: ax.io/v1alpha1
kind: Task
metadata:
name: test
spec:
workspaces:
- name: golang
goal: "Ensure that Go tool chain is available and is built from source"
debug: true
$ ax apply -f task.yaml
workspace.ax.io/golang created
task.ax.io/test created
$ ax watch task test
Watching task default/test...
[10:42:01] Phase: Pending Actor: test WorkerIP:
[10:42:05] Phase: Running Actor: test WorkerIP: 10.20.3.67
Task reached terminal phase "Running".
$ ax get tasks
NAME ATESPACE PHASE ACTOR WORKER-IP AGE
test default Running test 10.20.3.67 5s
$ ax ssh test -- ls /workspace
go
$ ax ssh test -- cd /workspace/go && go build ./...
$ ax ssh test -- ps -o pid,cmd
PID CMD
1 /usr/local/bin/ax-task-runner
12 go build ./...
$ ax ssh test -- touch notes.txt
$ ax suspend task test
task.ax.io/test suspended
$ ax resume task test
task.ax.io/test resumed
$ ax ssh test -- ls notes.txt
notes.txt
$ ax suspend task test
task.ax.io/test suspended
$ ax delete task test
task.ax.io/test deleted
Why AX
Agents are a new kind of workload.
They are neither microservices nor 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.
Isolated execution
Run untrusted agent code in a sandbox with CPU and memory limits. Cheap to create, suspend, and throw away.
WorkspaceEasy workspace setup
List the Git repos, MCP servers, and skills an agent needs, or just describe the goal. AX sets it all up in every sandbox before the task starts.
GatewayNetwork policies
Define and quickly manage network policies. Lock traffic down to an explicit allowlist of hosts and ports, inject credentials to the incoming requests.
ModelOne place for config
Configure models, model parameters, and secrets in one place. Rotate a key or pin a new model version with one apply.
How it works
Scales up to billions of tasks.
AX runs on top of Agent Substrate, a compute runtime designed from the ground up for massive density and fast stateful actor lifecycles.
Every task runs as a lightweight actor, allowing you to scale to billions of concurrent agent sessions per cluster without orchestrator limits.
Idle agents waiting on model responses, external tool calls, or human responses are checkpointed, suspended, and brought back in under a second with zero cold-start delay.
Dozens of tasks share worker resources, turning idle waiting time into spare compute capacity so you only pay when agents are actively thinking and running code.
Generative platform
Generative features built into the platform.
AX integrates generative AI directly into the platform. For example, if you want to set up a workspace just by explaining it in plain English, the environment is prepared automatically before your task starts.
apiVersion: ax.io/v1alpha1
kind: Task
metadata:
name: data-analysis
spec:
workspaces:
- name: python-env
goal: "Set up a Python 3 development environment"
Generative workspaces
Describe what a ready environment looks like in plain English. AX hands that goal to an agent on first boot to install toolchains and verify dependencies.
Run anything and everything
Interactive coding agents, long-running agent servers, Jupyter notebooks, headless browser testing, and custom tool runtimes—you name it.
Perfect for research
Spin up massive number of reproducible sandboxes to collect trajectories, run reinforcement learning loops, and evaluate agents at scale.
For builders & researchers
Built to be the most friendly runtime for developers and researchers.
We want to make dealing with agentic infrastructure easier so you can focus on your work. AX is designed with an uncompromising focus on ergonomics, rapid iteration, and joyful workflows for both application developers and AI researchers.
We aim to keep the runtime minimal and lightweight, while tastefully adding the essential features everyone needs to build, evaluate, and scale agents.
About
Born from research, built for production.
AX was born at Google when agentic runtime systems research met frontier compute. Over years of building and operating agentic execution engines, teams across Google recognized that agentic workloads represent an entirely new computing paradigm: stateful, bursty, long-running actors that compute intensely for a minute and then wait for model responses, tool responses, or human approval. Traditional orchestrators built for stateless microservices or predictable batch jobs become cost-prohibitive when keeping idle sandboxes running, yet lack native support for sub-second suspend and resume.
Drawing on agentic runtime research from Google DeepMind alongside deep experience in large-scale isolation, resumption, and scheduling, AX is being built as an open, declarative control plane purpose-built for agent execution. It abstracts tasks, workspaces, network policies, and models into core primitives so developers and researchers can run massive fleets of agents without reinventing the underlying infrastructure. This project heavily relies on Agent Substrate but provides agentic abstractions and generative runtime components.
Facts Only
* The system includes an agentic platform named AX.
* AX manages tasks through workspaces, which define environments like Git repositories and goals.
* A specific task example involves setting up a workspace named 'golang' with a goal to ensure the Go tool chain is built from source.
* Tasks can be suspended and resumed, and deleted.
* The platform supports features such as isolated execution (sandboxing), network policies, model configuration, and generative workspaces.
* AX runs on top of Agent Substrate for massive density and fast stateful actor lifecycles.
* Idle agents are checkpointed, suspended, and resumed with zero cold-start delay.
Executive Summary
The system introduces an agentic platform called AX designed to manage and scale agent workloads by providing four core primitives: isolated execution via workspaces, easy workspace setup, network policies, and a centralized place for model configuration. The architecture is built on Agent Substrate, enabling scaling to billions of concurrent agent sessions through lightweight actor lifecycles that support sub-second suspend and resume functionality. This capability allows idle agents to be checkpointed without incurring cold-start delays, turning waiting time into spare compute capacity by sharing resources among active tasks.
The platform supports diverse use cases, including running interactive coding environments, large-scale research requiring reproducible sandboxes, and generative workspaces where goals can be described in plain English. The overall design prioritizes ergonomics, rapid iteration, and scalability for both developers and AI researchers who need to manage complex agent infrastructure.
Full Take
The framework establishes a paradigm shift by abstracting the complexities of running stateful, bursty agent workloads into manageable primitives. The core tension lies in balancing extreme scalability—running billions of tasks efficiently—with the need for strict isolation and rapid interruption/resumption capabilities essential for interactive reasoning. The emphasis on ephemeral, sandboxed execution alongside checkpointing addresses a critical infrastructure gap where traditional orchestrators fail to handle the cost inefficiency of idle stateful actors. This design suggests a move away from monolithic orchestration toward fine-grained, distributed control over agent states.
The implication is that the bottleneck in deploying advanced AI agents is often not the model itself, but the management and lifecycle of the execution environment. By providing primitives for isolation, networking, and checkpointing, AX attempts to redefine agent infrastructure as a specialized compute runtime optimized specifically for the non-deterministic, waiting nature inherent in agentic workflows. The challenge moving forward involves ensuring that this efficiency does not introduce new vectors for systemic risk or diminish the intellectual oversight required when deploying these powerful, self-executing systems at scale.
What metrics are used to quantify the cost savings realized by suspending idle agents versus the overhead introduced by maintaining the stateful actor infrastructure? How does the declarative nature of workspace setup inherently mitigate the risk associated with running untrusted code in a highly distributed sandbox environment? Does the focus on ergonomics for builders risk obscuring the deeper safety and control mechanisms necessary for rigorous research environments?
Sentinel — Human
The text reads as a high-level technical whitepaper or product description that successfully integrates code examples with abstract architectural reasoning, indicating strong human authorship.