Network Working Group J. Bu
Internet-Draft Google
Intended status: Informational R. V. Guha
Expires: 3 May 2027
J. Arkko
J. Jiménez
Ericsson
30 October 2026
Agent Resource Discovery (ARD) Architecture
draft-bu-dawn-ard-architecture-00
Abstract
This document describes the high-level architecture for Agent
Resource Discovery (ARD), an open, federated framework for
publishing, indexing, discovering, and invoking software agent
capabilities (such as Model Context Protocol servers, Agent-to-Agent
agents, programmatic skills, and web APIs) across local networks,
enterprise domains, and the public Internet. It defines the system
roles, deployment topologies, core architectural principles, and end-
to-end interaction flows that connect the ARD specifications for
establishing Initial Contact and the Discovery Interface for
capability lookup in the ARD catalog. The Registration interface
will be specified in a later document.
About This Document
This note is to be removed before publishing as an RFC.
The latest revision of this draft can be found at
https://mindpower.github.io/ietf-draft-agent-resources-architecture/
draft-bu-dawn-ard-architecture.html. Status information for this
document may be found at https://datatracker.ietf.org/doc/draft-bu-
dawn-ard-architecture/.
Discussion of this document takes place on the Discovery of Agents
With Names (DAWN) Working Group mailing list (mailto:dawn@ietf.org),
which is archived at https://mailarchive.ietf.org/arch/browse/dawn/.
Subscribe at https://www.ietf.org/mailman/listinfo/dawn/.
Source for this draft and an issue tracker can be found at
https://github.com/mindpower/ietf-draft-agent-resources-architecture.
Bu, et al. Expires 3 May 2027 [Page 1]
Internet-Draft ARD Architecture October 2026
Status of This Memo
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 3 May 2027.
Copyright Notice
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. Code Components
extracted from this document must include Revised BSD License text as
described in Section 4.e of the Trust Legal Provisions and are
provided without warranty as described in the Revised BSD License.
Table of Contents
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 3
2. Conventions and Definitions . . . . . . . . . . . . . . . . . 4
3. System Architecture and Interaction Flows . . . . . . . . . . 5
3.1. Manifest Data Model . . . . . . . . . . . . . . . . . . . 7
3.2. Deployment Topologies . . . . . . . . . . . . . . . . . . 8
3.3. Core Architectural Principles . . . . . . . . . . . . . . 9
3.3.1. Hypermedia-Based Discovery . . . . . . . . . . . . . 9
3.3.2. Search-First Dynamic Discovery . . . . . . . . . . . 10
3.3.3. Scalability Beyond Context Windows . . . . . . . . . 10
3.3.4. Artifact-Agnostic Envelope . . . . . . . . . . . . . 10
3.3.5. Open Namespace Extensibility via JSON-LD . . . . . . 10
3.3.6. Universal HTTP REST Baseline . . . . . . . . . . . . 11
3.3.7. Strict Separation of Concerns . . . . . . . . . . . . 11
4. Security Considerations . . . . . . . . . . . . . . . . . . . 11
4.1. Decoupling of Administrative Domains . . . . . . . . . . 12
Bu, et al. Expires 3 May 2027 [Page 2]
Internet-Draft ARD Architecture October 2026
4.2. Defense-in-Depth Layers . . . . . . . . . . . . . . . . . 13
5. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 13
6. Informative References . . . . . . . . . . . . . . . . . . . 13
Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . . 15
Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 15
1. Introduction
Software agents and automated orchestrators increasingly rely on
external, callable capabilities such as Model Context Protocol (MCP)
servers [MCP], Agent-to-Agent (A2A) agents [A2A], web APIs, and agent
skills. This document refers to these capabilities as agentic
resources.
Early agent deployments rely on manual configuration or pre-
installing candidate tools into client prompts. As the number of
available resources expands across organizations, static
configuration becomes impractical: injecting extensive schemas into
orchestration prompts incurs token and processing overhead, while
single-operator centralized directories cannot readily accommodate
decentralized multi-organization environments.
The Agent Resource Discovery (ARD) architecture addresses this by
decoupling capability discovery from execution runtimes. Agentic
resources are described in manifests, indexed by registries, and
found at runtime through standard Internet protocols. The ARD
Registry has two interfaces, discovery and registration. A client
locates a manifest or registry through initial contact. The manifest
lists entries directly or consists of an entry that points to a
registry. The mechanisms are specified in the following documents:
* *Initial Contact ([ARD-INITIAL-CONTACT]):* Specifies how a client
or agent initially locates the entry point URI of an ARD manifest
or an ARD Registry starting from a domain name, a local network
attachment, or configuration — using DNS Service Binding (SVCB /
HTTPS) records [RFC9460], DNS-Based Service Discovery (DNS-SD /
mDNS), well-known URIs [RFC8615], and HTTP/HTML link relations.
* *Discovery Interface ([ARD]):* Specifies the discovery interface
through which a consumer performs structured lookup, faceted
exploration, and natural-language search on an ARD Registry. It
also specifies the manifest and entry format: an application/
ard+json document composed of ARD entries, each describing one
agentic resource with its discovery identifier, media type, url or
inline data, and an optional trustManifest that binds the entry to
its publisher.
Bu, et al. Expires 3 May 2027 [Page 3]
Internet-Draft ARD Architecture October 2026
* *Registration:* Specifies how a publisher registers entries with
an ARD Registry. Registration requires identification and
authentication of the publisher against the registry. Mechanisms
include W3C Decentralized Identifiers [DID-CORE], WIMSE workload
identities [WIMSE-ARCH], SPIFFE, or other identification
mechanisms, depending on the deployment. This interface is to be
specified in a later document.
2. Conventions and Definitions
The following terms are used throughout the ARD documents:
Agentic Resource (or Resource): A network-accessible capability —
such as an autonomous agent (A2A), an MCP server, a static AI
skill, an API service, or an ARD Registry — that a consumer
discovers and interacts with. In ARD, each resource is described
by a protocol-specific descriptor (e.g., an A2A Agent Card, an MCP
server card, or a skill document) referenced by the entry's url or
carried inline in data.
ARD Entry: An entry in a registry or manifest that describes one
agentic resource for discovery, or that points to another ARD
Registry. Its format is specified in [ARD].
Manifest: A static or dynamically generated application/ard+json
document containing an array of ARD entries ([ARD]). A manifest
is reached at an entry point discovered via [ARD-INITIAL-CONTACT]
(including a well-known URI), may contain entries from one or
multiple publishers, and may include or consist of an entry that
points to an ARD Registry.
Entry Point: The URI of an ARD manifest, together with the source
from which the client learned it ([ARD-INITIAL-CONTACT]). An
entry point is unverified until the client has retrieved the
manifest and authenticated the origin.
Initial Contact: The process by which a client obtains one or more
entry points, starting from a domain name, a local network
attachment, or configuration ([ARD-INITIAL-CONTACT]).
ARD Registry: The component that holds entries and offers two
interfaces, discovery of entries and registration of entries. A
registry may also populate itself by crawling and ingesting
manifests. The discovery interface is specified in [ARD]; the
registration interface is to be specified separately (Section 1).
Publisher: The party that controls a domain name and publishes
Bu, et al. Expires 3 May 2027 [Page 4]
Internet-Draft ARD Architecture October 2026
resources under it, by serving a manifest that lists them or by
registering entries with an ARD Registry. The domain name appears
as <publisher> in the discovery identifiers of its entries. In
its interactions with a registry, a publisher acts as a client.
Consumer: A client that discovers entries through a manifest or an
ARD Registry and retrieves or invokes the described resource at
its url. Consumers include agents, applications whose behavior is
driven by a language model acting on a user's intent,
orchestrators, and other workloads.
Domain Owner: The party that controls the DNS domain name under
which a manifest or an ARD Registry is reached. For a publisher's
own manifest, the domain owner is the publisher. For an
aggregator or a third-party registry, the domain owner operates
the manifest or registry while each entry identifies its own
publisher.
Discovery Identifier: A persistent, location-independent identifier
that uniquely identifies an agentic resource across manifests and
registries. In [ARD], it uses the Uniform Resource Name (URN)
[RFC8141] syntax urn:air:<publisher>:<namespace>:<agent-name>,
decoupling publisher identity (<publisher>) from both the manifest
or registry host (Domain Owner) and the runtime endpoint (url).
Local or non-DNS deployments may bind identifiers to their
respective trust domain anchors.
Trust Manifest: An optional cryptographic envelope within an ARD
entry that asserts publisher or third-party verifier identity,
software provenance, and compliance attestations ([ARD]).
3. System Architecture and Interaction Flows
Figure 1 shows the components of the architecture and the interfaces
between them, with the specification that defines each interface.
Arrows start at the party that initiates an interaction. A consumer
may discover entries directly by retrieving a manifest via initial
contact, or by querying an ARD Registry (which may itself be
discovered via an entry in a manifest). The registration interface
is to be specified in a later document (Section 1); runtime access to
a resource is outside the scope of ARD.
Bu, et al. Expires 3 May 2027 [Page 5]
Internet-Draft ARD Architecture October 2026
+----------+ Initial Contact [ARD-INITIAL-CONTACT] +-----------+
| | & Retrieve Manifest [ARD] | |
| |------------------------------------------>| |
| | | Publisher |
| Consumer | +----------------+ Crawl | / Domain |
| | | |-------------->| Owner |
| |--------->| ARD Registry | | |
| | Lookup, | |<--------------| |
| | Search +----------------+ Register +-----------+
| | [ARD] [TBD] |
+----------+ |
| |
| Access (at Entry `url`) Publishes |
v v
+------------------------------------------------------------------+
| Agentic Resource (Hosted on Same or Separate Domain) |
+------------------------------------------------------------------+
Figure 1: Agent Resource Discovery Architecture and Protocol Mapping
The architecture separates discovery from runtime execution across
four lifecycle phases:
1. *Publishing and Initial Contact:* A domain owner or publisher
serves a manifest at a well-known URI or advertises its manifest
or ARD Registry through the DNS, HTTP link, and local-link
mechanisms of [ARD-INITIAL-CONTACT]; a manifest lists entries
directly or includes an entry that points to an ARD Registry. A
client obtains the entry point through initial contact or
configuration. Publishers, live workloads, or Commissioning
Tools can also register entries dynamically with an ARD Registry
through the Registration interface (Section 1).
2. *Indexing:* An ARD Registry may serve a single domain or
aggregate entries across domains. It populates its indices
through registrations or by crawling manifests located through
the mechanisms of [ARD-INITIAL-CONTACT].
3. *Lookup and Search:* Consumers discover entries either by
querying an ARD Registry using structured filters, faceted
exploration, or natural-language queries ([ARD]), or by reading a
manifest obtained through initial contact
([ARD-INITIAL-CONTACT]).
4. *Descriptor Resolution and Access:* The consumer retrieves the
protocol descriptor at the entry's url (or reads it from inline
data), optionally verifies it against the entry's digest and
trustManifest, and accesses the resource using its native
Bu, et al. Expires 3 May 2027 [Page 6]
Internet-Draft ARD Architecture October 2026
protocol. The host at url may be in the publisher's domain or in
a third-party hosting domain; the entry's identifier, digest, and
trustManifest bind the resource to <publisher>. The registry
takes no part in runtime access.
3.1. Manifest Data Model
A manifest is a JSON document of media type application/ard+json with
one top-level member, entries, an array of ARD entries ([ARD]). A
publisher serves it at /.well-known/ard.json. An ARD Registry is
also a collection of entries, reached through its discovery
interface. A registry obtains its entries by reading manifests or
through dynamic registration.
An entry describes a single agentic resource, combining core
descriptive metadata, payload delivery references, discovery signals,
and cryptographic trust assertions ([ARD]). Figure 2 shows the data
model of a manifest. A manifest contains any number of entries, and
each entry references exactly one resource.
An ARD entry comprises:
* *Core Envelope:* The discovery identifier (a globally unique URI
or domain-anchored URN, such as urn:air), the artifact media type
(e.g., application/mcp-server-card+json, application/a2a-agent-
card+json), and exactly one of url (hypermedia reference to the
capability descriptor) or data (inline artifact payload). An
entry may also include an algorithm-prefixed cryptographic digest
to lock referenced descriptor contents.
* *Descriptive Metadata:* Human-readable attributes including
displayName, description, version, and categorical tags.
* *Discovery Signals:* Search attributes that enable high-
performance indexing without pre-fetching external artifacts:
- representativeQueries: A list of natural language prompts or
queries that the capability satisfies, serving as the primary
input for semantic vector and hybrid search indices.
- capabilities: Structured tokens or vocabulary terms identifying
specific tools or skills for precise filtering.
Bu, et al. Expires 3 May 2027 [Page 7]
Internet-Draft ARD Architecture October 2026
* *Provenance and Trust:* An optional trustManifest signed by
<publisher>, binding publisher identity, claims, and the artifact
digest. The publisher of an entry is established from its
trustManifest; the host that serves a manifest or operates a
registry establishes nothing about the publishers of the entries
it holds.
* *Open Extensibility:* As a JSON-LD node (Section 3.3.5), an entry
inherits the ARD base context and can be extended with domain-
specific terms via @context.
+--------------+ 1 0..n +-----------------------+ 1 1 +------------+
| Manifest |------------| Entry |----------| Resource |
+--------------+ +-----------------------+ +------------+
| entries | | identifier |
+--------------+ | type |
| url | data |
| displayName |
| description |
| representativeQueries |
| capabilities |
| version, tags, digest |
| trustManifest |
+-----------------------+
Figure 2: Manifest Data Model
The resource is served by the publisher in its native format, for
example an A2A Agent Card, an MCP server description, a skill, or an
API description. Manifests and registries hold entries; a consumer
that needs the resource follows the url. An entry that carries the
resource inline as data is the exception. A manifest may consist of
a single entry whose url is the base URI of a registry; a consumer
that retrieves such a manifest proceeds through the registry's
discovery interface.
3.2. Deployment Topologies
ARD is deployed in three settings, which differ in how a consumer
reaches a registry and in which party attests to the publisher of an
entry:
* *Local network:* A home or small office network without an
administrator. Consumers find manifests and registries on the
link through Multicast DNS and DNS-SD, or through a network-
provided domain name, as specified in [ARD-INITIAL-CONTACT].
Resources on the network register with a local registry through
the Registration interface, and their entries expire when the
Bu, et al. Expires 3 May 2027 [Page 8]
Internet-Draft ARD Architecture October 2026
resources leave the network. Entry points learned over multicast
are the least trusted source, and local policy determines which of
them a consumer uses.
* *Private network:* The infrastructure of a single organization,
within one administrative and trust domain. A registry indexes
the organization's resources and is reached through configured
entry points or the organization's own DNS. Publisher authority
and the authorization to register are established by the
organization's identity infrastructure, and the registry is
reachable only within the organization.
* *Internet:* Publishers and registries on the public Internet,
anchored in the DNS. A consumer starts from a domain name and
reaches a publisher's manifest through the organization index
record, DNS-SD, the well-known URI, or the ard link relation
([ARD-INITIAL-CONTACT]). A registry may crawl manifests across
domains and accept registrations from publishers in other domains.
Each entry carries its publisher's domain in its discovery
identifier and an optional trustManifest signed by the publisher,
so a consumer can verify the publisher of an entry regardless of
which registry returned it.
In every setting a publisher serves its manifest at /.well-known/
ard.json; the well-known URI is mandatory to implement in
[ARD-INITIAL-CONTACT], and the other mechanisms supplement it. A
manifest that lists entries directly is the simplest form of the
registry role and supports discovery of entries only. A manifest
that consists of a single entry pointing at a registry directs the
consumer to the registry's discovery interface.
3.3. Core Architectural Principles
ARD is designed according to seven foundational principles:
3.3.1. Hypermedia-Based Discovery
Discovery in ARD is hypermedia-based. A consumer follows links: from
an entry point to a manifest, from a manifest to its entries or to a
registry, from a registry response to entries, and from an entry to
the resource at its url. A registry offers a lookup interface over
its entries with structured filters and, where the registry supports
it, natural-language or semantic search ([ARD]). The entries in a
registry are maintained either by the registry itself, which crawls
and ingests manifests, or by publishers, which register and refresh
their entries through the Registration interface. An entry is
discoverable as soon as the registry has indexed it.
Bu, et al. Expires 3 May 2027 [Page 9]
Internet-Draft ARD Architecture October 2026
3.3.2. Search-First Dynamic Discovery
Capabilities are discovered on demand at runtime based on natural
language task descriptions and structured constraints, rather than
pre-installed statically. Registries maintain continuously refreshed
semantic and structured indices, allowing newly published
capabilities to be discovered immediately without client
recompilation or manual reconfiguration.
3.3.3. Scalability Beyond Context Windows
Traditional tool selection relies on injecting every candidate tool
description into the model's context window, which does not scale as
collections grow to thousands or millions of resources. While a
client can rank a small, pre-fetched set of tools locally, local
ranking still requires each client to know, fetch, and index the
candidate corpus in advance. ARD moves candidate discovery outside
the model into a dedicated search service (whether deployed over a
curated enterprise catalog or across open domains), where richer
signals such as representativeQueries, publisher identity, compliance
metadata, and structured attributes can be indexed, and where
publisher identity and trust attestations (trustManifest) can be
verified ahead of time during ingestion rather than by each client at
runtime. The client queries the registry and receives only the top-k
relevant entries to inject into its context window.
3.3.4. Artifact-Agnostic Envelope
ARD does not define or standardize the internal schemas of specific
resource architectures. Instead, it serves as a protocol-neutral
envelope. The entry's type field uses IANA Media Types to declare
whether the resource is an MCP server (application/mcp-server-
card+json), an A2A agent (application/a2a-agent-card+json), an AI
skill (application/ai-skill+md), or an Agent Registry (application/
ai-registry+json).
3.3.5. Open Namespace Extensibility via JSON-LD
Every ARD entry is a JSON-LD [JSON-LD] node. Core discovery terms
are defined in the default ARD base context. Publishers may enrich
entries with terms from arbitrary external namespaces (e.g., industry
taxonomies, regulatory tags, or pricing models) through @context
declarations. Registries index known terms and preserve unrecognized
terms, enabling open evolution without revisions to the core
specifications.
Bu, et al. Expires 3 May 2027 [Page 10]
Internet-Draft ARD Architecture October 2026
3.3.6. Universal HTTP REST Baseline
To guarantee universal interoperability regardless of execution
environments, every ARD Registry exposes a standard HTTP REST
interface over HTTPS conforming to [RFC9110]. While registries may
additionally offer protocol-specific wrappers (such as an MCP tool or
A2A skill wrapper), the HTTPS REST API represents the universal
baseline.
3.3.7. Strict Separation of Concerns
Operational and architectural concerns are decoupled across layers:
* *Discovery vs. Resolution:* ARD identifies what capabilities exist
and where their authoritative descriptors or endpoints reside.
Lower-level name resolution and transport routing remain delegated
to standard DNS and network primitives.
* *Discovery vs. Execution:* ARD is link-based. Once an agentic
resource is discovered, the client follows the artifact reference
(url) and invokes the resource directly via its native protocol
(e.g., JSON-RPC over HTTP/SSE for MCP, HTTP/REST for A2A, or
gRPC). The discovery registry never sits in the runtime execution
data path.
* *Identification vs. Network Location:* An agentic resource's
discovery identifier (urn:air:<publisher>:...) is decoupled from
both the manifest/registry hosting origin (Domain Owner) and the
physical execution endpoint (url). This allows registries and
manifests to aggregate entries across publishers, and allows a
resource's runtime endpoint to be hosted on or migrated across
cloud providers without changing its identifier.
* *Search Relevance vs. Security Evaluation:* Semantic search scores
indicate textual relevance only and do not represent trust,
safety, or compliance assertions.
* *Discovery vs. Authorization:* Authentication, token negotiation,
and runtime access control are handled by the resource endpoint
during invocation, while cryptographic provenance (trustManifest)
allows registries and consumers to verify publisher authority
independently of where a manifest or registry is hosted.
4. Security Considerations
Bu, et al. Expires 3 May 2027 [Page 11]
Internet-Draft ARD Architecture October 2026
4.1. Decoupling of Administrative Domains
A central security property of ARD is that a single discovery flow
may span three distinct administrative domains (Figure 3):
1. *Domain Owner (Serving Origin):* The host serving the manifest or
registry API (e.g., registry.example.org or a CDN target
catalog.example.net), authenticated at the transport layer via
TLS (and optionally DNSSEC during initial contact).
2. *Entry Publisher (<publisher> in urn:air:<publisher>:...):* The
organization claiming authorship of the agentic resource (e.g.,
abc.com in urn:air:abc.com:agent:flight-finder), authenticated at
the entry layer via trustManifest.identity (e.g.,
did:web:abc.com) and trustManifest.signature (or via same-origin
HTTPS when fetched directly from https://abc.com/.well-known/
ard.json).
3. *Runtime Endpoint Host (url):* The infrastructure hosting the
capability descriptor or execution endpoint (e.g., xyz.execute-
api.amazonaws.com), whose descriptor content is locked to the
publisher's signed entry via the cryptographic content digest.
+-------------------------------------------------------------------+
| 1. Domain Owner / Serving Origin (e.g., registry.example.org) |
| - Authenticated via HTTPS TLS cert (+ DNSSEC in Initial Contact)|
| |
| +-----------------------------------------------------------+ |
| | 2. ARD Entry: urn:air:abc.com:agent:flight-finder | |
| | - Publisher (<publisher> = abc.com) | |
| | - Signed by trustManifest (identity = did:web:abc.com) | |
| | - Pins descriptor content via digest = sha256:9f86... | |
| +-----------------------------------------------------------+ |
+---------------------------------|---------------------------------+
|
| Follows `url` & verifies `digest`
v
+-------------------------------------------------------------------+
| 3. Runtime Endpoint Host (e.g., xyz.execute-api.amazonaws.com) |
| - TLS cert belongs to cloud host; content bound by `digest` |
+-------------------------------------------------------------------+
Figure 3: Three-Domain Trust Model in ARD
Bu, et al. Expires 3 May 2027 [Page 12]
Internet-Draft ARD Architecture October 2026
4.2. Defense-in-Depth Layers
Because discovery spans untrusted networks, multi-tenant origins, and
third-party aggregators, the ARD architecture applies defense-in-
depth across the three companion specifications:
1. *Authenticated Transport and Hint Validation
([ARD-INITIAL-CONTACT]):* Entry points obtained from DNS records,
multicast responses, or third-party links are treated as
untrusted hints until the client fetches the resource over HTTPS
(TLS) and authenticates the serving origin.
2. *Entry-Level Publisher and Artifact Integrity Binding ([ARD]):*
Because the origin hosting a manifest or registry (Domain Owner),
the <publisher> domain in an entry's URN
(urn:air:<publisher>:...), and the host in the entry's runtime
url field may belong to three different administrative domains,
an unverified URN string carries no implicit trust. When an
entry is served directly from https://<publisher>/.well-known/
ard.json, same-origin HTTPS establishes domain authority for
entries under <publisher>. When entries are aggregated across
domains, cached, or federated across registries, cryptographic
publisher binding is established via the entry's signed
trustManifest (binding <publisher> to the entry's identifier,
type, version, and content digest). Independent security
auditors may attach additional third-party trustManifest
signatures to endorse compliance or evaluation claims without
altering the publisher's signature.
3. *Workload Authentication for Active Registration:* Registries
that accept dynamic registrations authenticate the registering
workload or Commissioning Tool using mutually authenticated TLS
or workload identity tokens (such as [WIMSE-ARCH]) and may verify
whether the registrant is authorized for the <publisher> domain
in the entry's URN to assign verified status indicators or
enforce admission policy.
Detailed protocol-specific security and privacy considerations are
specified in [ARD-INITIAL-CONTACT] and [ARD].
5. IANA Considerations
This document has no IANA actions. IANA registrations for well-known
URIs, HTTP link relations, DNS-SD service names, media types, and URN
namespaces are specified in [ARD-INITIAL-CONTACT] and [ARD].
6. Informative References
Bu, et al. Expires 3 May 2027 [Page 13]
Internet-Draft ARD Architecture October 2026
[A2A] Linux Foundation, "Agent2Agent (A2A) Protocol
Specification", 2025,
<https://a2a-protocol.org/latest/specification/>.
[ARD] Bu, J., Guha, R. V., Smith, S., Jiménez, J., and J.
Damick, "Agent Resource Discovery (ARD): Manifest and
Lookup", Work in Progress, Internet-Draft, draft-bu-dawn-
ard-discovery, October 2026,
<https://datatracker.ietf.org/doc/draft-bu-dawn-ard-
discovery/>.
[ARD-INITIAL-CONTACT]
Jiménez, J., Bu, J., and J. Arkko, "Agent Resource
Discovery (ARD): Initial Contact", Work in Progress,
Internet-Draft, draft-jimenez-dawn-ard-initial-contact,
October 2026, <https://datatracker.ietf.org/doc/draft-
jimenez-dawn-ard-initial-contact/>.
[DID-CORE] W3C, "Decentralized Identifiers (DIDs) v1.0", July 2022,
<https://www.w3.org/TR/did-core/>.
[JSON-LD] W3C, "JSON-LD 1.1 - A JSON-based Serialization for Linked
Data", July 2020, <https://www.w3.org/TR/json-ld11/>.
[MCP] Anthropic, "Model Context Protocol Specification", 2025,
<https://modelcontextprotocol.io/specification/>.
[RFC8141] Saint-Andre, P. and J. Klensin, "Uniform Resource Names
(URNs)", RFC 8141, DOI 10.17487/RFC8141, April 2017,
<https://www.rfc-editor.org/rfc/rfc8141>.
[RFC8615] Nottingham, M., "Well-Known Uniform Resource Identifiers
(URIs)", RFC 8615, DOI 10.17487/RFC8615, May 2019,
<https://www.rfc-editor.org/rfc/rfc8615>.
[RFC9110] Fielding, R., Ed., Nottingham, M., Ed., and J. Reschke,
Ed., "HTTP Semantics", STD 97, RFC 9110,
DOI 10.17487/RFC9110, June 2022,
<https://www.rfc-editor.org/rfc/rfc9110>.
[RFC9460] Schwartz, B., Bishop, M., and E. Nygren, "Service Binding
and Parameter Specification via the DNS (SVCB and HTTPS
Resource Records)", RFC 9460, DOI 10.17487/RFC9460,
November 2023, <https://www.rfc-editor.org/rfc/rfc9460>.
Bu, et al. Expires 3 May 2027 [Page 14]
Internet-Draft ARD Architecture October 2026
[WIMSE-ARCH]
IETF, "Workload Identity in Multi-System Environments
(WIMSE) Architecture", 2024,
<https://datatracker.ietf.org/wg/wimse/about/>.
Acknowledgments
The authors would like to thank Mirja Kühlewind, Shaun Smith, Jeffrey
Damick, Wes Hardaker, Warren Kumari, and the participants of the
Agent Resource Discovery community and IETF DAWN discussions for
their architectural contributions and feedback.
Authors' Addresses
Junjie Bu
Google
Email: jbu@google.com
R.V. Guha
Email: guha@guha.com
Jari Arkko
Ericsson
Email: jari.arkko@ericsson.com
Jaime Jiménez
Ericsson
Email: jaime.jimenez@ericsson.com
Bu, et al. Expires 3 May 2027 [Page 15]