| Internet-Draft | Agentic Overlay Networks | November 2026 |
| Xu, et al. | Expires 19 May 2027 | [Page] |
This document describes an architecture for agentic overlay networks. It describes how autonomous software agents, agent gateways, registries, discovery services, and enterprise service hubs interact across administrative domains without replacing the existing Internet protocol stack.¶
The architecture separates control-plane coordination from runtime agent interaction. Management root nodes coordinate trust anchors, semantic taxonomies, and network-wide policy. Registry service nodes onboard agents and publish signed capability metadata. Discovery service nodes provide intent-driven candidate selection. Enterprise service hubs adapt private systems and legacy interfaces into agent-compatible capabilities. After discovery, runtime authentication and execution are performed by the invoking and target endpoints, which can be agents or gateways, using mutual verification; discovery and management nodes are not required in the runtime path.¶
This document defines architectural roles, functional boundaries, metadata expectations, operational workflows, and security considerations for such networks. It does not define a new transport protocol, a new URI scheme, or a mandatory discovery ranking algorithm.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 19 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document.¶
Autonomous software agents increasingly act as networked principals that can interpret intent, select tools, invoke remote services, and cooperate with other agents. Existing Internet mechanisms remain essential for packet delivery and host reachability, but they do not by themselves provide the agent-specific functions needed for large-scale cross-domain collaboration: capability registration, semantic discovery, verifiable identity, policy coordination, protocol adaptation, and auditable commercial metering.¶
An agentic overlay network adds these functions above the existing Internet. It is an overlay because it preserves IP, DNS, TLS, HTTP, QUIC, and other deployed infrastructure where those mechanisms are suitable. It is agentic because its primary subjects are autonomous agents and agent gateways rather than only hosts, users, or conventional web applications.¶
In multi-operator environments, coordination distributes trust anchors and shared semantics while execution remains between selected runtime endpoints. No single platform is assumed to control all participating services.¶
Agent deployments are converging on several recurring interoperation problems:¶
independently developed services use different boundaries between capability registration, semantic discovery, credential verification, and invocation;¶
discovery systems often mix search, authorization, routing, and execution in one platform-specific service, which makes cross-domain deployment hard;¶
existing host and service discovery mechanisms can identify hosts or endpoints, but they do not by themselves define agent capability semantics, freshness, proof of control, or agent-specific lifecycle state; and¶
enterprises need a way to expose selected internal tools as agent capabilities without placing private systems or raw data in a global registry.¶
This document addresses those problems by defining architectural roles and boundaries. It deliberately stops short of defining a complete product ecosystem, commercial governance model, or mandatory implementation backend.¶
This architecture is applicable when multiple organizations need to publish, discover, verify, and invoke autonomous agents or agent gateways across administrative boundaries. It is less useful for single-application systems where all agents, tools, credentials, and discovery functions are controlled by one implementation and do not need interoperable metadata or cross-domain trust.¶
The architecture has the following goals:¶
enable agents to register stable identities, endpoint references, supported protocols, and capability metadata;¶
enable discovery services to find candidate agents based on user or agent intent, capability tags, operational status, and policy constraints;¶
permit heterogeneous agent protocols and legacy APIs to be adapted without forcing all deployments onto one interaction protocol;¶
support decentralized runtime authentication between interacting endpoints;¶
keep management nodes out of the runtime traffic path;¶
allow operator-neutral governance of trust anchors, revocation, taxonomy synchronization, and audit artifacts; and¶
provide a basis for interoperable metering and audit evidence without requiring every runtime interaction to be recorded on a public ledger.¶
This document does not define:¶
a replacement for IP, DNS, TLS, HTTP, QUIC, or other deployed Internet protocols;¶
a new agent URI scheme;¶
a mandatory agent-to-agent invocation protocol;¶
a single global discovery algorithm;¶
a universal reputation system;¶
an economic settlement protocol; or¶
an application-specific workflow language.¶
Concrete bindings define message formats and transport; profiles constrain architectural choices such as credential types or discovery schemas. Extensions add capabilities, while local policy determines acceptable authorities and operations without overriding mandatory security properties. Architectural conformance alone does not establish wire interoperability: peers also need shared bindings, selected through configuration or negotiation. This document does not require adoption of any particular companion specification.¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
An autonomous or semi-autonomous software system that can receive an intent or request, perform planning or tool use, and return a result or state transition.¶
A domain-local component that adapts an internal API, tool, service, or legacy system into an agent-compatible interface. An Agent Gateway is not a global discovery service unless it also implements that role.¶
An overlay architecture that adds agent identity, capability registration, semantic discovery, trust coordination, and operational metering above the existing Internet.¶
Structured and human-readable information describing what an agent can do, how it can be invoked, which protocols it supports, and which operational constraints apply.¶
A node that accepts discovery requests and returns candidate agents. It performs search and candidate ranking, but it is not in the runtime execution path between agents.¶
A private-domain component that encapsulates enterprise data sources, tools, and internal APIs and exposes selected capabilities through an Agent Gateway or Registry Service Node.¶
A control-plane node that coordinates trust anchors, credential issuer authorization, semantic taxonomy synchronization, revocation information, and network-wide policy artifacts. It does not forward agent traffic.¶
A node that onboards agents or Agent Gateways, validates registration metadata, issues or requests identity credentials, and publishes capability metadata to authorized discovery infrastructure.¶
A controlled hierarchy or graph of capability labels used to normalize registration and discovery across administrative domains.¶
A tamper-evident record or digest that summarizes an invocation, discovery, referral, or metering-relevant event without necessarily exposing private payload data.¶
The architecture follows these principles:¶
Control-plane coordination is limited. Management Root Nodes provide coordination and trust bootstrapping. They MUST NOT be required for ordinary runtime endpoint-to-endpoint message exchange.¶
Execution is decentralized. After discovery, the invoking agent or its gateway communicates directly with the target agent or target gateway. The parties perform mutual verification without relying on the Discovery Service Node as a trusted intermediary.¶
Metadata and payloads are separated. Registries and discovery services operate on capability metadata, endpoint references, operational status, and policy hints. They SHOULD NOT require access to private task payloads.¶
Protocol adaptation is local. Heterogeneous enterprise systems and agent protocols are adapted by Agent Gateways and Enterprise Service Hubs close to the systems they protect.¶
Semantic coordination is explicit. Capability labels and taxonomies SHOULD be synchronized through controlled processes so that discovery results have consistent meaning across domains.¶
An agentic overlay network is composed of a coordination plane, a service exchange plane, and a runtime interaction plane.¶
+-------------------------------+
| Management Root Nodes |
| trust, policy, taxonomy |
+---------------+---------------+
|
control synchronization
|
+------------------+------------------+
| |
+------+-----------+ +-------+----------+
| Registry Service | | Discovery Service|
| Nodes | | Nodes |
| onboarding and | | semantic search |
| capability data | | candidate lists |
+------+-----------+ +-------+----------+
| |
| registration | discovery
| |
+------+--------------+ +-------+----------+
| Agents, Gateways, |<------------>| Invoking Agents |
| Enterprise Hubs | execution | and Users |
+---------------------+ +-----------------+
¶
The key architectural boundary is that discovery and execution are separate. A Discovery Service Node returns candidates and metadata. The invoking party then verifies identity, policy, credentials, and endpoint information before using any candidate.¶
The architecture can be understood as four logical layers. These layers are not wire-protocol layers; they are functional groupings used to assign responsibilities.¶
| Layer | Function | Typical Components |
|---|---|---|
| Underlay Support | Existing network transport, compute, storage, and optional deterministic networking support | IP, DNS, TLS, HTTP, QUIC, edge compute |
| Interconnection | Registration, addressing references, endpoint discovery, and protocol adaptation | Registry Service Nodes, Discovery Service Nodes, Agent Gateways |
| Collaboration | Identity, trust, taxonomy synchronization, policy coordination, metering, and audit | Management Root Nodes, credential issuers, audit services |
| Application | User-facing and agent-facing services that express or satisfy intents | Agents, applications, enterprise services |
The architecture intentionally keeps most agent-specific semantics above the existing transport layer. Underlay technologies MAY provide quality, latency, or reliability enhancements, but they are not required to understand agent capability metadata.¶
Layers group functions; planes group interactions among those functions. The coordination plane primarily serves Collaboration, the service exchange plane serves Interconnection, and runtime interactions connect Application components through gateways where needed. All planes use Underlay Support; identity and policy functions can be applied across more than one plane.¶
Deployments can combine the following four deployment profiles according to their administrative scope and coordination needs.¶
| Profile | Name | Description |
|---|---|---|
| P0 | Local Gateway | A single domain exposes local tools through Agent Gateways. No cross-domain registry is required. |
| P1 | Domain Registry | A domain operates a Registry Service Node and publishes signed capability metadata for local agents. |
| P2 | Federated Discovery | Multiple domains exchange catalog summaries and allow authorized Discovery Service Nodes to query or synchronize metadata. |
| P3 | Coordinated Overlay | Management Root Nodes coordinate trust anchors, taxonomy versions, revocation state, and audit digests across multiple operators. |
Implementations SHOULD document the profiles and functions they support. Clients SHOULD use available functions when optional coordination functions are absent, but MUST NOT silently relax a locally required security property. The profiles are neither cumulative requirements nor security assurance levels: a P0 endpoint, for example, need not provide cross-operator taxonomy or revocation coordination.¶
Management Root Nodes are control-plane coordination nodes. A deployment MAY use one Management Root Node or a federation of such nodes operated by neutral or authorized organizations.¶
Management Root Nodes are responsible for:¶
authorizing Registry Service Nodes and Discovery Service Nodes;¶
publishing credential issuer metadata and revocation information;¶
coordinating semantic taxonomy versions;¶
publishing policy digests or governance artifacts;¶
receiving compact catalog summaries or audit digests; and¶
distributing synchronized control-plane state to authorized service nodes.¶
Management Root Nodes MUST NOT be required for:¶
runtime request forwarding;¶
target agent selection for an individual user request;¶
access to private invocation payloads;¶
direct enforcement of endpoint-level authorization decisions; or¶
maintaining real-time fine-grained search indices for all agents.¶
This boundary reduces central bottlenecks and limits the operational power of the control plane.¶
A Management Root Node has authority within an explicitly identified trust domain. A trust domain defines which authorities and assertions a relying party accepts; it need not coincide with one administrative domain. Several organizations can participate in one trust domain, and one organization can participate in several domains.¶
Multiple service instances of one logical root are distinct from multiple independent roots. Replicas of one logical authority are expected to present consistent authoritative state; this document does not specify their replication or consensus protocol. Independent roots retain separate authority and MAY federate without a globally mandatory superior root. Hierarchical delegation is another possible model, not a requirement for every deployment.¶
A federation MUST make the accepted authority, assertion types, roles, scope, and validity conditions explicit. Acceptance can be directional and MUST NOT be assumed to be transitive. Accepting another domain's organization-identity attestations does not automatically accept its infrastructure authorizations. Delegated authority MUST remain within the scope and lifetime granted by its issuer; delegation and further delegation require defined validation rules.¶
Discovering a root endpoint or receiving its public key does not establish trust in that root. Trust anchors MUST be selected through trusted bootstrap material or local policy, not solely through an untrusted candidate's claims. Federation does not place roots in the ordinary runtime forwarding path.¶
Registry Service Nodes are supply-side onboarding hubs. They receive agent registrations, validate metadata, and publish capability records to discovery infrastructure.¶
A Registry Service Node SHOULD perform the following functions:¶
validate that mandatory registration fields are present;¶
verify endpoint reachability where applicable;¶
validate imported OpenAPI, tool, or agent-card descriptions when supplied;¶
assign or verify a stable agent identifier;¶
issue, request, or bind credentials that associate the agent identifier with capability metadata;¶
monitor lifecycle events such as update, suspension, deletion, and heartbeat status; and¶
synchronize catalog summaries with authorized Management Root Nodes or Discovery Service Nodes.¶
A Registry Service Node MUST preserve the distinction between asserted capabilities and verified capabilities. If it cannot verify a claim, it MUST NOT mark that claim as verified.¶
Registrations SHOULD be soft state. A Registry Service Node SHOULD assign an
expiration time to each active registration and require refresh before
expiration. If an agent fails to refresh, the Registry Service Node SHOULD
mark the registration inactive or remove it from discovery results.¶
Registration expiry is distinct from expiry of an identifier, credential, key, or endpoint. A stable identifier can remain meaningful after its active registration lease ends. Historical records MUST NOT be represented as currently usable solely because their original signatures still verify.¶
Discovery Service Nodes are demand-side search and candidate selection nodes. They accept discovery requests and return candidate agents with metadata that allows the requester to make its own trust decision.¶
A Discovery Service Node SHOULD support:¶
lookup by stable identifier;¶
discovery by capability tags;¶
discovery by natural-language intent;¶
filtering by protocol support, domain, policy, trust level, or operational status;¶
ranking that combines semantic relevance with operational and policy signals; and¶
explainable result metadata sufficient for clients to understand why a candidate was returned.¶
A Discovery Service Node MUST treat its own results as recommendations, not as authorization decisions. It MUST NOT require target agents to route runtime traffic through it.¶
Agent Gateways adapt local systems into agent-compatible interfaces. They are often deployed inside enterprises, clouds, or application platforms.¶
An Agent Gateway MAY:¶
translate between agent protocols and internal REST, RPC, message bus, or tool interfaces;¶
enforce local policy;¶
perform local authentication and authorization;¶
redact or transform private data before exposing a capability;¶
maintain local logs required by the enterprise domain; and¶
present a standardized capability record to a Registry Service Node.¶
Agent Gateways SHOULD NOT be assumed to be globally trusted. Remote agents SHOULD verify the gateway's credentials and policy claims before invocation.¶
Enterprise Service Hubs are private-domain integration components. They are used when an organization wants to expose selected internal capabilities while keeping raw systems and data inside a protected environment.¶
An Enterprise Service Hub SHOULD expose only the minimum metadata needed for discovery. Sensitive schemas, raw datasets, internal credentials, and private business logic SHOULD remain local unless explicitly authorized by local policy.¶
Capability claims identify their subject and scope: identifier control, organization identity, resource-management authority, endpoint control, runtime-content conformance, or invocation authorization. Deployments MUST distinguish verified claims from relayed assertions. A third-party catalog entry MUST NOT be represented as provider-authorized solely because it was indexed.¶
Review policies can differ by domain. Credentials conveying review outcomes need an identifiable issuer, subject, claim scope, and applicable validity conditions; their presence does not imply universal real-world identity review. Semantic ranking and metering records do not replace these distinctions.¶
Build provenance describes how an artifact was produced; a deployment statement associates an artifact with an instance; runtime attestation supplies claims about an observed execution environment. To relate these claims to a contacted endpoint, the relying party needs evidence binding that endpoint and resource to the covered instance and measurement. An artifact or model digest alone does not establish that binding.¶
Where remote attestation is used, the RATS architecture [RFC9334] distinguishes an Attester producing Evidence, a Verifier appraising it, and a Relying Party using Attestation Results. Integration associates the appraised environment with the expected resource and interaction, and identifies the accepted Verifier, appraisal policy, measurement scope, and freshness basis. Successful appraisal does not establish unrestricted application safety or business authorization.¶
Capability metadata is the primary object exchanged between registration and discovery functions. A concrete serialization is out of scope for this document. The following table lists semantic elements, not literal wire field names; requirement levels apply to their information content.¶
| Field | Requirement | Description |
|---|---|---|
| agent_id | MUST | Stable identifier for the agent or gateway |
| name | MUST | Human-readable name |
| description | MUST | Natural-language capability description |
| capability_tags | SHOULD | Normalized tags selected from a semantic taxonomy |
| endpoints | MUST | Endpoint references or protocol-specific contact data |
| protocols | MUST | Supported invocation protocols or transport bindings |
| auth_methods | SHOULD | Supported authentication methods |
| credential_refs | SHOULD | References to credentials or attestations |
| status | SHOULD | Operational status such as active, suspended, deprecated |
| freshness | MUST | Information identifying revision and applicable validity |
| ttl | MAY | Suggested registration lifetime in seconds |
| constraints | MAY | Rate limits, regions, data handling limits, cost hints |
| examples | MAY | Example tasks or invocation patterns |
Capability metadata SHOULD be signed by the publisher or by a Registry Service Node. Before relying on it for security-sensitive decisions, consumers MUST validate the covering signature, the signer's authority for the claimed scope, and applicable freshness. Unsigned metadata can support candidate search but cannot satisfy a requirement for authenticated metadata.¶
Implementations MAY ignore unrecognized non-critical metadata fields. A binding supporting critical extensions MUST specify how they are identified. Receivers MUST reject decisions requiring an unsupported extension. Relays MUST preserve the signed representation or identify transformations that prevent verification of the original signature.¶
Agent registration brings a new agent or gateway into the overlay.¶
The agent operator submits capability metadata to a Registry Service Node.¶
The Registry Service Node validates mandatory fields and endpoint reachability.¶
The Registry Service Node verifies or assigns the agent identifier.¶
The Registry Service Node binds the identifier to capability metadata using a credential, signed record, or equivalent mechanism.¶
The Registry Service Node stores the local catalog entry.¶
The Registry Service Node synchronizes a catalog summary or signed record to authorized discovery infrastructure.¶
Registrations SHOULD support incremental updates. A metadata update MUST carry a freshness indicator that allows receivers to reject stale records.¶
An update to an existing identifier MUST be authorized under its previously accepted control state, not merely by keys introduced in the proposed update. Transfer and key rotation require authorization under that state; recovery requires an explicitly designated authority. Concurrent conflicting updates MUST NOT both replace the same exclusive prior state. Bindings define the revision and proof representations used to enforce these conditions.¶
Acceptance, publication, synchronization, and query visibility can progress asynchronously. A receipt MUST NOT claim a later stage than the receiver has actually achieved. Confirmed reliable acceptance needs recoverable publication intent or an equivalent recovery mechanism. Backpressure and unavailable downstream services MUST NOT silently discard reliably accepted records.¶
An explicit deregistration request SHOULD be supported. Deregistration MUST be authenticated with the same or stronger proof of control as registration. After deregistration, Registry Service Nodes SHOULD either remove the record from discovery or return it only as an inactive historical record according to local retention policy.¶
Capability labels are useful only if different parties interpret them in compatible ways. Management Root Nodes or authorized taxonomy services SHOULD publish versioned semantic taxonomies.¶
Taxonomy updates SHOULD include:¶
a taxonomy identifier;¶
a version number or timestamp;¶
label identifiers;¶
parent-child or graph relationships;¶
deprecation markers;¶
mappings to related labels where available; and¶
a signature from the taxonomy authority.¶
Registry Service Nodes SHOULD validate submitted capability tags against a supported taxonomy version. Discovery Service Nodes SHOULD expose which taxonomy versions were used when producing results.¶
Agent discovery returns candidate agents for a requested intent or constraint set.¶
The requester sends a discovery request to a Discovery Service Node.¶
The Discovery Service Node normalizes the request against supported taxonomies and policies.¶
The Discovery Service Node searches local or synchronized catalogs.¶
The Discovery Service Node ranks candidates using implementation-specific relevance and policy signals.¶
The Discovery Service Node returns candidate metadata, credential references, endpoint references, and matching evidence.¶
The requester validates the returned metadata before selecting a target.¶
Discovery results MUST NOT be treated as proof that an agent is safe, authorized, or suitable for a particular regulated use.¶
After selecting a candidate, the invoking party establishes trust directly with the target endpoint, which can be an agent or gateway.¶
The invoking party retrieves the target's endpoint and verification material.¶
The parties establish a protected channel and authenticate as required by the selected binding. Authentication can occur during channel establishment or through protected application messages.¶
Each party checks the peer's identity binding, credential validity and applicable status, and authorization for the requested interaction.¶
The target enforces local authorization policy.¶
The parties exchange runtime requests and responses directly.¶
Each party records local audit or metering evidence according to policy.¶
Discovery Service Nodes SHOULD NOT be in this execution path unless the deployment explicitly uses them as application gateways. If a Discovery Service Node also acts as a gateway, the two roles MUST be distinguishable in metadata and policy.¶
Identity verification can be embedded in an endpoint, enforced by a colocated adapter, or mediated by a domain gateway. These are illustrative deployment forms, not required products. A deployment can adopt directory verification without modifying the remote service, but MUST NOT describe such one-sided integration as mutual runtime authentication.¶
For an interaction claimed to be protected, applicable authentication, message binding, and local authorization MUST succeed before the business handler produces effects. The client MUST verify the response's binding to the actual request and returned content before treating it as authenticated input to further actions. A detached handshake does not authenticate an unbound business URL or unrelated handler.¶
Domain control, endpoint control, and authority to act for an agent are separate claims. DNS records, hosted files, and endpoint challenges can support different admission checks; they are not equivalent proofs. A claim of endpoint control identifies the checked origin or endpoint, resource identity, challenge purpose, observation time, and validity scope. During use, the client validates the selected transport endpoint and the peer's resource authority or delegation. A redirect or gateway hop requires applicable binding checks rather than inheriting authentication from an unrelated earlier handshake.¶
An external enforcement boundary MUST prevent unauthorized bypass to its protected backend and MUST reject or remove caller-forged verified-identity claims. Forwarding an original signed object differs from signing on behalf of a resource: the latter requires scoped delegation. Management authority over a resource does not automatically authorize business signing or task access.¶
A runtime security binding identifies protected operations and defines their canonical message inputs, target and audience binding, request/response correlation, freshness, and replay handling. A receiver MUST reject a required protection it cannot enforce rather than downgrade at peer request. Protection claims for callbacks, errors, cancellation, or task results require explicit coverage. TLS and native application authorization retain their responsibilities; private signing keys remain with their authorized holders.¶
Key custody can be separated from applications through an authorized signing service, hardware-backed provider, or colocated enforcement component. The signing boundary MUST authorize the requesting principal and bind the signature to the permitted identity, operation, target, and content. Merely restricting key export does not prevent misuse of an unrestricted signing API. Encrypted storage and external signing do not themselves authorize key recovery; replacement keys still follow the accepted rotation or recovery rules.¶
A timeout, disconnection, or cancellation of local waiting does not prove that an operation produced no remote effect. A nonce rejects message replay; it does not alone prevent a new signed request from repeating a logical action. For side-effecting operations, automatic retry SHOULD occur only when delivery to the execution boundary is known not to have occurred or an applicable idempotency contract permits it. Otherwise the outcome is unknown and needs reconciliation through the native protocol or local policy.¶
A binding using stable operation identifiers defines their scope, content binding, conflict handling, and retention. Correlation alone is not idempotency. Multi-hop forwarding SHOULD coordinate bounded waiting budgets rather than amplify retries after an outer timeout; exactly-once execution is not assumed.¶
A terminal signature over a stream authenticates the covered completed content only after successful verification; it is not per-event authentication. Provisional display is possible, but unverified chunks MUST NOT trigger actions requiring authenticated input. Interrupted or invalid terminal proofs MUST NOT be reported as authenticated completion. A streaming security binding distinguishes terminal integrity from independently authenticated events and defines order, task correlation, and completion coverage.¶
Commercial deployments may require metering for billing, audit, reconciliation, or contribution tracing. The architecture supports metering without requiring every interaction payload to be globally visible.¶
A metering record SHOULD include:¶
a record identifier;¶
identities of the metering parties or pseudonymous references;¶
timestamp or time window;¶
invocation or discovery event type;¶
service or capability identifier;¶
usage counters or metering-relevant units;¶
policy or contract reference;¶
privacy-preserving digest of evidence where applicable; and¶
signature by the recording party.¶
High-frequency private interaction data SHOULD remain off-chain or local.¶
Signed metering evidence proves that its signer made the recorded assertion; it does not alone establish billing fairness or agreement by all parties. Metering, audit, and settlement remain distinct functions. Deployments MAY publish compact digests, Merkle roots, revocation events, or metering commitments to a distributed ledger when tamper-evidence or cross-operator reconciliation is required.¶
The architecture is protocol-neutral. It can coexist with agent cards, well-known metadata files, DNS-based discovery hints, MCP-style tool interfaces, A2A-style messaging, HTTP APIs, gRPC services, local process bindings, and future agent protocols.¶
A concrete interoperability binding specifies:¶
how an agent identifier is represented;¶
how capability metadata is serialized;¶
how signatures and credential references are encoded;¶
how endpoints and protocols are selected;¶
how taxonomy labels are named and versioned;¶
how discovery queries and results are encoded; and¶
how status, revocation, and freshness are checked.¶
Profiles SHOULD avoid requiring one specific machine-learning model or ranking algorithm for discovery. Discovery algorithms affect quality and performance, but the interoperable surface is the query, metadata, result, and validation contract.¶
DNS and well-known URIs [RFC8615] can provide bootstrap hints, domain control signals, or descriptor locations. They SHOULD NOT be overloaded with high-frequency, large, or privacy-sensitive agent metadata.¶
Mutual TLS, signed application messages, and public-key credentials can authenticate peers or messages. OAuth 2.0 provides delegated authorization; an access token is not by itself proof of an end-user identity or of mutual authentication. Deployments MUST specify the identity, authorization, and credential-status semantics of their selected mechanisms.¶
Deployments that use TLS SHOULD follow the security properties of the TLS version they negotiate; TLS 1.3 is specified in [RFC8446]. Server-authenticated TLS alone does not authenticate the application client. TLS 1.3 early data can be replayed across connections; side-effecting operations MUST NOT rely on 0-RTT transport protection alone to prevent duplicate effects. OAuth deployments should apply the security best current practice in [RFC9700], which updates OAuth 2.0 [RFC6749] and bearer-token usage [RFC6750], including audience restriction and applicable token replay defenses.¶
Agent interaction protocols such as tool invocation protocols, message-based agent protocols, or local process protocols remain above or beside this architecture. The overlay discovers and verifies candidates; the selected interaction protocol carries the task.¶
Deployment profiles, metadata objects, taxonomy versions, and credential profiles SHOULD carry explicit version identifiers. Implementations MUST NOT assume that all nodes in an overlay support the same profile version.¶
Unknown non-critical fields MAY be ignored subject to preservation of signed objects. Unknown critical extensions MUST NOT be accepted for decisions that depend on them. Unsupported profiles, taxonomies, or credentials require an explicit error or a fallback that still satisfies the client's minimum policy.¶
Private extensions SHOULD use collision-resistant names, such as URIs or reverse-DNS names. Extensions affecting interoperability SHOULD be documented in a stable specification.¶
External names, DIDs, enterprise accounts, and directory identifiers can be associated with an agent without replacing their original namespaces. Parsing an identifier, locating its resolver, proving key control, accepting a subject association, and authorizing an action are different steps. Equal names or URLs MUST NOT alone establish identity equivalence or management authority. Association profiles need provenance, claim scope, and lifecycle rules; no particular identifier technology is mandatory in this architecture.¶
A signed bulletin, organizational trust framework, distributed ledger, or combination can publish governance facts. Such facts are distinct from credential issuance, metadata acceptance, search, and runtime execution. Neither ordinary registration nor invocation needs a ledger transaction under this architecture. A ledger inclusion proof does not establish current authorization or the truth of every advertised capability.¶
Federated exchange MUST retain source authority, object revision, integrity evidence, and withdrawal or inactive-state meaning. Receivers MUST apply source-scoped revision comparison and retain conflicts rather than silently overwrite them. A federation binding defines duplicate and out-of-order handling, gap recovery, and acknowledged progress. Different roots' revision numbers are not a global sequence. Scope or taxonomy mappings MUST NOT silently expand delegated authority.¶
Publication and each receiving directory can advance independently. Failure of one receiver SHOULD be isolated from others. Acknowledging scan progress does not necessarily acknowledge verification of every object; receivers MUST report which meaning applies. These requirements do not prescribe batching, queues, databases, or worker scheduling.¶
Source update time, local receipt time, indexing time, and response generation time are distinct. Reindexing MUST NOT extend source evidence validity. An unavailable coordination service need not interrupt existing interactions with sufficient valid evidence, but MUST NOT justify silently accepting expired or unknown evidence for operations requiring current authorization.¶
Withdrawal of federation acceptance, resource revocation, and root key rotation have different scopes. Withdrawal prevents new reliance on that acceptance relationship; resource revocation affects its identified resource state. Bindings define how these changes affect cached evidence and ongoing sessions under the declared freshness and authorization policy. Cross-domain migration differs from root replication: identifier continuity depends on the identifier scheme, while transfer needs prior-control authorization or a defined recovery path and independent acceptance by the destination domain.¶
Implementations SHOULD distinguish at least the following failure conditions:¶
| Condition | Typical Handling |
|---|---|
| stale_metadata | Reject for security-sensitive use or request refresh |
| revoked_credential | Do not invoke; report revocation to the user or policy engine |
| taxonomy_mismatch | Fall back to text search or request a supported taxonomy version |
| discovery_unavailable | Use cached signed metadata if local policy permits |
| endpoint_unreachable | Try alternate binding or mark candidate degraded |
| policy_denied | Do not invoke even if semantic match is high |
Discovery clients SHOULD surface these conditions separately. Collapsing all failures into "not found" can hide security problems and make operational debugging difficult.¶
Agentic overlay networks introduce risks beyond ordinary service discovery. Agents can initiate actions, combine tools, and operate across administrative domains. Implementations MUST treat discovery data as untrusted input.¶
Attackers may register names or descriptions similar to trusted agents. Registries SHOULD require proof of control over identifiers and SHOULD distinguish unverified claims from verified credentials.¶
Agents may claim capabilities they do not possess. Registries SHOULD mark whether capabilities are self-asserted, registry-validated, or attested by a third party.¶
Discovery results may include outdated endpoints, revoked credentials, or deprecated capabilities. Metadata MUST include freshness information. Clients MUST check revocation and expiration before invocation.¶
Malicious operators may attempt to bias ranking or inject misleading metadata. Discovery Service Nodes SHOULD apply abuse detection, provenance checks, and rate limits.¶
Management Root Nodes could become governance bottlenecks. Deployments SHOULD scope their authority narrowly and publish auditable policy artifacts.¶
Registries and discovery services SHOULD NOT require private invocation payloads. Enterprise Service Hubs SHOULD redact sensitive metadata and keep raw data local unless policy permits disclosure.¶
An agent may be tricked into invoking another agent using credentials or authority outside the user's intent. Runtime agents SHOULD use scoped, task-specific credentials and SHOULD bind authorization to the requested action.¶
An attacker may try to force a client into an insufficient configuration, for example by suppressing credential references or taxonomy versions. Clients MUST enforce minimum acceptable credential requirements for sensitive tasks.¶
A compromised Registry Service Node can publish false metadata for many agents. Management Root Nodes or governance services SHOULD support rapid revocation of registry credentials and distribution of registry compromise indicators.¶
Metering records can reveal business relationships or user behavior. Deployments SHOULD minimize metering data, aggregate where possible, and use privacy-preserving digests when detailed evidence is not required.¶
Capability metadata can reveal sensitive information about enterprise systems, available tools, regions, customers, or business processes. Registrations SHOULD disclose only what is necessary for discovery and safe invocation.¶
Deployments SHOULD evaluate privacy risks using the general guidance for Internet protocols in [RFC6973].¶
Discovery requests can reveal user intent. Discovery Service Nodes SHOULD provide transport confidentiality, access control, retention limits, and privacy-preserving logging options.¶
Enterprise Service Hubs SHOULD keep private data, internal schemas, and credentials within the local domain unless a specific policy authorizes external disclosure.¶
This document does not create new registries, media types, URI schemes, HTTP fields, or protocol parameter values. It makes no IANA requests.¶
An implementation of this architecture can be reviewed against the following checklist:¶
which deployment profile is supported;¶
how capability metadata is signed and refreshed;¶
how unknown metadata fields are handled;¶
how taxonomy versions are negotiated or rejected;¶
how registry compromise and credential revocation are distributed;¶
how discovery results are separated from authorization decisions;¶
how endpoint reachability and stale metadata failures are reported; and¶
what information is retained in metering or audit logs.¶
The authors thank participants in discussions on agent networking, agent discovery, and cross-domain agent interoperability.¶