StackMap
Subscribe
Explore / ax
google

ax

Google's declarative runtime for agent workloads on Kubernetes: Task, Workspace and Model manifests run each agent sandboxed on Agent Substrate, with suspend/resume and ax ssh.

12,781 626 Go Apache-2.0updated 4 days ago
orchestrationsandboxes
View on GitHubDispute this mapping →
Curator's take

Worth watching if you run agents at fleet scale on Kubernetes. AX treats an agent as its own kind of workload, neither service nor batch job: declare a Task with a goal, a Workspace that pre-wires Git repos, MCP servers and skill packages, and a Model, then `ax apply`, `ax watch`, `ax ssh` into the sandbox, and suspend idle agents to resume later. kubectl users will feel at home. The catch is in its own warning banner: heavy development, v1alpha1 APIs and breaking changes expected before a stable release, and Agent Substrate must already run in your cluster. Not for a laptop or a single agent; for a stable Kubernetes primitive today, use agent-sandbox.

Mapped by ShipWithAI editors · links verified

Continue your stack

What teams reach for next — and why each earns a place beside ax. Ranked by curator confidence.

pairs wellalternativealternativellm-dagent-sandboxOpenSandboxax
pairs wellalternativebuilt withpick a node for the why · open it from the panel
Weekly digest
README.md3 min read

AX axolotl AX

[!WARNING] AX and several of its features are in heavy development. We are actively refining our core concepts, protocols, and specifications, and will likely introduce major breaking changes prior to a stable release.

Declare an agentic task with workspaces and model specifications. AX sandboxes it, wires up its workspace, and helps running it at scale.

AX is a high-throughput, declarative orchestrator to run billions of autonomous agent workloads in a cluster. It runs on top of Agent Substrate for sandboxed execution and is built to run billions of tasks per cluster. If you have used Kubernetes, ax will feel similar.

# task.yaml
apiVersion: ax.io/v1alpha1
kind: Workspace
metadata:
  name: golang
spec:
  git:
    - repo: https://github.com/golang/go.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   # lets you `ax ssh` into the sandbox

Then apply it, watch it come up, and look over the agent's shoulder:

ax apply -f task.yaml
ax watch task test
ax ssh test -- ls -al /workspace

Why?

Agents 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 three small primitives that handle all of that declaratively:

You want to... AX gives you
Run untrusted agent code in an isolated sandbox with CPU/memory limits Task
Pre-wire Git repos, MCP servers, and skill packages so every agent starts warm Workspace
Configure which LLM the platform itself uses, with credentials from a Kubernetes secret Model
Pause an idle agent and pick up exactly where it left off ax suspend / ax resume
Shell into a running agent to see what it is doing ax ssh

Everything is expressed as ax.io/v1alpha1 manifests and applied with a single command.

Quick start

Prerequisites

AX schedules every task as a sandboxed actor on Agent Substrate, so Substrate must be running in your cluster before you deploy AX. You need:

  • A Kubernetes cluster with Agent Substrate installed (see below)
  • Go and kubectl
  • ko (brew install ko) and a container registry your cluster can pull from

To install Agent Substrate, follow the instructions in the Substrate README. Substrate lands in the ate-system namespace and exposes its Control API at api.ate-system.svc.cluster.local:443, which is where AX expects to find it. Verify it is up before moving on:

kubectl get svc api -n ate-system

1. Install the CLI

go install github.com/google/ax/cmd/ax@latest

This puts the ax binary in $(go env GOPATH)/bin. Make sure that directory is on your PATH.

2. Deploy the control plane

With the prerequisites in place — most importantly a reachable Agent Substrate Control API — deploy the AX control plane:

make deploy AX_IMAGE_REPO=<your-registry>

This deploys Redis, then builds and deploys the control plane images with ko. Everything lands in the ax-system namespace.

3. Run your first task

ax apply -f examples/task.yaml       # Task + Workspace + Model in one file
ax get tasks
# NAME      ATESPACE   PHASE     ACTOR           WORKER-IP    AGE
# task123   default    Running   task123         10.20.3.67   1m

ax watch task task123                # stream phase and condition changes live
ax ssh task123 -- ls -la /workspace