Google AX: Declarative Agent Orchestration with Kubernetes YAML

Google's AX has a pink axolotl as its mascot, which should give you some sense of the engineering culture behind it. But the axolotl's cute face hides something genuinely interesting: AX isn't just another AI framework trying to abstract away the hard parts of building autonomous agents.

It's declarative, which means you describe what you want your agent to do in YAML—yes, Kubernetes-style YAML—and the system figures out how to make it happen. Your task gets sandboxed, gets a workspace wired up, gets its network fenced off, and then you can run billions of these per cluster. You can go simple, one task per agent, or compose as many subtasks as your agent needs to actually get work done.

I'll be honest, when I first heard about another Google AI orchestration tool, I rolled my eyes. We have enough frameworks. But AX actually solves problems I've spent too many late nights debugging: environment isolation, resource management, and composability at scale. Whether that's enough to pull teams away from LangChain, CrewAI, or their own homegrown solutions is the question I'm dying to figure out.

Practical Implementation

Writing YAML to define agent workflows feels like the k8sification of AI was always inevitable, if only as a form of salary justification. I can understand why it was chosen, but I'm not a fan of writing a bunch of yaml when I could be writing code.

That said, the AX API does make it straightforward to define and deploy a real agent workflow programmatically. Here's how you set up a task with a workspace and execute it:

from ax.interface import AXClient

client = AXClient()
task = client.create_task(
    name="data-analysis",
    workspaces=[
        {
            "name": "python-env",
            "goal": "Set up a Python 3 development environment"
        }
    ]
)

results = client.run_task(task.id)
print(results.output)

The workspaces field is where you declare the environment each agent will operate in. In this case, we're asking the agent to provision a Python 3 environment before running any analysis code. You can chain multiple workspaces together if your workflow needs different environments at different stages.

What's actually happening under the hood is the AX platform translates your task definition into a series of containerized operations, manages the scheduling, and passes state between agents. You're not writing Kubernetes manifests by hand, which is nice. The platform handles the pod creation, resource allocation, and inter-agent communication — you just define what needs to happen, not how to schedule it.

task = client.create_task(
    name="ml-pipeline",
    workspaces=[
        {"name": "data-prep", "goal": "Download and clean dataset from S3"},
        {"name": "model-training", "goal": "Train a logistic regression model"},
        {"name": "validation", "goal": "Evaluate model accuracy and generate report"}
    ]
)

Each workspace runs in isolation but passes its output to the next one. The interface stays the same whether you're defining two workspaces or twenty. I've been running tasks with up to 15 stages and the only real friction point is writing good enough goal descriptions that the agents don't get stuck.

What Is AX and Why It Matters

Google's approach to integrating AI into Workspace feels like a company still figuring out what it's actually trying to build. The Gemini integration in Sheets, based on what I've seen from early users, delivers the kind of performance that makes you wonder if they tested it at all before shipping. Basic tasks that should be straightforward become frustrating little puzzles of "wait, why didn't that work?" It's the kind of experience that reinforces a pattern: Google announces big AI features with fanfare, then either abandons them or ships something that feels half-baked.

What strikes me about the community reaction is how much of it reads like resignation rather than anger. People aren't surprised that Google's AI tools underperform—they've been burned before. That skepticism isn't just about individual product quality; it's about trust. When your company has a reputation for killing promising projects, releasing half-finished AI features just adds another data point to an already long list.

I'm genuinely unsure whether Agent Substrate represents a meaningful architectural shift or another interesting experiment that'll get folded into something else six months from now. The technical approach might be sound, but architecture doesn't matter if the execution is sloppy and the commitment is questionable. Scion's appeal—maturity, integration, reliability—says as much about what developers actually want as it does about technical superiority.

The real question isn't whether Google can build good AI tools. It's whether they can build them consistently enough to overcome the habit of rolling out features that feel rushed and then quietly sunsetting them when adoption doesn't meet expectations. Until they solve that, I can't blame anyone for looking elsewhere.

Declarative Agent Workflows

The gap between Google's Gemini integration in Sheets and user expectations is wider than I'd like to see. People aren't just disappointed—they're frustrated that Google shipped what amounts to a half-baked feature under the weight of its own hype. The product feels more like a checkbox than a thoughtful integration, and that’s on a platform where users depend on reliability.

What stands out is the broader pattern: Google's track record with AI features and open-source projects has been uneven at best. Discontinuing products isn’t new, but doing so after building anticipation around AI capabilities adds a layer of skepticism. Users aren’t just evaluating features—they’re weighing trust. And right now, that trust is fraying.

This is why alternatives like Scion are gaining traction. It’s not just about having better performance on basic tasks; it’s about consistency and depth of integration. Ax and Agent Substrate have their merits, but Scion’s maturity and tighter ecosystem feel like a more reliable path forward. Whether that’s enough to shift long-term usage remains unclear, but it’s a signal I’d take seriously.

I’m genuinely uncertain how Google rebuilds credibility here. Technical fixes won’t be enough if users no longer believe the promises. Maybe that’s the real challenge: not building the best agent workflows, but earning the right to be in the conversation at all.

Building Autonomous Systems

What I see here is a gap between integration promise and actual utility. Google's approach to embedding AI into existing workflows—spreading it across Docs, Sheets, and now autonomous agents—feels increasingly scattered. The Gemini-in-Sheets disappointment isn't just about one model underperforming; it's symptomatic of a broader pattern where Google ships AI features before they're reliable enough to change behavior.

This matters because autonomous systems need consistency to be trusted with agency. An agent that can't reliably format a spreadsheet or follow a multi-step instruction is going to struggle with anything more complex. I'm skeptical that wrapping these underpowered integrations in an "autonomous" label solves the core issue: the underlying models and tooling aren't mature enough for independent action in productivity contexts.

I'm genuinely torn on Scion vs. Ax/Substrate. Scion's tight integration with Google's ecosystem is its strength, but that also means you're betting on Google's long-term commitment to keeping these APIs alive and improving. Ax and Agent Substrate feel more like infrastructure plays—less shiny out of the box, but more composable if you're building something that needs to outlive a single platform's roadmap. The real question is whether developers will trust Google to maintain these tools long enough to build on them, or if they'll keep reaching for something that smells less like abandonware.

Conclusion

AX's pink axolotl mascot feels almost quaint now, doesn't it? Here's this system that can run billions of concurrent agent tasks, each burning real money if something goes wrong, and they put a cartoon salamander on the dashboard. Maybe that's the point — make the terrifying thing friendly enough that developers will actually hand it the keys to their cloud bill.

The bigger question is whether "billions of tasks per cluster" matters more than it sounds. Most engineering teams aren't running agent fleets at Google scale. The real test isn't the theoretical ceiling — it's whether AX's Kubernetes-style YAML actually makes building agentic workflows simpler than duct-taping together existing tools. So far, the answer seems to be: mostly yes, for people already swimming in Google's ecosystem. Everyone else is still figuring out if they want to learn a new way to orchestrate agents just because it's declarative.

I'm genuinely curious what happens when these agents start talking to each other without human supervision. AX promises strict isolation and network fencing, but agents calling model APIs and tool servers in loops have a way of finding creative ways to escape their cages. The system can scale to billions, but can it scale human trust?