Co-Author: Aaron Sempf & Michael Walmsley
In a previous article, I argued that agent ecosystems are at the same inflection point the web faced decades ago: before platforms, marketplaces, or exchanges could scale, discovery had to be standardized, open, and boring.
This piece builds on that foundation, with
Michael Walmsley’s Open-tethyr, an open-source SDK that provides the cache and tethering layer between agent discovery and agent coordination. If Agent Discovery eXchange (AX) defines how agents advertise themselves, Open-tethyr defines how ecosystems store, retrieve, and bind to those agents without centralising control.
If AX is the equivalent of early web discovery primitives, the next question becomes obvious:
how do we move from discovering agents to coordinating them at global scale without collapsing everything into a single platform?
The answer lies in separating discovery, coordination, and execution, and allowing each to evolve independently.
Discovery Comes Before Coordination (Again)
The web did not begin with a global website registry. It began with DNS for naming, HTTP for retrieval, and a handful of conventions for publishing machine-readable metadata. Only after those primitives stabilized did search engines, directories, and commercial platforms emerge.
The same ordering matters for agents.
Before brokers, supervisors, or exchanges can coordinate agents effectively, they need a reliable way to answer a simpler question: what agents exist, and what do they claim they can do?
AX is intentionally scoped to answer only that question.
It defines how agents advertise their existence and capabilities using existing internet infrastructure, typically via a well-known HTTPS endpoint. Nothing about execution, economics, or policy is implied.
That narrowness is not a limitation. It is what makes scale possible.
Crawling, Not Registration
One of the most important shifts enabled by open discovery is the move away from static registration.
In platform-centric models, every provider must onboard to every exchange. This creates friction, duplication, and artificial boundaries. In contrast, open discovery enables a crawler model.
Agents publish metadata.
Indexers crawl it.
Intermediaries decide what to do with it.
This is how the web works today, and it is how agent ecosystems avoid fragmenting tomorrow.
With AX, onboarding becomes publishing metadata, not integrating with a specific exchange API. Discovery becomes something intermediaries consume, not something agents submit to.
From Discovery to Working Memory
Discovery at global scale does not work without local access. When a broker or arbiter needs to select an agent, it cannot query the entire internet. It queries a local view, a cache populated by crawlers, direct publication, or federation with other caches.
Open-tethyr provides this layer. It is not a crawler. It is not a registry. It is the working memory that sits between discovery sources and the systems that consume them.
Crawlers populate it.
Publishers push to it.
Federated peers replicate across it.
The consuming application sees only a consistent interface for querying available agents and their capabilities.
This separation matters. Discovery protocols can evolve. Population mechanisms can vary by deployment. The cache abstraction remains stable.
Brokers as Arbiters, Not Registries
In multi-agent systems, coordination logic is implemented by an Arbiter or Supervisor. The Arbiter’s job is to reason over available agents, apply constraints and policy, rank candidates, and coordinate execution. It is a decision-maker, not a data collector.
The diagram below shows how open discovery changes the broker's role. Instead of acting as a registration gate or static registry, the broker (or Arbiter) queries from a cache of indexed agents and selects dynamically at runtime.
Discovery remains decentralized, while coordination and execution stay firmly under broker control.
AX standardizes discovery, not coordination. Brokers and Arbiters remain fully responsible for trust, ranking, and execution. This does not eliminate brokers or exchanges. It clarifies their role.
Open-tethyr provides the cache layer that the Arbiter queries against. How that cache is populated; crawlers, direct publication, federation, is independent of how the Arbiter reasons over it. The Arbiter applies trust filters, ranking, and eligibility rules before execution occurs. The broker remains fully in control of coordination and economics.
Discovery becomes open input, not gated membership.
This distinction mirrors the web again: search engines do not own websites; they index them.
From Discovery to Tethering
Discovery answers what exists. Tethering answers how you work with it. Agents must eventually be connected into structured, governed relationships. This is where tethering comes into play.
A tether is a governed, revocable binding between a subscriber and a published agent. It encapsulates access credentials, usage policies, and discovery metadata in a single relationship primitive.
Open-tethyr provides tethering as a first-class operation. Once agent metadata is cached, a consumer can establish a tether: requesting access, receiving credentials, and maintaining that relationship over time.
Discovery and coordination are explicitly decoupled. The cache holds what’s available; tethers define who can use it. Multiple consumers can tether to the same agent under different policies.
An exchange may apply its own ranking, trust, or policy logic. Another exchange may take a different approach. Both operate on the same substrate, Open-tethyr caches populated from the same discovery sources, federating without centralising authority.
This is not fragmentation. It is federation.
Why This Scales
Global scale does not come from tighter control. It comes from looser coupling.
Open discovery allows multiple brokers, exchanges, and coordination models to coexist. It allows agents to be indexed once and used many times. It allows trust, economics, and governance to evolve without breaking discovery.
Most importantly, it prevents the ecosystem from collapsing into a single chokepoint.
The web scaled because discovery was universal and coordination was competitive. Agent ecosystems will scale for the same reason.
The Pattern Is Familiar
DNS did not define search.
robots.txt did not define crawling behavior.
OpenSearch did not define ranking or monetization.
They made ecosystems possible.
AX plays the same role for agents. Open-tethyr provides the substrate that makes federation practical. Together, they let coordination systems, brokers, arbiters, and exchanges innovate independently.
Discovery first.
Coordination second.
Execution where it belongs.
If we want a global network of agents, we already know how to build one. We’ve done it before.
Top comments (0)