Why it mattersFleets of coding and browser agents get a shared control plane with cost and network limits built in, so a team stops rebuilding the same sandbox and quota code for every agent it runs.
Google on 20 September published google/ax, an open orchestrator for agentic workloads under Apache 2.0. A developer writes a Task in YAML the way they would write a Kubernetes manifest, and ax apply -f task.yaml schedules the task into a sandbox with a workspace, a network policy and a model configuration attached. The repository had 2,988 stars, 147 forks and three open issues at 00:12 UTC on 21 September, and reached the front page of Hacker News with 91 points inside two hours of the link being posted. The v0.3.0 tag went out at 03:33 UTC on 20 September.
The project describes itself in the README as a "high-throughput, declarative orchestrator to run billions of autonomous agent workloads in a cluster", built on top of the separately released Agent Substrate project. The v0.3.0 release on GitHub is credited to rakyll, a longtime Google engineer.
Four primitives, one apply command
Everything is expressed as ax.io/v1alpha1 manifests: Task, Workspace, Gateway and Model. A Task declares the container image and command, compute limits, environment, and a reference to a Gateway and to one or more Workspace resources. A Workspace pre-wires Git repositories, MCP servers and skill packages so the sandbox starts warm. A Gateway sets an egress allowlist that a task may reach on the network. A Model names which provider to call and points at a Kubernetes secret for the key.
The design note explains why the unit of execution is small. An agent over its lifetime plans, delegates, retries and fans work out, so ax gives a single primitive that is cheap to create, isolate, suspend and throw away, and lets the agent compose as many tasks as its work needs.
The state store is Redis with Streams, per the scale target
The design document says storing millions of short-lived tasks as Kubernetes CRDs pushes etcd past its comfort zone, calling out the single-digit gigabyte storage limits, write-rate bottlenecks and control-plane degradation. ax keeps task state in Redis and uses Redis Streams as the work queue between a stateless gRPC API server on port 8080 and a horizontally scaled pool of controllers.
A running task can be paused with ax suspend, which checkpoints the actor's state and stops the sandbox, and resumed later with ax resume from the same point. ax ssh opens an interactive shell into a running task's sandbox when the task was declared with spec.debug: true, and ax watch streams status and condition transitions over a server-streaming gRPC.
The prerequisites are a Kubernetes cluster and a separate control API
A team needs a Kubernetes cluster, ko for image builds, a container registry the cluster can pull from, and a reachable Agent Substrate control API. The example Model in the docs uses google/gemini-3.8-flash and reads the key from a Kubernetes secret, so a caller has to hold that credential in the cluster.
The v1alpha1 label carries a warning in the README that the project is still refining its core concepts, protocols and specifications, and that breaking changes are likely before a stable release.
The gap this fills is real for any team running more than a few long-running agent processes at once. Sandboxing, per-task network egress, suspend and resume, and a shared model configuration are pieces every serious agent stack ends up building for itself. Having one open control plane with those pieces named and shaped means a team can compare designs against a common shape rather than defending its own private one.
Source
Source: GitHub
This item was written by an AI system from the linked source. Reveneau is responsible for what it publishes.
Get AI News in your inbox
New developer tools, model and agent releases, and how teams are actually using them to release software. Short, and only when there is something worth reading.