google/ax v0.3.0: Google's agent orchestration runtime goes open source and takes off (+2,305 stars/day)
🔎 Google just laid down the infrastructure layer that AI agents were missing
September 23, 2026 will probably go down as the day agent orchestration became a full-fledged infrastructure topic. That day, google/ax v0.3.0 (Agent eXecutor) climbed to the top spot for AI topics on Hacker News with 481 points, and the repo showed a velocity of around +2,305 stars/day at the peak of the wave — for roughly 1,968 stars at the day's snapshot. For a project born on March 30, 2026, that's a rare signal.
Why now? Because the race for frontier models — GPT-5.5, Gemini 3 Pro Deep Think, Claude Opus 4.7 — no longer produces visible progress for the end user. The performance lever has shifted: it's no longer the model, it's the runtime that executes, isolates, retries, and audits millions of agent tasks.
Meanwhile, agents are leaving developer terminals to become mass-market products — Meta Muse, Meta's personal agent turned mass-market product, is the best illustration of this. An industry moving from prototype to production needs its Kubernetes. Google just opened up its own, under the Apache 2.0 license.
Key takeaways
- AX (Agent eXecutor) is Google's open source distributed agent runtime: harnesses, skills, tools, and isolated agents, with automatic recovery after failure or interruption. Apache 2.0, repo created March 30, 2026, 623 commits.
- v0.3.0 took the #1 AI spot on Hacker News on September 23, 2026 (481 points). The repo shows ~1,968 stars and 116 forks in today's snapshot, with a velocity of +2,305 stars/day at the peak of the HN wave.
- Split into three services: API frontend, reconciler, and a sandboxed task runner.
- Task state moves out of Kubernetes CRDs and into Redis Streams: etcd wasn't designed for the churn of millions of short-lived agent tasks.
- Stated ambition: the "Kubernetes of AI agents," with orchestration at the scale of billions of tasks per cluster.
Recommended tools
Good news: the AX stack comes down to four building blocks, all open source. You can test everything without spending a dime, then switch to managed offerings the day you move to production.
| Tool | Main use | Price (September 2026) | Best for |
|---|---|---|---|
| AX | Distributed agent orchestration runtime | Free (Apache 2.0) | Orchestrating fleets of isolated agents |
| Kubernetes | Recommended deployment foundation (Agent Substrate) | Free self-hosted; managed offerings vary (check cloud.google.com) | Production at scale |
| Redis | Task state via Redis Streams | Free self-hosted; paid managed offerings (check redis.io) | Absorbing the churn of short-lived tasks |
| Go | Toolchain for the ax CLI |
Free | Installing and experimenting locally |
For a broader view of the ecosystem, our selection of the best AI tools is updated every quarter.
What exactly is AX?
AX (Agent eXecutor) is Google's open source distributed agent runtime: a harness runtime that dynamically provisions isolated environments, from suspendable and resumable images, to run harnesses and agents. The code is public on GitHub, under the Apache 2.0 license — commercial use included, no strings attached.
The project is young but moving at an unusual pace: repo created on March 30, 2026, 623 commits, and already a v0.3.0 that managed to snag the top AI spot on Hacker News. That pace looks like a strategic product, not a lab experiment.
The README fully owns the positioning: "as we move away from monolithic agents toward distributed harnesses where tools, skills, and agents are deployed as isolated actors, a distributed runtime with dynamically spawned isolated workers becomes a necessity." In other words: when your agents call tools, skills, and other agents, someone has to handle isolation, resumption, and auditing. That someone is AX.
The concrete promises
The features claimed by the project read like an ops checklist:
- Distributed runtime: isolated harnesses, skills, tools, and agents, with dynamically spawned workers.
- Automatic resumption after failure or interruption — the one thing everyone promises and few actually deliver.
- Built-in harnesses for frontier models, so you can get started without writing glue code.
- Auditing & policy: all calls, human and agentic alike, coordinated by a common controller.
- Portability, with Kubernetes as the target experience.
- Harness- and model-agnostic: AX imposes neither framework nor vendor.
That last point deserves a closer look. Since AX is model-agnostic, you can point it at the agentic leaderboard leaders — GPT-5.5 (98.2), Gemini 3 Pro Deep Think (95.4), Claude Opus 4.7 (94.3) — or at self-hosted models like Kimi K2.6 or GLM-5 Reasoning. To make the call, our guide to the best LLMs for AI agents details the trade-offs.
Under the hood
The architecture targets multi-tenancy from the ground up: multi-tenant AX Server, event log storage, Control API, stateful actors per session-tenant, SnapshotService, and an MCP server. The native presence of an MCP server is no small detail: it plugs AX directly into the standard tool ecosystem, without an ad hoc gateway.
What v0.3.0 changes: a runtime that became three services
v0.3.0 splits AX into three distinct services — API frontend, reconciler, and sandboxed task runner — and it's this split, more than any single feature, that generated the buzz. According to AI Weekly, the release took the top AI spot on Hacker News with 481 points.
The three roles are crystal clear:
- The API frontend exposes the Control API: the single entry point for the task and session lifecycle.
- The reconciler runs the convergence loop, in the purest Kubernetes tradition: it continuously reconciles the observed state toward the desired state.
- The sandboxed task runner executes tasks in isolated environments, so a crash doesn't take down the entire fleet.
| Aspect | Before v0.3.0 | v0.3.0 |
|---|---|---|
| Task state | Kubernetes CRDs (and therefore etcd) | Redis Streams |
| Runtime organization | Less decoupled roles | Three services: API frontend, reconciler, sandboxed task runner |
This is exactly the pattern that made Kubernetes successful: decoupled roles, externalized state, disposable workers. Applying it to agents seems obvious in retrospect. It still had to be executed cleanly — and released under Apache 2.0.
Why task state is leaving etcd for Redis Streams
Because etcd wasn't designed for the churn of millions of short-lived agent tasks. That's the core argument of the release, and it's technical before it's marketing.
A useful reminder: etcd is Kubernetes' strongly consistent brain. It excels at handling a small number of stable objects that are rarely written and often read — configurations, secrets, deployment specs. Its strength is consistency, not raw throughput.
Agents completely invert this profile. A fleet of agents is a downpour of ultra-short-lived tasks: created, executed, completed, deleted within seconds — and that by the millions. Storing this state in Kubernetes CRDs pushes this constant churn through etcd, which is exactly what it wasn't designed for.
Hence the migration to Redis Streams: an append-only log structure built for throughput, with consumer groups and controlled retention. Task state stops being a collection of strongly consistent objects and becomes a stream. It's the trade-off that every platform eventually makes when moving from "a few important things" to "masses of ephemeral things."
My take: this migration says more about the team's maturity than any star count. Knowing where NOT to use etcd is the hallmark of people who have already pushed it to its limits.
Google's strategy: the "Kubernetes of AI agents"
Google isn't releasing yet another agent: it wants to own the layer on which everyone else's agents will run. The stated ambition is crystal clear — to become the "Kubernetes of AI agents", an open source background runtime capable of orchestrating billions of tasks per cluster.
Production deployment, incidentally, goes through Agent Substrate, the Kubernetes variant recommended by the project. The loop is coherent: Google masters K8s, controls its managed offering, and has just added the agents layer on top.
Let's replay the Kubernetes playbook, which was also born at Google: you open up the technology, the community adopts it, the ecosystem builds on top of it, and the original vendor monetizes the managed layer above. Apache 2.0 doesn't prevent you from making money; it only guarantees that no one can shut off the tap behind you.
The timing is no accident. Personal agents are becoming mainstream consumer products, and frontier capabilities are advancing before our eyes — our coverage of OpenAI's latest breakthrough on agent benchmarks is testament to that. The more capable the agents, the more orchestration becomes the bottleneck. Google is arriving precisely at the moment when this bottleneck becomes the number one problem.
How to try AX today
Two commands are all it takes to install the CLI and run a first execution.
go install github.com/google/ax/cmd/ax@latest
ax exec
For local experimentation, you don't need a cluster. For production, the project explicitly recommends the Agent Substrate on Kubernetes — portability is one of the runtime's stated commitments, not a future option.
Two tips for a useful first run:
- Start with an inexpensive model. Since AX is agnostic, first plug in a free or nearly free model via the free AI APIs (Groq, Google, OpenRouter), while you validate your orchestration pipeline.
- Keep control of your data while prototyping. If you want local models while AX handles the orchestration, our guide to open source AI agents with Ollama covers the setup.
One last tip, less glamorous: log everything from day one. Auditing and policy coordinated by a shared controller are one of AX's promises — you might as well design your workflows to take advantage of it, rather than rebuilding the audit after the fact.
AX in the agent-harness ecosystem: the runtime layer takes shape
AX isn't arriving in a desert: the entire harness/runtime layer is taking shape in open source, and Google's entry gives it its biggest boost yet. Three recent signals make this clear.
- Life-Harness: boosting LLM agents by 88.5% without retraining, the open source runtime revolution: agent performance is now played out at the runtime level, not just the model.
- Google DESIGN.md: the open-source standard that gives coding agents a visual memory: Google is already playing the open standards card on another front of the agents ecosystem.
- OpenSeeker-v2: open source breaks the monopoly of industrial search agents: open source is also chipping away at search agents, a segment we thought was locked down.
The pattern is the same everywhere. Frontier models are converging — GPT-5.5 at 98.2, Gemini 3 Pro Deep Think at 95.4, Claude Opus 4.7 at 94.3 in the agentic leaderboards — so differentiation is shifting to orchestration, memory, and tools. To situate AX on this map, our roundup of the best autonomous AI agents covers the key players.
My prediction: in twelve months, the question will no longer be "which model are you using?" but "which runtime are you running?". AX has just taken a head start on that question.
Limitations and Caveats
AX is the most exciting piece of the ecosystem in months — but it's a six-month-old project, not a platform proven over ten years. Three cautions are in order.
Maturity, first. Repo created on March 30, 2026, with v0.3.0 already shipped: the pace (623 commits) is impressive, but a project's APIs at this stage are still moving. Expect breakage between minor versions, and pin your versions in production.
Buzz metrics, next. The +2,305 stars/day figure corresponds to the velocity at the peak of the September 23 Hacker News wave; the snapshots diverge, with about 1,968 stars and 116 forks as of September 23. Virality measures attention, not production deployment — don't confuse the two.
The operational prerequisite, finally. The recommended production path runs through Kubernetes and the Agent Substrate. If your team isn't proficient with K8s, adopting AX carries a real upskilling cost — one to budget for before promising deadlines.
None of these limitations is a dealbreaker. But presenting them as negligible would be puffery — and this project deserves better than puffery.
❌ Common mistakes
Mistake 1: confusing an orchestration runtime with an agent framework
AX doesn't help you write an agent: it runs, isolates, restarts, and audits the ones that already exist. Comparing it to a development framework is beside the point, and leads to bad benchmarks. Solution: evaluate AX on operational criteria — failure recovery, isolation, auditability, portability — not on how easy it is to code an agent.
Mistake 2: reproducing the CRD pattern for task state
If you build your own orchestrator on Kubernetes with one CRD per agent task, you're recreating the bottleneck AX just fixed: etcd isn't built for the churn of millions of short-lived tasks. Solution: externalize task state into a stream-like structure such as Redis Streams, and leave etcd to what it does best — strongly consistent configuration.
Mistake 3: judging adoption by star velocity
+2,305 stars/day is a media flash in the pan: impressive on the day, unreadable a week later. Solution: track the slow signals — release cadence, commit volume (623 in six months, a sustained pace), quality of issues, early production feedback.
❓ Frequently Asked Questions
Is AX really open source?
Yes. AX is distributed under the Apache 2.0 license, a permissive license that allows commercial use, modification, and redistribution. The code is public on GitHub (google/ax), main branch, with approximately 1,968 stars and 116 forks as of the September 23, 2026 snapshot.
Does AX replace Kubernetes?
No, it's the opposite: Kubernetes is the recommended deployment target, via the Agent Substrate. AX behaves like a specialized layer on top of K8s, with its multi-tenant AX Server, its Control API, and its task state offloaded to Redis Streams.
Which models does AX work with?
AX is model- and harness-agnostic, with built-in harnesses for frontier models. In practice: GPT-5.5, Gemini 3 Pro Deep Think, or Claude Opus 4.7 on the API side, Kimi K2.6 or GLM-5 Reasoning on the self-hosted side. The choice of model remains an architecture decision, not a tool constraint.
Do you need to be a Kubernetes expert to use AX?
For testing, no: the CLI installs with a single Go command and runs with ax exec. For production, in practice yes: the recommended deployment goes through Kubernetes and the Agent Substrate, which assumes solid operational skills within the team.
Is AX production-ready?
The project is clearly prepared for it: multi-tenancy, auditing & policy, automatic recovery, SnapshotService. But v0.3.0 is still recent for a project born on March 30, 2026. Our advice: evaluate on a non-critical scope, then scale up gradually.
✅ Conclusion
By splitting its runtime into three services and migrating task state to Redis Streams, Google has just addressed the real bottleneck of agents in production — and claimed the throne of "Kubernetes for AI agents" before anyone else could. To follow the rest of the saga, head over to our current AI trends.