AX: Een runtime voor agent-gebaseerde taken op schaal

Voorbeeld van gebruik

Configuratiebestand (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

Uitvoering via de command-line:

$ 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

Waarom AX?

Agents zijn een nieuw type workload. Ze zijn noch microservices, noch batch-jobs. Ze accumuleren status, hebben strikte isolatie nodig, maken verbinding met model-API's en tool-servers, en kunnen veel geld kosten in een oneindige lus als er niemand toezicht houdt. AX biedt vier kleine primitieven die dit alles declaratief afhandelen:

  • Task (Taak): Geïsoleerde uitvoering

Voer onbetrouwbare agent-code uit in een sandbox met CPU- en geheugenlimieten. Deze zijn goedkoop om te maken, te pauzeren en weg te gooien.

  • Workspace (Werkruimte): Eenvoudige inrichting

Lijst de Git-repositories, MCP-servers en vaardigheden op die een agent nodig heeft, of beschrijf simpelweg het doel. AX richt alles in elke sandbox in voordat de taak start.

  • Gateway: Netwerkbeleid

Definieer en beheer snel netwerkbeleid. Beperk het verkeer tot een expliciete 'allowlist' van hosts en poorten, en injecteer inloggegevens in inkomende verzoeken.

  • Model: Centraal beheer van configuratie

Configureer modellen, modelparameters en geheimen op één plek. Roteer een sleutel of pin een nieuwe modelversie met één apply-commando.

Hoe het werkt

AX schaalt op naar miljarden taken. Het draait bovenop Agent Substrate, een compute-runtime die vanaf de basis is ontworpen voor enorme dichtheid en snelle, stateful actor-levenscycli.

Miljarden taken

Elke taak draait als een lichtgewicht actor, waardoor je kunt schalen naar miljarden gelijktijdige agent-sessies per cluster zonder beperkingen vanuit de orchestrator.

Hervatting in minder dan een seconde

Inactieve agents die wachten op modelreacties, externe tool-aanroepen of menselijke reacties worden via checkpoints opgeslagen, gepauzeerd en binnen een seconde weer geactiveerd, zonder vertraging door een 'cold-start'.

Dichte multiplexing

Tientallen taken delen worker-resources, waardoor inactieve wachttijd wordt omgezet in reserve-rekencapaciteit. Je betaalt dus alleen wanneer agents actief nadenken en code uitvoeren.

Generatief platform

AX integreert generatieve AI direct in het platform. Als je bijvoorbeeld een werkruimte wilt inrichten door deze in gewone taal te beschrijven, wordt de omgeving automatisch voorbereid voordat je taak start.

Voorbeeld task.yaml voor een generatieve werkruimte:

apiVersion: ax.io/v1alpha1
kind: Task
metadata:
  name: data-analysis
spec:
  workspaces:
    - name: python-env
  goal: "Set up a Python 3 development environment"

Generatieve werkruimtes

Beschrijf in gewone taal hoe een klaarstaande omgeving eruitziet. AX draagt dit doel bij de eerste opstart aan een agent over om toolchains te installeren en afhankelijkheden te verifiëren.

Voer alles uit

Interactieve codeer-agents, langlopende agent-servers, Jupyter-notebooks, headless browser-testen en aangepaste tool-runtimes—alles is mogelijk.

Ideaal voor onderzoek

Start een enorm aantal reproduceerbare sandboxes op om trajecten te verzamelen, reinforcement learning-lussen uit te voeren en agents op schaal te evalueren.

Voor bouwers & onderzoekers

AX is gebouwd om de meest gebruiksvriendelijke runtime te zijn voor ontwikkelaars en onderzoekers. Het doel is om het beheer van agentic-infrastructuur te vereenvoudigen, zodat de focus kan liggen op het eigenlijke werk. AX is ontworpen met een compromisloze focus op ergonomie, snelle iteratie en prettige workflows.

De runtime is minimaal en lichtgewicht gehouden, terwijl de essentiële functies die nodig zijn om agents te bouwen, evalueren en schalen, zorgvuldig zijn toegevoegd.

Over AX

Ontstaan uit onderzoek, gebouwd voor productie.

AX is ontstaan bij Google, waar onderzoek naar agentic-runtime systemen samenkwam met frontier compute. Door jarenlang agentic execution engines te bouwen en te exploiteren, erkenden teams binnen Google dat agent-workloads een geheel nieuw computingsparadigma vertegenwoordigen: stateful, bursty, langlopende actors die een minuut intensief rekenen en vervolgens wachten op modelreacties, tool-reacties of menselijke goedkeuring.

Traditionele orchestrators, gebouwd voor stateless microservices of voorspelbare batch-jobs, worden kostbaar wanneer inactieve sandboxes draaiend worden gehouden, en ze missen native ondersteuning voor het pauzeren en hervatten van taken in minder dan een seconde.

Gebaseerd op onderzoek naar agentic-runtimes van Google DeepMind, samen met diepgaande ervaring in grootschalige isolatie, hervatting en scheduling, wordt AX ontwikkeld als een open, declaratief control plane specifiek voor de uitvoering van agents. Het abstraheert taken, werkruimtes, netwerkbeleid en modellen tot kernprimitieven, zodat ontwikkelaars en onderzoekers enorme vloten agents kunnen draaien zonder de onderliggende infrastructuur opnieuw uit te hoeven vinden. Dit project leunt zwaar op Agent Substrate, maar biedt specifieke agentic-abstracties en generatieve runtime-componenten.