A2A Connected the Agents. Now Someone Has to Route Them.

The Directory Problem

When Google unveiled the Agent2Agent Protocol in April 2025 and donated the specification, SDKs, and developer tooling to the Linux Foundation two months later, the industry finally received a standardized vocabulary for AI agents to discover one another, advertise skills via Agent Cards, and exchange messages over HTTPS. More than a hundred companies—including AWS, Microsoft, Salesforce, SAP, and ServiceNow—have lined up behind the specification, treating it as the interoperability fabric that keeps agent networks from collapsing into bespoke point-to-point plumbing. The Linux Foundation stewardship was designed specifically to prevent any single vendor from reclaiming control later. But discovery is a directory problem. The harder question is what happens after the handshake: who actually does the work, who joins late, and who should quit while they are behind. That runtime void is where Sprix AI, the A2A initiative of Chinese firm 屿智同行, has dropped its open-source research preview, the SAGE Router. The repository has collected roughly 677 GitHub stars and a flurry of LinkedIn attention not because it invents another agent framework, but because it attempts to formalize the scheduling logic that every multi-agent demo eventually needs and almost none provide.

Three Routes, One Utility Function

The project’s full name—State-Aware Graph Exchange—hints at its ambition. SAGE sits conceptually above the A2A protocol, ingesting live Agent Cards, task requirement DAGs, and execution state, then emitting a routing decision. Its reference implementation is a single Python file with no runtime dependencies, a deliberate austerity that keeps the focus on the algorithm rather than framework lock-in. The authors have already sketched how production integration would map A2A signals into SAGE’s internal world: AgentCard.skills become normalized capability vectors, security requirements become hard permission filters, supported input and output modes become compatibility gates, and provider quotes become structured bids with cost, latency, and confidence. Task status, artifacts, and failures feed into an ExecutionState that tracks completed DAG nodes and transfer loss. Yet the current prototype intentionally stops short of transmitting tasks. It returns the decision—mode, team topology, schedule—while an external A2A client must still execute the selected route through message sends, streaming, or polling.

Most current multi-agent systems, according to the Sprix team, either freeze a plan at the outset or loop blindly until something works. SAGE rejects both approaches. It re-evaluates routing while execution is already underway, weighing accumulated progress, completed DAG nodes, failures, and transferable context before deciding whether switching agents is worth the disruption. The model defines three competing routes that share a single auditable utility function. In SELF mode, the incumbent agent keeps the task. In COLLABORATE mode, the incumbent retains ownership but recruits a complementary team. In HANDOFF mode, a peer takes full control. These are not disconnected heuristics or hard-coded state machines; they are candidates in an optimization that scores each configuration by predicted success, then penalizes it for cost, latency, risk, context-transfer loss, and coordination overhead.

The mathematics underneath are refreshingly explicit. For any requirement, SAGE combines global and requirement-conditioned trust into a calibrated capability score. Team coverage is computed as the probability that at least one member satisfies the requirement, derived from the product of individual failure probabilities. Once coverage is established, the system assigns each remaining requirement to the strongest calibrated member, serializes work bound to a single agent, and parallelizes independent assignments across agents. The result is an inspectable communication topology with a critical-path latency estimate. Every feasible route—solo, team, or handoff—then faces the same utility equation. The equation starts with the expected value of success, then systematically subtracts cost, critical-path latency, risk, context-transfer loss, and coordination overhead, while also penalizing uncertainty and rewarding exploration. The authors note that the lightweight online predictor can later be swapped for a production reward model, but even in its current form it replaces the brittle fixed-success assumptions common in static orchestrators. This is not a neural network black box; it is a structured objective that an operator can inspect and, in theory, regulate.

Complementarity Over Prestige

