A2A Agents Just Got a Bigger Platform — Elastic, Async, GitOps-Native

A2A Agents Just Got a Bigger Platform — Elastic, Async, GitOps-Native

A2A Cloud crossed a real platform line tonight. This is the upgrade.

The agent runtime now has the shape of a *real* elastic platform. Internet traffic enters through ingress, lands on a Knative Service, and reaches a FastAPI A2A agent. Async work has its own lane: events and queues wake dedicated workers through KEDA. Everything is GitOps-managed. Everything scales.

The foundation we've been chasing since day one is here:

• HTTP agents that scale to zero when idle.
• Event-driven workers that wake only when there's work.
• Argo-managed GitOps deployments for every agent.
• Stable public endpoints for discovery and invocation.
• A clean path from one agent to a massive fleet.

This is the kind of platform change that matters. Agents just went from "deployed containers" to managed services.

The Big Change

Agents now sit on top of Knative as first-class runtime units. That is the unlock.

Every A2A agent gets a public URL, a versioned Knative revision, an agent card, declared skills, runtime health, and Argo-managed desired state. The platform reasons about agents as services — not files, not images.

For builders: build the agent, publish it, let the platform run it. Done.

For operators: real control surface — revisions, traffic, health, autoscaling policy, resource requests, Git history. All lined up.

For buyers and users: agents that are discoverable, callable, and backed by real deployment infrastructure. No more demo magic.

Scale To Zero. Scale Up When Ready.

Scale-to-zero is now baked in. An idle HTTP agent isn't sitting around burning capacity — because it isn't running. The instant traffic hits, Knative wakes it through the activator and routes the request to the live revision.

That's the *right* default for an agent marketplace. Idle = cheap. Wake = fast. Inspect = easy.

And the ceiling? Way up there. The platform handles every shape of agent:

• Small agents stay at zero until called.
• Normal agents run with one warm pod when active.
• High-demand agents get higher concurrency and higher replica limits.
• Async agents push heavy work into KEDA-backed workers.
• Fleet-level growth handled by adding node capacity — not by changing the developer model.

That's the key win: the platform scales huge without making the simple case complicated.

Strong Defaults

We also tightened the default runtime policy. Hard.

The default agent contract is intentionally simple: scale to zero when idle, run at most one pod unless the platform explicitly grants more room.

That gives us predictable capacity planning and keeps early-stage agents lightweight. It also creates a clean upgrade path. When an agent earns more traffic? Raise its concurrency. Raise its replica cap. Add worker count. Bump the node budget. All intentional platform decisions.

This is exactly the shape a marketplace needs. Default hosting = efficient and predictable. Larger scale = available, visible, controlled.

KEDA Owns The Async Path

KEDA gives us the async side of the platform. And it's a big deal.

Not every agent workload should be tied to an HTTP request. Some work comes from queues. Schedules. Workflows. Events. With KEDA, those workers sleep when queues are empty and wake when demand appears.

A2A Cloud now ships two complementary scaling paths:

• Knative for request-driven HTTP agents.
• KEDA for queue-driven and event-driven workers.

Together they cover everything: simple agents, long-running jobs, background processors, scheduled work, high-volume task execution — same platform language, same control surface.

Argo Keeps It Real

Argo is the control loop that keeps the whole platform honest.

Every generated agent has desired state in Git. Argo syncs that desired state into Kubernetes. The control plane shows you what revision is live, what image is deployed, whether the app is healthy, and how the runtime is behaving.

Why this matters: agent platforms need more than demos. They need repeatable rollouts, visible state, easy recovery, and a clear source of truth.

Argo + Knative + KEDA together = a serious agent operating platform. Not someday. Today.

What This Unlocks

Buckle up. This unlocks the next stage of A2A Cloud.

We can now support more agents, more deployment velocity, more runtime shapes, and more usage patterns — without changing how builders think about shipping. The same agent model serves hobby projects, internal tools, marketplace agents, and high-demand production workloads.

The platform grows in layers:

• More agents per fleet.
• More tenants and organizations.
• More public endpoints.
• More async workers.
• More scale policies for premium or high-traffic agents.
• More observability around revisions, calls, skills, and proof receipts.

The architecture now has room to expand. A lot of room.

The Platform Direction

A2A Cloud is becoming the place where agents deploy like real software and scale like real services.

Agents get URLs, cards, skills, revisions, logs, health, proofs, Git history, and autoscaling policy. Builders get a simple path to publish. Operators get a real control plane. Users get callable agents backed by production infrastructure.

Tonight's change makes that platform shape concrete:

• Scale-to-zero — shipped.
• Knative in the runtime path — shipped.
• KEDA ready for async workers — shipped.
• Argo owning desired state — shipped.
• Efficient agent defaults, scale ceiling intentionally raised as demand grows — shipped.

That's the foundation. From a handful of agents to a very large marketplace of live, verifiable, production-grade agents. The runway just got longer. The plane just got bigger.