Google has opened a new platform for building and running agent workloads, and it’s being billed as a step up from the microservice and batch jobs of the past. The company calls it AX, and it’s built to run billions of agent tasks at once, each in its own sandbox. The announcement describes it as a runtime for developers and researchers who want to treat agents like first-class resources.
The project’s promise is straightforward: AX is a set of four small building blocks that can manage every task through YAML files and command-line commands. It handles running untrusted agent code inside a sandbox, setting up workspaces, managing network policies, and configuring models, all declaratively. The work was developed at Google, drawing on that company’s work on agentic runtime systems and frontier compute.
A Single Task, or Many
The simplest example in the documentation shows a task that runs inside a sandbox, where AX itself manages the environment. The task in question clones a Git repo, builds the Go toolchain from source, and runs a few commands inside that sandbox. To get started, a task.yaml file is used to declare the workspace, the Git repo, and the goal, after which the ax apply command is used to fire it up.
The first YAML document sets up a workspace named golang by referencing a Git repository at https://github.com/golang/go.git. It specifies the branch as “my-fix”, which is the main branch of the project.
The second YAML document defines a task named test that depends on the golang workspace. The task’s goal is “Ensure that Go tool chain is available and is built from source”, and the debug setting is enabled.
The ax apply command builds the workspace and the task, while ax watch tracks its progress through phases. Within a few seconds, the task runs within a sandbox, and SSH lets you log in to examine the process tree.
A task called default/test is being watched for activity. It first appeared in 10:42:01, when its phase was marked as Pending with an Actor of test and no associated WorkerIP. The task then moved into a running state later, with the same Actor test. That change was recorded in 10:42:05, and the system also attached the WorkerIP 10.20.3.67 to that entry. The task reached its final phase of completion shortly after, which is labeled as “Running”.
You can start a shell inside the sandbox using the ax ssh command. Once the shell is running, you have access to common commands like ls, cd, go build, ps, and touch. The platform also lets you suspend and resume tasks while keeping your place in the session, so you don’t lose state.
What AX Is For
AX is a runtime geared toward developers and researchers, designed to simplify working with agentic infrastructure so you can concentrate on your work. The platform keeps things lightweight and minimal, including only the essential features needed to build, test, and scale agents.
The project began with research and was constructed for production use. It started at Google, where agentic runtime systems research met frontier compute resources. Through years of building and running agentic execution engines, teams across Google observed that agent workloads define a new computing model: stateful, bursty, long-running actors that compute intensely for a minute, then wait for model responses, tool responses, or human approval.
The orchestrators designed for stateless microservices or predictable batch jobs carry a heavy cost when idle sandboxes must be kept running. They lack native support for sub-second suspend and resume. AX is being built as an open, declarative control plane purpose-built for agent execution.
The Four Primitives
The AX project strips down tasks, workspaces, network policies, and models into basic building blocks. This lets developers and researchers run huge agent fleets without rebuilding the underlying foundation from scratch. The project depends heavily on Agent Substrate, while also supplying its own agentic abstractions and generative runtime parts.
The isolation primitives stand out as the defining feature. Untrusted agent code runs inside a sandbox with CPU and memory limits, a setup that is cheap to create, suspend, and discard. Workspaces are quick to arrange. List the Git repos, MCP servers, and skills an agent needs, or simply describe the goal — AX handles all the setup in every sandbox before the task begins.
Rapidly define and manage network policies. Explicitly allow only a specific list of hosts and ports, and inject credentials into incoming requests. Model configuration happens in one location. A single apply rotates a key or pins a new model version.
Generative Workspaces
The platform comes with a feature that creates pieces automatically. You can describe a workspace in simple words and the environment prepares itself before your task starts. The announcement gives a Python example to show how it works.
The specification for the task has an api version of ax.io/v1alpha1 and a kind of Task. It carries a name of data-analysis, along with a workspace named python-env. The goal for that workspace is “Set up a Python 3 development environment”.
Before your task begins, the environment gets set up on its own. What a prepared environment should look like is explained in simple terms, and AX gives that job to an agent when it first starts up, so it can put in the necessary tools and check that everything needed is there.
What Runs in AX
The hosting supports a broad variety of computing tasks. Interactive coding agents, long-lived agent servers, Jupyter notebooks, headless browser testing, and custom tool environments — the list goes on. The announcement holds that AX is ideal for research.
The platform is designed to manage the scale of running reproducible sandboxes, collecting their trajectories, running reinforcement learning loops, and evaluating agents without hitting limits. Massive numbers of such sandboxes are spun up to gather the data needed for these processes.
| Primitive | Description |
|---|---|
| Task | A single unit of work, running in a sandbox |
| Workspace | A Git repo, MCP server, or skill the agent needs |
| Network policy | An allowlist of hosts and ports |
| Model | A configuration for models, parameters, and secrets |
The Suspend Dance
Restarting and reactivating tasks is a central part of the system’s design. The AX checkpoints pause agents that are idle while waiting for model answers, outside tool requests, or human reactions, then bring them back within a second and without any initial delay. With many tasks sharing worker resources, the time agents spend waiting becomes extra computing power that can be used elsewhere, so charges are only incurred when agents are actually thinking and running code.
The example commands document every step of the task’s life cycle. The ax watch command follows the task from Pending to Running. The ax ssh command lets you enter a shell inside the sandbox. The ax suspend and ax resume commands pause the task and bring it back to life. The ax delete command removes the sandbox entirely.
The Bottom Line
The platform is genuine, and the demonstration commands prove it by showing a working system from git checkouts through SSH sessions to suspending tasks. The story moves through each command in a way that makes the platform feel genuinely useful.
AX is a real platform with real commands behind it. Both application developers and AI researchers are the intended audience for the platform, which is built with a relentless emphasis on ergonomics, fast iteration, and enjoyable workflows.
Source material: “Google's Open Agentic Orchestrator,” agentexecutor.io.
Get the Notebook.
The day's best stories and every fresh verdict, in plain English, in your inbox by seven. One email a day, no more.