What distinguishes SAGE from the growing pile of multi-agent frameworks is its insistence on complementarity over prestige. A team is scored for marginal requirement coverage, not for stacking individually famous agents. An agent that excels at coding receives no automatic credit for research tasks; trust is contextual and learned per requirement. The search for teammates is bounded by beam search rather than greedy sequential addition, and permission constraints are applied as hard filters before any capability scoring begins. The output is deliberately auditable: every decision carries assignments, topology, success estimates, coverage maps, cost, latency, risk, utility, and a human-readable rationale. In a domain where routing choices are often buried inside prompt templates or hidden behind opaque LLM reasoning, SAGE treats the decision itself as a first-class artifact.

The Stack Above A2A

The timing is strategic. The A2A protocol provides the wiring, but the ecosystem is already accumulating higher-level layers. A recent research paper on multimodal modality-native A2A routing, for instance, demonstrates how voice and image can flow through A2A without protocol modifications, provided the downstream reasoning layer is capable. SAGE occupies an adjacent layer: it assumes A2A transport and Agent Card discovery, then adds the intelligence to decide which agents should form the circuit. Meanwhile, practitioner reports from the OpenAI Agents SDK and LangChain ecosystems suggest that handoff patterns remain fragile; one community implementation noted that handoffs occasionally “don’t stick” and introduce latency bottlenecks. SAGE’s response is to replace ad-hoc delegation with a deterministic policy that learns from execution evidence, including per-requirement partial credit and quote-fidelity updates that calibrate an agent’s promised cost and latency against its actual performance. The ReputAgent directory categorizes SAGE alongside AutoGen and CrewAI, though SAGE differentiates itself by targeting deterministic, observable routing policies rather than conversational glue code.

Synthetic Wins, Real Questions

The project is not shy about its limits. The authors label it an early-stage research preview, explicitly warning that it is not a production SLA. The included benchmark runs 2,500 synthetic tasks across five seeds, and while the numbers favor the online learning variant—0.634 quality versus 0.507 for incumbent-only routing, with deadline misses dropping from 26.4 percent to 0.2 percent—the README practically pleads for skepticism. The team lists what a publishable evaluation still requires: confidence intervals over real executions, heterogeneous agent benchmarks, marketplace trace replay, calibration analysis, and adversarial conditions. That candor is rarer than the algorithm itself. The benchmark also reveals the trade-off honestly: online SAGE spends more than static SAGE to achieve higher quality, a cost that remains visible rather than being laundered through a capability-only score.

The Road to Production

SAGE also remains, for now, a decision engine in isolation. The prototype returns a routing choice—mode, assignments, topology—but intentionally does not transmit tasks over A2A. A production deployment would need signed Agent Card ingestion, authenticated identities, persistent event-driven recovery, and human approval gates, all of which sit on the roadmap. The current version is best understood as a rigorous specification executable in Python, a proof that routing can be framed as constrained optimization rather than prompt engineering. Its lack of runtime dependencies is elegant, but it also underscores the gap between a clean algorithm and a hardened service.

If the project succeeds, it could shift how agent networks are governed. Today, A2A gives agents a common language; SAGE suggests they also need a common scheduler, one that treats collaboration as a coverage problem and handoffs as a transfer-loss calculation. The risk is that the utility function’s many hyperparameters—weights for cost, latency, risk, overhead, and exploration—may prove harder to tune in messy real-world marketplaces than in a deterministic simulator. And as the awesome-a2a ecosystem list grows, SAGE will compete for mindshare against more mature frameworks with larger communities and richer SDKs. Its survival will depend on whether practitioners value interpretable routing over convenience.

Where SAGE goes next depends on whether the A2A ecosystem moves beyond demos. The roadmap calls for real A2A adapters, offline replay on anonymized Sprix marketplace traces, learned task-text embeddings for candidate retrieval, and eventually a distributed router service with observability and human approval gates. Those milestones will test whether a state-aware utility layer can survive contact with actual agent behavior—adversarial bids, churn, privacy constraints, and the inevitable moment when an agent’s self-assessed capability vector diverges from reality. Until then, SAGE stands as one of the more intellectually honest attempts to answer the question that A2A left open: once everyone can see everyone else, who actually gets the job?