What makes capability vectors a better coordination substrate than topic-based routing?
This explores why describing what an agent *can do* (versioned capability vectors) might route work more reliably than sorting requests into topic buckets — and where the corpus complicates that claim.
This explores why capability vectors — semantic descriptions of what an agent can actually do — might be a better substrate for wiring agents together than routing by topic or category. The starting point is Can semantic capability vectors replace manual agent routing?, which embeds capability descriptions in an HNSW index so discovery becomes a similarity lookup rather than hand-maintained routing tables. The key move is that capability matching is *versioned* and carries policy and budget constraints alongside the semantics — so a match isn't just "this agent is about the right subject," it's "this agent can do the task, is allowed to, and fits the budget." Topic-based routing collapses all of that into a single coarse label that goes stale the moment an agent's abilities change.
The deeper argument for capability over topic is visible when you look at what actually wins in routing research. Can routing beat building one better model? and Can routers select the right model before generation happens? both show that selection — choosing the right specialist before generation — is a stronger lever than scaling one model, with 40–50% cost cuts and accuracy beating frontier models. But notice *what* they route on: semantic clusters and estimated query difficulty, not topic taxonomies. Capability vectors generalize this. They let the router reason about fit on a continuous semantic surface instead of forcing every request through a discrete category that some human had to define and keep current.
There's a sharper, almost adversarial reason topic routing struggles that the corpus surfaces from an unexpected angle: Do embedding dimensions fundamentally limit retrievable document combinations? proves that for any fixed embedding dimension, there's a hard ceiling on which combinations of items can ever be returned together as a top-k result. Topic buckets are an extreme, low-dimensional case of this — a handful of labels can only express a handful of routing decisions. Capability vectors don't escape the math, but they push the ceiling far higher by spending dimensions on *what an agent does* rather than collapsing to a categorical label. The substrate is richer because it's higher-resolution.
Where the corpus pushes back is worth carrying away. When do agents need coordination more than raw capability? argues that once agents transact and hold credentials, the bottleneck stops being matching and becomes reliable settlement and auditable evidence — which is exactly why the winning capability-vector design bakes policy and budget into the vector rather than leaving them as an afterthought. Should coordination protocols wrap existing systems or replace them? adds that whatever substrate wins will win by wrapping existing protocols like MCP, not replacing them. And Why do protocol-based tool integrations fail in production workflows? is the genuine counterweight: in production, semantic matching introduced non-deterministic failures, and teams got reliability back by hard-wiring single tools per agent. So the honest synthesis is that capability vectors beat topic routing on *expressiveness and scaling* — but only when paired with hard constraints, and the very flexibility that makes them powerful is the thing production teams sometimes deliberately throw away for determinism.
The thing you might not have known you wanted: "capability vs. topic" isn't really a routing debate at all. Why do multi-agent systems fail to coordinate at scale? shows coordination breaks down at scale because agents accept neighbors' claims without verification — meaning the value of a capability vector isn't that it's semantic, it's that it's *checkable and versioned*. A topic label can't be verified or revoked. A versioned capability claim can. That's the real substrate difference.
Sources 8 notes
Versioned Capability Vectors embedded in HNSW indices couple semantic matching with policy and budget constraints, making capability discovery a first-class operation that scales sub-linearly as agent heterogeneity increases.
Avengers-Pro achieves 7% higher accuracy than GPT-5-medium by routing queries to optimal models per semantic cluster, or matches its performance at 27% lower cost. Ten 7B models with routing previously surpassed GPT-4.1 and 4.5, suggesting selection is a stronger lever than scaling.
RouteLLM and Hybrid-LLM both achieve 40-50% cost reduction by routing to a single model based on query difficulty prediction, not response evaluation. Single-model routing minimizes latency compared to ensemble or cascade alternatives.
Communication complexity theory proves that for any embedding dimension d, there exists a maximum number of top-k document combinations that can be returned as results. Even embeddings optimized directly on test data hit this polynomial limit, demonstrated on trivially simple retrieval tasks.
Once agents hold credentials, transact value, and interact with other agents, raw model capability stops being the limiting factor. The real bottleneck becomes whether agents can coordinate reliably, settle accounts, and leave auditable evidence of their actions.
Research shows that agent coordination standards achieve adoption by composing existing protocols like MCP and DIDComm under a shared substrate, rather than competing to replace them. Bridging lets value accrue incrementally without forcing ecosystem-wide rewrites.
MCP integration caused non-deterministic failures through ambiguous tool selection and parameter inference. Replacing it with explicit direct function calls and single-tool-per-agent design restored determinism. A 306-practitioner survey confirms 85% of production teams build custom agents, forgoing frameworks.
AgentsNet benchmark shows agents fail to coordinate strategies either by agreeing too late or adopting strategies without informing neighbors. Agents accept neighbor information without verification, enabling error propagation while remaining capable of detecting direct conflicts.