Network Working Group J. Bu
Internet-Draft Google
Intended status: Standards Track R. V. Guha
Expires: 3 May 2027
S. Smith
Hugging Face
J. Jiménez
Ericsson
J. Damick
Amazon
30 October 2026
Agent Resource Discovery (ARD): Manifest and Lookup
draft-bu-dawn-ard-discovery-00
Abstract
This document specifies the catalog representation and lookup
protocol for Agent Resource Discovery (ARD), an open architecture for
publishing, discovering, and searching software agent capabilities
across federated networks. ARD defines a JSON-LD capability
description envelope (the ARD Entry) and catalog container (the ARD
Manifest) identified by domain-anchored Uniform Resource Names
(URNs), cryptographic publisher authority bindings (the Trust
Manifest), and an HTTP query interface supporting structured,
semantic, and federated search across registries. Initial contact
for discovering catalog entry points and active agent registration
are specified in companion ARD documents.
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-discovery/
draft-bu-dawn-ard-discovery.html. Status information for this
document may be found at https://datatracker.ietf.org/doc/draft-bu-
dawn-ard-discovery/.
Discussion of this document takes place on the Discovery of Agents
With Names (DAWN) Proposed 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-discovery.
Bu, et al. Expires 3 May 2027 [Page 1]
Internet-Draft ARD Manifest and Lookup 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. The ARD Entry and Manifest Format . . . . . . . . . . . . . . 4
3.1. JSON-LD Representation and Base Context . . . . . . . . . 4
3.2. Entry Fields . . . . . . . . . . . . . . . . . . . . . . 5
3.2.1. Required Fields . . . . . . . . . . . . . . . . . . . 5
3.2.2. Recommended Discovery Signals . . . . . . . . . . . . 6
3.2.3. Optional Descriptive Fields . . . . . . . . . . . . . 6
3.3. Value-or-Reference Pattern and Hypermedia Linking . . . . 6
3.4. Domain-Anchored URN Syntax . . . . . . . . . . . . . . . 7
3.5. Identity and the Trust Manifest . . . . . . . . . . . . . 9
3.5.1. Publisher and Verifier Authority Binding . . . . . . 10
3.5.2. Cryptographic Subject Binding and Integrity
Digests . . . . . . . . . . . . . . . . . . . . . . . 11
3.6. The ARD Manifest Container . . . . . . . . . . . . . . . 11
Bu, et al. Expires 3 May 2027 [Page 2]
Internet-Draft ARD Manifest and Lookup October 2026
4. Lookup, Search, and Federated Discovery . . . . . . . . . . . 12
4.1. Registry Ingestion and Companion Protocols . . . . . . . 12
4.1.1. Ingestion and Crawling Pipelines . . . . . . . . . . 13
4.2. The Search and Query HTTP API . . . . . . . . . . . . . . 14
4.2.1. Universal Query Model . . . . . . . . . . . . . . . . 14
4.2.2. Search Endpoint (POST /search) . . . . . . . . . . . 15
4.2.3. Explore Endpoint (POST /explore) . . . . . . . . . . 16
4.2.4. Deterministic List Endpoint (GET /agents) . . . . . . 17
4.2.5. Standard Error Responses . . . . . . . . . . . . . . 17
4.3. Federated Routing and Scalability . . . . . . . . . . . . 18
4.3.1. Federation Trust Model and Origin Binding . . . . . . 19
4.3.2. Referrals Federation Example . . . . . . . . . . . . 20
5. Formal CDDL Specification . . . . . . . . . . . . . . . . . . 21
6. Security Considerations . . . . . . . . . . . . . . . . . . . 24
6.1. Threat Model . . . . . . . . . . . . . . . . . . . . . . 24
6.2. Publisher Authority Verification . . . . . . . . . . . . 25
6.3. Decoupling of Semantic Relevance and Trust . . . . . . . 26
6.4. Attestation Integrity and Subject Binding . . . . . . . . 26
6.5. Mandatory Transport Layer Security (TLS 1.3) . . . . . . 27
6.6. DoS Protection and Federation Limits . . . . . . . . . . 27
6.7. Workload Identity and Token Scoping . . . . . . . . . . . 27
7. Privacy Considerations . . . . . . . . . . . . . . . . . . . 27
8. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 28
8.1. Media Type Registrations . . . . . . . . . . . . . . . . 28
8.1.1. application/ard+json . . . . . . . . . . . . . . . . 28
8.1.2. application/ai-registry+json . . . . . . . . . . . . 28
8.2. URN Sub-Namespace Registration: urn:air . . . . . . . . . 29
9. References . . . . . . . . . . . . . . . . . . . . . . . . . 29
9.1. Normative References . . . . . . . . . . . . . . . . . . 29
9.2. Informative References . . . . . . . . . . . . . . . . . 30
Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . . 31
Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 31
1. Introduction
Software agents and automated orchestrators increasingly interact
with external, callable capabilities — such as Model Context Protocol
(MCP) servers [MCP], Agent-to-Agent (A2A) agents [A2A], web APIs, and
modular skills. In this document, callable capabilities providing
programmatic services to automated systems are referred to
generically as "agentic resources."
The overall Agent Resource Discovery (ARD) architecture, deployment
topologies, and design principles are described in [ARD-ARCH].
Within the ARD protocol suite, initial contact for locating a
domain's manifest or registry entry point URI is specified in
[ARD-INITIAL-CONTACT], and active registration of live workloads with
an Agent Directory is specified in [AGENT-DIRECTORY].
Bu, et al. Expires 3 May 2027 [Page 3]
Internet-Draft ARD Manifest and Lookup October 2026
This document specifies the *Manifest Representation and Lookup
Protocol* for ARD:
* *The ARD Entry and Manifest Format (Section 3):* Defines the JSON-
LD [JSON-LD] capability description envelope (ARD Entry), the
application/ard+json container format (ARD Manifest), and the
domain-anchored Uniform Resource Name (URN) syntax
(urn:air:<publisher>:<namespace>:<agent-name>) [RFC8141].
* *Cryptographic Trust and Authority Binding (Section 3.5):* Defines
the optional trustManifest envelope (sealed using RFC 8785 JCS
[RFC8785] and RFC 7515 detached JWS [RFC7515]) and artifact digest
binding that allow consumers and multi-domain aggregators to
verify publisher authority and third-party evaluations
independently of the serving origin.
* *Lookup, Search, and Federated Discovery (Section 4):* Defines the
HTTP REST interface (POST /search, POST /explore, and GET /agents)
for structured filtering, semantic vector search, faceted
exploration, and federated routing (auto, referrals, and none)
across ARD Registries.
2. Conventions and Definitions
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.
This document uses the architectural terminology (Agentic Resource,
ARD Entry, Manifest, Registry, Publisher, Domain Owner, Consumer,
Discovery Identifier, and Trust Manifest) defined in [ARD-ARCH].
3. The ARD Entry and Manifest Format
The primary information model of ARD is the *ARD Entry* — the
description of a single agentic resource carrying both core
descriptive metadata and the discovery signals (representativeQueries
and structured capabilities) required to make resources comparable
and discoverable across publishers. ARD is defined over ARD entries;
the container an entry travels in (a hosted manifest/catalog or a
registry API response) is a transport concern.
3.1. JSON-LD Representation and Base Context
An ARD entry is a JSON-LD node. The authoritative ARD base context
is published at:
Bu, et al. Expires 3 May 2027 [Page 4]
Internet-Draft ARD Manifest and Lookup October 2026
https://agenticresourcediscovery.org/context/v1
The base context maps core terms to Internationalized Resource
Identifiers (IRIs) under the namespace
https://agenticresourcediscovery.org/ns#.
A conforming ARD consumer or registry MUST interpret an entry by
applying the ARD base context as the initial expansion context (the
JSON-LD expandContext option). An entry's local @context, when
present, is layered on top of the base context: it MAY introduce new
namespace prefixes or override existing ones, but does not discard
the base. Under this rule, core terms resolve to their standard
IRIs, while namespaced extension terms resolve through the prefixes
declared in the entry.
Including @context in an entry is OPTIONAL when served within an ARD
manifest, as compliant processors automatically inject the base
context. An entry SHOULD include @context when exchanged outside an
ARD manifest (such as in generic JSON-LD documents or third-party
feeds) where generic processors might otherwise lack the base
context.
3.2. Entry Fields
The following fields comprise an ARD entry:
3.2.1. Required Fields
identifier (String, MUST): A globally unique, domain-anchored URN
following the syntax defined in Section 3.4 (e.g.,
urn:air:example.com:agent:flight-finder) that identifies a
specific agentic resource instance published under the <publisher>
domain's authority (rather than an abstract capability class
shared across independent vendors). The JSON-LD @id MAY mirror
this identifier.
displayName (String, MUST): A human-readable display name for the
agentic resource.
type (String, MUST): The artifact media type formatted as an IANA
Media Type string (e.g., application/mcp-server-card+json,
application/a2a-agent-card+json).
url OR data (MUST, exactly one): The capability payload delivery
mechanism. An entry MUST specify either url or data, but MUST NOT
specify both (see Section 3.3).
Bu, et al. Expires 3 May 2027 [Page 5]
Internet-Draft ARD Manifest and Lookup October 2026
3.2.2. Recommended Discovery Signals
representativeQueries (Array of Strings, SHOULD): A list of 2 to 5
representative natural language user prompts or queries that this
capability is designed to fulfill — the primary signal from which
registries build semantic vector indices. Omitting this field
severely degrades search discoverability. Conformance tooling
flags missing or under-populated queries as a warning rather than
a hard failure to accommodate entries originating from basic
catalogs.
capabilities (Array of Strings, MAY): Strings naming specific skills
or tools exported by the resource (e.g., ["WeatherQuery",
"ForecastLookup"]) or JSON-LD vocabulary terms mapped via @context
that enable high-performance structured filtering without fetching
the complete artifact card.
3.2.3. Optional Descriptive Fields
description (String, OPTIONAL): A detailed natural language summary
of the capability, its purpose, and operational characteristics.
tags (Array of Strings, OPTIONAL): Categorical tags for indexing
(e.g., ["travel", "finance", "utility"]).
version (String, OPTIONAL): A version identifier (e.g., SemVer
1.2.0).
digest (String, OPTIONAL): An algorithm-prefixed cryptographic
digest (<alg>:<hex>, e.g., sha256:9f86d08...) of the target
artifact referenced by url (or inline data). Implementations MUST
support sha256 and MAY support additional collision-resistant hash
algorithms (such as sha384 or sha512).
updatedAt (String, OPTIONAL): An [RFC9110] or ISO 8601 UTC timestamp
indicating when the record was last modified.
metadata (Object, OPTIONAL): An open key-value mapping for arbitrary
operational metadata (e.g., rate limits, region availability).
trustManifest (Object, OPTIONAL): A cryptographic trust envelope
containing publisher identity assertions, provenance chains, and
compliance attestations (see Section 3.5).
3.3. Value-or-Reference Pattern and Hypermedia Linking
An entry delivers its capability manifest through either reference
(url) or value (data):
Bu, et al. Expires 3 May 2027 [Page 6]
Internet-Draft ARD Manifest and Lookup October 2026
* *Reference (url - Primary Link-Based Model):* A URI pointing
directly to the external artifact descriptor (such as an Agent
Card, OpenAPI schema, or MCP server manifest). ARD is
fundamentally *link-based*: the registry indexes discovery
metadata and returns reference links, leaving the client to fetch
operational descriptors directly from the capability host. This
ensures that the registry remains strictly decoupled from the
runtime execution data path and avoids serving as a proxy or
single point of failure. When an entry using url carries content-
bound attestations in trustManifest, the entry SHOULD include
digest to lock the referenced descriptor's content against post-
publication modification at url.
* *Value (data - Inline Fallback):* The complete artifact document
embedded directly inline as a JSON object. This is provided as an
optional mechanism for standalone, isolated, or air-gapped
environments where an additional network resolution round-trip is
impossible or undesirable.
An entry MUST carry exactly one of url or data, and MUST NOT include
both.
3.4. Domain-Anchored URN Syntax
The discovery identifier MUST be a Uniform Resource Name (URN)
adhering to [RFC8141] using the formal urn:air: namespace prefix:
urn:air:<publisher>:<namespace>:<agent-name>
Where:
* urn:air: The assigned ARD namespace identifier.
* <publisher>: The fully qualified domain name (FQDN) of the
publishing authority (e.g., example.com, cloud.google.com).
* <namespace>: A sub-organization, project, or category identifier
defined by the publisher (e.g., travel, devtools, hr).
* <agent-name>: A unique name identifying the agentic resource
instance within that publisher's namespace.
This domain-anchored structure guarantees global uniqueness without
requiring a centralized naming committee, leverages existing DNS
ownership for authority, and allows registries to parse publisher
boundaries deterministically.
Bu, et al. Expires 3 May 2027 [Page 7]
Internet-Draft ARD Manifest and Lookup October 2026
Separating the logical resource identifier (urn:air:...) from
physical content delivery (url or data) serves several protocol
requirements:
* *Uniform Identity Across url and Inline data:* Entries delivered
by value via data (such as inline skills, prompt templates, or
embedded MCP configurations) do not have a separate artifact url.
The urn:air identifier provides a uniform primary key regardless
of delivery mode.
* *Origin Independence and Deduplication:* A resource's physical
hosting url may change across staging and production environments,
CDN mirrors, or cloud providers without changing the logical
resource. The (identifier, version) tuple enables crawlers,
registries, and federated peers to deduplicate entries and
correlate third-party trustManifest evaluations across catalogs,
while keeping provenance links (provenance[].sourceId) stable
across hosting migrations.
* *Cryptographic Publisher Binding vs. Hosting Origin:* Note that
the HTTP origin hosting the manifest (/.well-known/ard.json), the
<publisher> domain in the URN, and the host in the entry's url
field do not need to be the same domain. For example, a catalog
hosted at https://example.com/.well-known/ard.json may include an
entry published by abc.com (urn:air:abc.com:agent:flight-finder)
whose descriptor url is hosted on a cloud provider
(https://xyz.execute-api.us-east-1.amazonaws.com/agent.json),
where the TLS certificate of url belongs to the cloud provider
rather than abc.com. An unverified urn:air:<publisher>:... string
carries no implicit trust; binding the URN to <publisher> requires
verifying a trustManifest signed by a key authorized by
<publisher> (e.g., did:web:<publisher>). Because a manifest or
registry response can contain entries from multiple publishers,
each entry carries its full urn:air:<publisher>:... URN rather
than a relative suffix.
* *Separation from Runtime Workload Identity:* Whereas runtime
workload identifiers (such as spiffe:// or WIMSE Workload Identity
Tokens) authenticate live execution instances during active
registration ([AGENT-DIRECTORY]) or runtime invocation, urn:air
identifies the published catalog artifact across versions and
registries.
Bu, et al. Expires 3 May 2027 [Page 8]
Internet-Draft ARD Manifest and Lookup October 2026
3.5. Identity and the Trust Manifest
To satisfy enterprise compliance, supply-chain verification, and
zero-trust policies, an ARD entry MAY carry a trustManifest object
(or a trustManifests array when multiple parties — such as the
original publisher and an independent security auditor — attach
separate signed manifests to the same entry):
{
"identifier": "urn:air:example.com:agent:flight-finder",
"type": "application/a2a-agent-card+json",
"version": "1.2.0",
"url": "https://agents.example.com/flight-finder/agent.json",
"digest": "sha256:9f86d081884c7d659a2feaa0c55ad015...",
"trustManifest": {
"identity": "did:web:example.com",
"issuedAt": "2026-03-20T14:00:00Z",
"subject": {
"identifier": "urn:air:example.com:agent:flight-finder",
"type": "application/a2a-agent-card+json",
"version": "1.2.0",
"digest": "sha256:9f86d081884c7d659a2feaa0c55ad015..."
},
"attestations": [
{
"type": "https://slsa.dev/provenance/v1",
"uri": "https://example.com/attestations/slsa.json",
"mediaType": "application/vnd.in-toto+json",
"digest": "sha256:7f83b1657ff1fc53b92dc18148a1d65d..."
}
],
"signature": "eyJhbGciOiJFUzI1NiIsImtpZCI6ImRpZDp3ZWI6..."
}
}
Each trustManifest object is a self-contained signed envelope with
the following core fields and signature semantics:
* identity (String, MUST): The cryptographic signer identifier (for
example, did:web:example.com, resolved over HTTPS from
https://example.com/.well-known/did.json).
* issuedAt (String, SHOULD) and expiresAt (String, MAY): ISO 8601
timestamps indicating when the manifest was signed and, for
periodic third-party evaluations, when the assertion expires.
Bu, et al. Expires 3 May 2027 [Page 9]
Internet-Draft ARD Manifest and Lookup October 2026
* subject (Object, MUST): A self-contained block containing the
target entry's release coordinates (identifier, type, digest, and
version when present on the entry). Including subject directly
inside trustManifest allows the manifest to be canonicalized and
verified as a standalone JSON object without cross-level JSON
stitching.
* attestations (Array, MAY) and provenance (Array, MAY): Hash-pinned
references (uri + digest) to external supply-chain or compliance
evidence (such as SLSA build provenance, SPDX SBOMs, SARIF
vulnerability scans, or SOC 2 audit reports) and artifact lineage
links (sourceId + sourceDigest).
* signature (String, MUST): A JSON Web Signature (JWS) [RFC7515]
computed over the JSON Canonicalization Scheme (JCS) [RFC8785]
serialization of the trustManifest object with the signature
member removed. The JWS Protected Header specifies the signing
algorithm (alg, with ES256 Mandatory-to-Implement) and key
identifier (kid).
3.5.1. Publisher and Verifier Authority Binding
A trustManifest signature cryptographically binds the signer
(identity) to the artifact coordinates in subject (identifier, type,
version, digest) and to the referenced attestations and provenance
digests. Verifiers distinguish two roles:
1. *Publisher Authority (Publisher Profile):* To establish that the
entry was genuinely published by <publisher> in
urn:air:<publisher>:..., the entry MUST include a trustManifest
whose identity matches or is cryptographically authorized by
<publisher> (e.g., did:web:<publisher>). Verifying registries
and consumers MUST confirm that (a) trustManifest.subject
(identifier, type, digest, and version) matches the parent entry,
(b) trustManifest.identity binds to <publisher>, and (c)
trustManifest.signature is valid over the JCS-canonicalized
trustManifest. Entries failing these checks MUST be rejected.
2. *Third-Party Verifier Attestations (Signer Profile):* Independent
security auditors, compliance bodies, or evaluation services
(whose identity domain differs from <publisher>, e.g.,
did:web:auditor.example.org) MAY attach an additional
trustManifest in trustManifests[] over the same subject
coordinates to endorse third-party evaluation results without
altering the publisher's manifest. A third-party manifest
attests only the evaluator's claims and does not substitute for
the publisher's trustManifest.
Bu, et al. Expires 3 May 2027 [Page 10]
Internet-Draft ARD Manifest and Lookup October 2026
3.5.2. Cryptographic Subject Binding and Integrity Digests
Attestations in trustManifest.attestations involve two distinct
integrity bindings:
1. *Binding the Attestation to the Target Artifact:* To prevent
attestation transplantation (where an attacker copies a valid
attestation from one agent into another entry's metadata), each
third-party attestation statement MUST either be a direct
cryptographic signature over the artifact or include a signed
subject claim that identifies the resource's identifier and/or
the artifact's content digest. When the artifact is referenced
via url rather than inline data, the ARD entry MUST include the
top-level digest field so that the referenced bytes at url are
bound to the attested digest.
2. *Pinning the External Attestation Document
(attestations[].digest):* Because external attestation documents
referenced by attestations[].uri (such as PDF compliance reports,
SARIF scan results, or SLSA provenance files) may be hosted on
external servers or in formats that do not carry self-contained
signatures, the optional digest field inside each attestations[]
item records the cryptographic hash of the external attestation
document itself. Sealed under trustManifest.signature, this acts
as a subresource integrity pin ensuring the external file at
attestations[].uri cannot be replaced or modified after the
trustManifest is signed.
All digest strings (digest, attestations[].digest, and
provenance[].sourceDigest) use the algorithm-prefixed <alg>:<hex>
format (e.g., sha256:...) to support hash agility; sha256 is
Mandatory-to-Implement (MTI).
3.6. The ARD Manifest Container
When published as a static catalog document (at an entry point URI
discovered via [ARD-INITIAL-CONTACT], such as https://{domain}/.well-
known/ard.json), ARD entries are packaged in an application/ard+json
document containing a top-level entries array:
Bu, et al. Expires 3 May 2027 [Page 11]
Internet-Draft ARD Manifest and Lookup October 2026
{
"entries": [
{
"identifier": "urn:air:acme.com:tools:weather",
"displayName": "Acme Weather Service",
"type": "application/mcp-server-card+json",
"url": "https://api.acme.com/mcp/weather.json",
"capabilities": ["CurrentWeather", "Forecast"],
"representativeQueries": [
"what is the weather in Seattle",
"get tomorrow's rain forecast"
]
}
]
}
A publisher is not required to enumerate its capabilities in a static
manifest; it MAY instead operate a dynamic Agent Registry exposing
the query interface (Section 4.2) directly, or publish a minimal
manifest containing a single application/ai-registry+json entry whose
url advertises the Base URI of its dynamic Agent Registry service.
For web crawlers, publishers MAY also signal their manifest in HTML
<head> elements using <link rel="ard" type="application/ard+json"
href="...">.
4. Lookup, Search, and Federated Discovery
Whether a publisher exposes a dynamic Agent Registry directly or
third-party registries aggregate entries across domains, clients
query Agent Registries to perform structured, semantic, and faceted
discovery.
4.1. Registry Ingestion and Companion Protocols
An Agent Registry may operate as a publisher's own dynamic discovery
endpoint, as a standalone search service that ingests entries via web
crawling, or as a dual-role Agent Directory that pairs lookup with an
active registration service. This document specifies the *Lookup and
Search Interface* (Section 4.2 and Section 4.3), which builds upon
two companion specifications:
Bu, et al. Expires 3 May 2027 [Page 12]
Internet-Draft ARD Manifest and Lookup October 2026
* *Initial Contact and Entry Point Discovery
([ARD-INITIAL-CONTACT]):* Clients and registry crawlers obtain
manifest or registry entry point URIs using the mechanisms defined
in [ARD-INITIAL-CONTACT] — including DNS Service Binding (SVCB /
HTTPS) records under _entries._agents.<domain> or
_search._agents.<domain>, DNS-Based Service Discovery (_ard._tcp)
over unicast DNS or Multicast DNS, the baseline well-known URI
(/.well-known/ard.json), and the ard HTTP link relation.
* *Active Registration and Soft-State Lifecycle
([AGENT-DIRECTORY]):* For dual-role Agent Directories that accept
active registrations from live agent workloads or Commissioning
Tools (CTs), the registration wire protocol, soft-state lifetime
(lt) renewals, and workload identity authentication (such as IETF
WIMSE [WIMSE-ARCH] Workload Identity Tokens and Workload Proof
Tokens, SPIFFE IDs, or ID-JAG assertions) are specified in
[AGENT-DIRECTORY] (drawing from [RFC9176]). A registry MAY verify
whether the asserted workload identity or trustManifest binds to
the <publisher> domain declared in the entry's URN (see
Section 3.5.1) and use the outcome for verified status indicators,
filtering, ranking, or admission decisions.
4.1.1. Ingestion and Crawling Pipelines
Registries populate and refresh their discovery indices through
automated ingestion and crawling pipelines that:
* Discover and fetch publisher /.well-known/ard.json manifests, HTTP
ard link relations, HTML <link rel="ard"> tags, and DNS-advertised
entry points over TLS 1.3 (per [ARD-INITIAL-CONTACT]).
* Ingest validated manifests and entries from software repositories,
package registries, and federated peer registries.
As in [ARD-INITIAL-CONTACT] and the CoRE Resource Directory
architecture (Section 7.2 of [RFC9176]), a discovery channel or
registry is authoritative for its own lookup and search responses,
not for the third-party agent resources it lists. Entry point URIs
and entries ingested from static manifests, HTML <link rel="ard">
tags, package registries, or federated peer registries serve as
discovery *hints* until publisher authority and artifact integrity
are verified via the entry's signed trustManifest and the target
resource at url (see Section 4.3.1 and Section 6.2).
Bu, et al. Expires 3 May 2027 [Page 13]
Internet-Draft ARD Manifest and Lookup October 2026
4.2. The Search and Query HTTP API
In accordance with BCP 56 [RFC9205], compliant Agent Registries MUST
expose an HTTP query interface over HTTPS conforming to [RFC9110]
(supporting HTTP/1.1 and HTTP/2, and optionally HTTP/3), MAY
additionally offer protocol-specific wrappers, and MAY document their
endpoints using the OpenAPI Specification [OpenAPI]. A registry
discovers peer registries by recognizing entries whose type is
application/ai-registry+json.
To avoid squatting on root URI paths ([RFC8615], Section 4.3 of
[RFC9205]), the endpoint paths /search, /explore, and /agents defined
in this section are relative to the Registry's discovered *Base URI*
(advertised in the url field of the registry's application/ai-
registry+json entry, e.g., https://registry.example.com/ard/v1).
Requests with a message body and successful responses use the
application/json media type unless a specific profile media type is
negotiated via Accept / Content-Type headers.
4.2.1. Universal Query Model
Search and introspection endpoints accept a unified query object
comprising three optional elements: @context, text, and filter:
{
"query": {
"@context": {
"okf": "https://openknowledgeformat.org/ns#"
},
"text": "book a round-trip flight to Tokyo next Monday",
"filter": {
"type": ["application/a2a-agent-card+json"],
"tags": ["travel", "booking"],
"okf:regulatoryZone": ["JP", "US"],
"trustManifest.attestations.type": ["SOC2-Type2"]
}
}
}
* @context: Defines JSON-LD prefix mappings used for keys inside
filter.
* text: Natural language user intent used for semantic relevance
matching and vector search.
Bu, et al. Expires 3 May 2027 [Page 14]
Internet-Draft ARD Manifest and Lookup October 2026
* filter: Key-value map of exact structural constraints. Keys
represent term paths (resolved via @context and the base context).
Values are arrays combined with OR logic; multiple keys are
combined with AND logic.
4.2.2. Search Endpoint (POST /search)
The Search endpoint executes semantic ranking combined with
structured filtering over the registry index.
4.2.2.1. Search Request Schema
{
"query": {
"text": "flight booking assistant",
"filter": {
"type": ["application/a2a-agent-card+json"]
}
},
"federation": "referrals",
"pageSize": 5,
"pageToken": "eyJwYWdlIjoxfQ=="
}
Parameters:
* query.text (String, MUST): The semantic search prompt.
* query.filter (Object, OPTIONAL): Structured filter constraints.
* federation (String, OPTIONAL): Federation routing mode ("auto",
"referrals", or "none", default: "auto").
* pageSize (Integer, OPTIONAL): Maximum results to return (default:
10, max: 100).
* pageToken (String, OPTIONAL): Pagination cursor token.
4.2.2.2. Search Response Schema
Bu, et al. Expires 3 May 2027 [Page 15]
Internet-Draft ARD Manifest and Lookup October 2026
{
"results": [
{
"identifier": "urn:air:skyways.com:agents:flight-booker",
"displayName": "Skyways Flight Booker",
"type": "application/a2a-agent-card+json",
"url": "https://api.skyways.com/agents/booking.json",
"score": 96,
"source": "https://registry.skyways.com"
}
],
"referrals": [
{
"identifier": "urn:air:globaltravel.org:registry:main",
"displayName": "Global Travel Agent Registry",
"type": "application/ai-registry+json",
"url": "https://registry.globaltravel.org/search"
}
],
"nextPageToken": "eyJwYWdlIjoyfQ=="
}
The score integer parameter (0 to 100) indicates informational
semantic relevance calculated by the registry.
4.2.3. Explore Endpoint (POST /explore)
The Explore endpoint allows clients to introspect registry contents,
aggregate distributions, and inspect available facets without
returning full entry records.
4.2.3.1. Explore Request Schema
{
"query": {
"filter": {
"type": ["application/mcp-server-card+json"]
}
},
"resultType": {
"facets": [
{ "field": "capabilities", "limit": 10 },
{ "field": "publisher", "limit": 5 }
]
}
}
Bu, et al. Expires 3 May 2027 [Page 16]
Internet-Draft ARD Manifest and Lookup October 2026
4.2.3.2. Explore Response Schema
{
"resultType": "facets",
"facets": {
"capabilities": {
"buckets": [
{ "value": "WeatherTool", "count": 142 },
{ "value": "WebSearch", "count": 98 }
],
"otherCount": 12
}
}
}
4.2.4. Deterministic List Endpoint (GET /agents)
A lightweight, cacheable HTTP GET endpoint for administrative
browsing, catalog synchronization, and developer tooling. Supports
standard query parameters: pageSize, pageToken, and a deterministic
filter query string.
4.2.5. Standard Error Responses
When a query fails or cannot be processed, conforming registries MUST
return an appropriate HTTP status code and SHOULD return an HTTP
Problem Details object (application/problem+json) conforming to
[RFC9457] (per Section 4.7 of [RFC9205]), including a machine-
readable error code extension member:
{
"type": "https://agenticresourcediscovery.org/problems/invalid-argument",
"title": "Invalid Argument",
"status": 400,
"detail": "Malformed query JSON or unsupported filter term.",
"error": "INVALID_ARGUMENT"
}
Bu, et al. Expires 3 May 2027 [Page 17]
Internet-Draft ARD Manifest and Lookup October 2026
+==============+=====================+==============================+
| HTTP Status | Error Code | Description |
+==============+=====================+==============================+
| 400 Bad | INVALID_ARGUMENT | Malformed query JSON, |
| Request | | missing required fields, |
| | | or invalid filter |
| | | syntax. |
+--------------+---------------------+------------------------------+
| 401 | UNAUTHENTICATED | Missing or invalid |
| Unauthorized | | authentication |
| | | credentials. |
+--------------+---------------------+------------------------------+
| 403 | PERMISSION_DENIED | Caller lacks sufficient |
| Forbidden | | access permissions for |
| | | the registry or |
| | | resource. |
+--------------+---------------------+------------------------------+
| 404 Not | NOT_FOUND | Specified agent |
| Found | | identifier, registry, or |
| | | endpoint does not exist. |
+--------------+---------------------+------------------------------+
| 429 Too Many | RATE_LIMIT_EXCEEDED | Request rate limit |
| Requests | | exceeded; server SHOULD |
| | | include a Retry-After |
| | | header field ([RFC9110]) |
| | | and client SHOULD retry |
| | | with backoff. |
+--------------+---------------------+------------------------------+
| 500 Internal | INTERNAL_ERROR | Internal server or |
| Server Error | | unhandled storage |
| | | failure. |
+--------------+---------------------+------------------------------+
| 501 Not | NOT_IMPLEMENTED | Requested feature (e.g., |
| Implemented | | Explore endpoint or |
| | | unsupported federation |
| | | mode) is not |
| | | implemented. |
+--------------+---------------------+------------------------------+
Table 1
4.3. Federated Routing and Scalability
Registries coordinate in a decentralized mesh using the federation
parameter:
Bu, et al. Expires 3 May 2027 [Page 18]
Internet-Draft ARD Manifest and Lookup October 2026
* *auto:* The queried registry forwards the query to its upstream
peer registries, aggregates and de-duplicates the result sets, and
returns a unified response to the client.
* *referrals:* The registry returns its own local matches along with
a list of referrals pointing to downstream or domain-specific
registries. The client decides which registries to query next.
* *none:* The registry queries only its locally indexed entries.
Figure 1 illustrates the query flows for the auto and referrals modes
(whereas none restricts search to Registry A's local index):
Mode 1: "auto" (Recursive) Mode 2: "referrals" (Iterative)
+----------+ +----------+ +----------+ +----------+
| Consumer |------->| Registry | | Consumer |------->| Registry |
| |<-------| A | | |<-------| A |
+----------+ Agg. +----------+ +----------+ Local +----------+
Results | ^ | ^ + Referrals
Fwd | | Peer | |
Query | | Results | +--- Follow Referral
v | | Query / Results
+----------+ | +----------+
| Peer | +------->| Peer |
| Registry | | Registry |
+----------+ +----------+
Figure 1: Federated Registry Query Flows
To prevent infinite loops and denial-of-service amplification across
federated registries, registries MUST maintain a hopCount and reject
or truncate queries exceeding a maximum hop limit (default: 3 hops).
4.3.1. Federation Trust Model and Origin Binding
Federated discovery introduces two distinct verification boundaries:
1. *Non-Authoritative Downstream Registries:* In both "auto" and
"referrals" modes, peer registries act as non-authoritative
discovery intermediaries (analogous to Section 7.2 of [RFC9176]).
A TLS connection to a registry authenticates only that registry
(source), not the <publisher> of the entries it returns.
Consequently, neither an aggregating registry in "auto" mode nor
a client following "referrals" MUST rely on transport trust in a
downstream registry to establish publisher authority. Instead,
consumers and verifying registries MUST validate each entry's
signed trustManifest against the <publisher> domain (and any
Bu, et al. Expires 3 May 2027 [Page 19]
Internet-Draft ARD Manifest and Lookup October 2026
third-party verifier trustManifest against the verifier's
identity); entries lacking a verified publisher trustManifest
MUST be treated as unverified discovery hints. In "referrals"
mode, clients can also evaluate the referred registry's identity
before transmitting sensitive query text.
2. *Binding Location url to the Target Origin:* A valid
trustManifest signature from <publisher> proves that <publisher>
authorized the entry (urn:air:<publisher>:...), but if url points
to a different origin (for example,
urn:air:attacker.example:agent:foo specifying "url":
"https://victim.example.com/service"), <publisher>'s signature
alone does not prove that the target origin (victim.example.com)
consented to host that resource. When the origin of url differs
from https://<publisher>, consumers and verifying registries MUST
verify that the artifact descriptor retrieved from url matches
the entry's signed cryptographic digest and explicitly declares
the matching identifier (urn:air:<publisher>:...) or publisher
identity (trustManifest.identity) before invoking the resource.
4.3.2. Referrals Federation Example
When a consumer specifies "federation": "referrals", the registry
returns its direct capability matches in results alongside an array
of referrals pointing to downstream or specialized registries
matching the query scope:
Request:
{
"query": {
"text": "find corporate travel booking agents"
},
"federation": "referrals"
}
Response:
Bu, et al. Expires 3 May 2027 [Page 20]
Internet-Draft ARD Manifest and Lookup October 2026
{
"results": [
{
"identifier": "urn:air:example.com:agent:internal-travel",
"displayName": "Internal Corporate Travel Assistant",
"type": "application/a2a-agent-card+json",
"url": "https://corp.example.com/agents/travel.json",
"score": 92,
"source": "https://registry.corp.example.com"
}
],
"referrals": [
{
"identifier": "urn:air:travelmesh.org:registry:global",
"displayName": "Global Travel Agent Registry",
"type": "application/ai-registry+json",
"url": "https://finder.travelmesh.org/search"
},
{
"identifier": "urn:air:partnernet.com:registry:alliances",
"displayName": "Airline Alliances Registry",
"type": "application/ai-registry+json",
"url": "https://registry.partnernet.com/search"
}
]
}
5. Formal CDDL Specification
The normative grammar of the ARD manifest, entry, and REST payloads
is defined in Concise Data Definition Language (CDDL) [RFC8610]:
start = ard-manifest
; --- The Manifest ---
ard-manifest = {
entries: [* ard-entry],
* tstr => any
}
; --- The ARD Entry ---
ard-entry = {
ard-entry-required,
ard-entry-descriptive,
* tstr => any
}
ard-entry-required = (
Bu, et al. Expires 3 May 2027 [Page 21]
Internet-Draft ARD Manifest and Lookup October 2026
; URN: urn:air:{publisher}:{namespace}:{agent-name}
identifier: tstr,
displayName: tstr,
type: tstr, ; IANA Media Type
content-delivery ; value-or-reference
)
ard-entry-descriptive = (
? "@context" => any,
? "@id" => tstr,
? description: tstr,
? tags: [+ tstr],
? capabilities: [+ tstr],
? representativeQueries: [* tstr],
? version: tstr,
? digest: tstr,
? updatedAt: tstr,
? metadata: {* tstr => any},
? trustManifest: trust-manifest,
? trustManifests: [+ trust-manifest]
)
content-delivery = (
url: tstr //
data: {* tstr => any}
)
; --- Trust Envelope ---
trust-manifest = {
identity: tstr,
? issuedAt: tstr,
? expiresAt: tstr,
? subject: trust-subject,
? identityType: tstr,
? trustSchema: trust-schema,
? attestations: [* attestation],
? provenance: [* provenance-link],
? signature: tstr,
* tstr => any
}
trust-subject = {
identifier: tstr,
type: tstr,
? version: tstr,
? digest: tstr,
? url: tstr,
* tstr => any
Bu, et al. Expires 3 May 2027 [Page 22]
Internet-Draft ARD Manifest and Lookup October 2026
}
trust-schema = {
? identifier: tstr,
? version: tstr,
? governanceUri: tstr,
? verificationMethods: [* tstr],
* tstr => any
}
attestation = {
type: tstr,
uri: tstr,
? mediaType: tstr,
? digest: tstr,
* tstr => any
}
provenance-link = {
relation: tstr,
sourceId: tstr,
? sourceDigest: tstr,
* tstr => any
}
; --- Search API Payloads ---
query-model = {
? text: tstr,
? "@context" => any,
? filter: {* tstr => ([+ tstr] / tstr)}
}
search-request = {
query: query-model,
? federation: "auto" / "referrals" / "none",
? pageSize: uint,
? pageToken: tstr
}
search-response = {
results: [* search-result-item],
? referrals: [* registry-referral],
? nextPageToken: tstr
}
search-result-item = {
identifier: tstr,
? displayName: tstr,
Bu, et al. Expires 3 May 2027 [Page 23]
Internet-Draft ARD Manifest and Lookup October 2026
? type: tstr,
? url: tstr,
? digest: tstr,
? trustManifest: trust-manifest,
score: 0..100,
source: tstr,
* tstr => any
}
registry-referral = {
identifier: tstr,
displayName: tstr,
type: "application/ai-registry+json",
url: tstr
}
; Helper types
any = any-cbor / any-json
any-cbor = bool / int / float / tstr / bstr /
[* any-cbor] / {* any-cbor => any-cbor}
any-json = bool / int / float / tstr / null /
[* any-json] / {* tstr => any-json}
null = nil
6. Security Considerations
Discovery protocols for autonomous systems operate in adversarial
environments where malicious capability advertisements could
misdirect automated actions, trigger unauthorized tool invocations,
or exfiltrate private conversation contexts.
6.1. Threat Model
The ARD security architecture considers the following primary threat
vectors:
1. *Namespace Squatting and Impersonation:* An attacker advertises
an agent under a reputable organization's domain name (e.g.,
asserting urn:air:google.com:... without holding administrative
control over google.com).
2. *Relevance Score Poisoning (SEO Injection):* An attacker injects
deceptive, highly generic, or adversarial terms into
representativeQueries or description to artificially inflate the
agent's ranking in response to high-value user prompts (such as
financial or credential-handling queries).
Bu, et al. Expires 3 May 2027 [Page 24]
Internet-Draft ARD Manifest and Lookup October 2026
3. *Attestation Transplantation:* An attacker extracts a
cryptographically valid compliance attestation (e.g., SOC2 or
security audit) from a legitimate agent and embeds it into a
malicious entry's metadata.
4. *Federation Amplification and Query Loops:* A hostile registry
initiates recursive queries across federated peers designed to
trigger exponential request explosion or denial-of-service loops.
5. *Prompt and Intent Snooping:* Eavesdroppers or untrusted
intermediary registries harvest sensitive user query prompts
(query.text) to extract proprietary enterprise context, personal
data, or system prompts.
6.2. Publisher Authority Verification
To counter namespace squatting and record tampering, registries and
consumers MUST enforce domain authority binding:
* The <publisher> segment of the urn:air:<publisher>:... identifier
MUST correspond to an authentic FQDN.
* *Cryptographic Publisher and Verifier Verification
(trustManifest):* For end-to-end publisher authentication and
tamper protection across registries, third-party catalogs, and
federated hops, the entry MUST carry a trustManifest signed by a
cryptographic identity authorized by <publisher> (e.g., via W3C
did:web:{publisher} or X.509 SAN certificates; third-party
evaluators MAY attach additional trustManifest signatures bound to
their own verifier domains), and the target resource at url MUST
be bound via its cryptographic content digest. Verifying
registries and consumers MUST reject signed entries whose
cryptographic proof or domain binding fails.
* *Cross-Origin Target url Binding:* Signing an entry under
<publisher> does not authorize the publisher to claim an
unconsenting third-party origin in url. When the origin of url
differs from https://<publisher>, consumers and verifying
registries MUST verify bidirectional binding at the target url by
confirming that the artifact descriptor retrieved from url matches
the entry's signed digest and declares the matching identifier
(urn:air:<publisher>:...) or publisher identity (see
Section 4.3.1).
* *No Implicit Authority from Manifest Host or Transport Origin:*
Retrieving an entry from https://{domain}/.well-known/ard.json
(even when {domain} matches <publisher>), via HTML <link
rel="ard">, or from a discovery registry establishes only
Bu, et al. Expires 3 May 2027 [Page 25]
Internet-Draft ARD Manifest and Lookup October 2026
transport security to the serving host and MUST NOT be treated as
proof of publisher authority. Any entry lacking a verified
trustManifest signature bound to <publisher> MUST be treated by
registries and consumers as an unverified discovery hint.
6.3. Decoupling of Semantic Relevance and Trust
The score returned by POST /search represents solely mathematical
text/semantic similarity between query.text and the indexed
capability. Orchestrators and clients:
* MUST NOT interpret score as an indicator of safety, quality, or
authenticity.
* MUST NOT execute privileged operations or expose sensitive
credentials to an agent solely based on high search scores.
* MUST evaluate security policies, verified trust manifests, and
sandbox restrictions independently of the discovery ranking.
6.4. Attestation Integrity and Subject Binding
To prevent attestation transplantation and post-publication content
substitution:
* *Artifact Subject Binding:* Signed attestations referenced in
trustManifest.attestations (such as SLSA [SLSA] or in-toto
statements) MUST either directly sign the target artifact or bind
to the resource's identifier and/or the artifact's algorithm-
prefixed digest (<alg>:<hex>, with sha256 Mandatory-to-Implement).
When an entry delivers its artifact by reference (url), consumers
MUST compute the digest of the retrieved artifact and verify that
it matches the entry's digest and the attestation subject before
honoring any audit or provenance claims.
* *External Attestation Pinning:* When an entry in
trustManifest.attestations includes digest, consumers fetching the
external attestation document from attestations[].uri MUST verify
that the fetched document's digest matches attestations[].digest
sealed by trustManifest.signature.
Bu, et al. Expires 3 May 2027 [Page 26]
Internet-Draft ARD Manifest and Lookup October 2026
6.5. Mandatory Transport Layer Security (TLS 1.3)
All ARD communications — including static manifest retrieval, DNS
over HTTPS (DoH), registration endpoints, and search API queries —
MUST use Transport Layer Security (TLS) 1.3 [RFC8446] or later in
accordance with BCP 195 [RFC9325]. Implementations MUST use
ephemeral key exchange providing forward secrecy and enforce strict
certificate validation. Cleartext HTTP (plaintext) MUST NOT be
permitted for any public discovery endpoint.
6.6. DoS Protection and Federation Limits
To prevent distributed denial-of-service amplification:
* Registries implementing "auto" federation MUST decrement a Hop-
Count header (maximum initial value: 3). Queries reaching Hop-
Count: 0 MUST NOT be forwarded.
* Registries MUST implement referral loop detection by tracking
visited registry URIs in a query trail header.
* Public registries SHOULD implement rate-limiting per client IP and
authenticated identity.
6.7. Workload Identity and Token Scoping
When dynamic registration interfaces are exposed, registries SHOULD
integrate with standard workload identity protocols such as WIMSE
[WIMSE-ARCH]. Registration tokens MUST be short-lived, audience-
restricted, and cryptographically verified against trusted identity
providers.
7. Privacy Considerations
Natural language queries submitted to POST /search inherently reflect
the user's immediate intent, tasks, and potentially confidential
context.
1. *Query Eavesdropping:* Queries transmitted over open networks can
reveal user activities. Mandatory TLS 1.3 protects query
confidentiality in transit.
2. *Registry Logging and Profile Building:* Third-party public
registries could aggregate queries across time to build
behavioral profiles of individuals or corporate entities.
Conforming public registries SHOULD adopt strict data
minimization, zero-retention, and query anonymization policies.
Bu, et al. Expires 3 May 2027 [Page 27]
Internet-Draft ARD Manifest and Lookup October 2026
3. *Client-Side Intent Filtering:* Client orchestrators SHOULD
sanitize query.text before transmission to external registries,
stripping proprietary source code, credentials, personally
identifiable information (PII), and session identifiers.
8. IANA Considerations
The ard.json Well-Known URI, ard Link Relation, and ard Service Name
registrations are requested in the companion initial contact
specification [ARD-INITIAL-CONTACT]. This document requests the
Media Type and URN Sub-Namespace registrations below.
8.1. Media Type Registrations
IANA is requested to register the following media types in the "Media
Types" registry:
8.1.1. application/ard+json
* *Type name:* application
* *Subtype name:* ard+json
* *Required parameters:* N/A
* *Optional parameters:* N/A
* *Encoding considerations:* binary (JSON UTF-8)
* *Security considerations:* See Section 6 of this document.
* *Interoperability considerations:* Fully compliant with RFC 8259
JSON and JSON-LD 1.1.
* *Specification document:* This document
8.1.2. application/ai-registry+json
* *Type name:* application
* *Subtype name:* ai-registry+json
* *Required parameters:* N/A
* *Optional parameters:* N/A
* *Encoding considerations:* binary (JSON UTF-8)
Bu, et al. Expires 3 May 2027 [Page 28]
Internet-Draft ARD Manifest and Lookup October 2026
* *Security considerations:* See Section 6 of this document.
* *Specification document:* This document
8.2. URN Sub-Namespace Registration: urn:air
IANA is requested to register the formal URN sub-namespace air within
the IETF URN registry adhering to [RFC8141]:
* *Namespace ID:* air (Agentic Information Resource)
* *Structure:* urn:air:<publisher>:<namespace>:<agent-name>
* *Specification:* This document
9. References
9.1. Normative References
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
Requirement Levels", BCP 14, RFC 2119,
DOI 10.17487/RFC2119, March 1997,
<https://www.rfc-editor.org/rfc/rfc2119>.
[RFC7515] Jones, M., Bradley, J., and N. Sakimura, "JSON Web
Signature (JWS)", RFC 7515, DOI 10.17487/RFC7515, May
2015, <https://www.rfc-editor.org/rfc/rfc7515>.
[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>.
[RFC8174] Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC
2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174,
May 2017, <https://www.rfc-editor.org/rfc/rfc8174>.
[RFC8446] Rescorla, E., "The Transport Layer Security (TLS) Protocol
Version 1.3", RFC 8446, DOI 10.17487/RFC8446, August 2018,
<https://www.rfc-editor.org/rfc/rfc8446>.
[RFC8610] Birkholz, H., Vigano, C., and C. Bormann, "Concise Data
Definition Language (CDDL): A Notational Convention to
Express Concise Binary Object Representation (CBOR) and
JSON Data Structures", RFC 8610, DOI 10.17487/RFC8610,
June 2019, <https://www.rfc-editor.org/rfc/rfc8610>.
Bu, et al. Expires 3 May 2027 [Page 29]
Internet-Draft ARD Manifest and Lookup October 2026
[RFC8615] Nottingham, M., "Well-Known Uniform Resource Identifiers
(URIs)", RFC 8615, DOI 10.17487/RFC8615, May 2019,
<https://www.rfc-editor.org/rfc/rfc8615>.
[RFC8785] Rundgren, A., Jordan, B., and S. Erdtman, "JSON
Canonicalization Scheme (JCS)", RFC 8785,
DOI 10.17487/RFC8785, June 2020,
<https://www.rfc-editor.org/rfc/rfc8785>.
[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>.
[RFC9205] Nottingham, M., "Building Protocols with HTTP", BCP 56,
RFC 9205, DOI 10.17487/RFC9205, June 2022,
<https://www.rfc-editor.org/rfc/rfc9205>.
[RFC9457] Nottingham, M., Wilde, E., and S. Dalal, "Problem Details
for HTTP APIs", RFC 9457, DOI 10.17487/RFC9457, July 2023,
<https://www.rfc-editor.org/rfc/rfc9457>.
9.2. Informative References
[A2A] Linux Foundation, "Agent-to-Agent (A2A) Protocol
Specification", 2025,
<https://github.com/a2a-project/spec>.
[AGENT-DIRECTORY]
Jimenez, J. and J. Arkko, "Agent Directory", 2026,
<https://datatracker.ietf.org/doc/draft-jimenez-agent-
directory/>.
[ARD-ARCH] Bu, J., Guha, R. V., Arkko, J., and J. Jiménez, "Agent
Resource Discovery (ARD) Architecture", Work in Progress,
Internet-Draft, draft-bu-dawn-ard-architecture, October
2026, <https://mindpower.github.io/ietf-draft-agent-
resources-architecture/draft-bu-dawn-ard-
architecture.html>.
[ARD-INITIAL-CONTACT]
Jiménez, J., Bu, J., and J. Arkko, "Agent Resource
Discovery (ARD): Initial Contact", Work in Progress,
Internet-Draft, draft-jimenez-ard-initial-contact, October
2026, <https://jaimejim.github.io/ietf-draft-ard-initial-
contact/draft-jimenez-ard-initial-contact.html>.
Bu, et al. Expires 3 May 2027 [Page 30]
Internet-Draft ARD Manifest and Lookup October 2026
[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", 2024,
<https://modelcontextprotocol.io/>.
[OpenAPI] OpenAPI Initiative, "OpenAPI Specification v3.1.0",
February 2021, <https://spec.openapis.org/oas/v3.1.0>.
[RFC9176] Amsüss, C., Ed., Shelby, Z., Koster, M., Bormann, C., and
P. van der Stok, "Constrained RESTful Environments (CoRE)
Resource Directory", RFC 9176, DOI 10.17487/RFC9176, April
2022, <https://www.rfc-editor.org/rfc/rfc9176>.
[RFC9325] Sheffer, Y., Saint-Andre, P., and T. Fossati,
"Recommendations for Secure Use of Transport Layer
Security (TLS) and Datagram Transport Layer Security
(DTLS)", BCP 195, RFC 9325, DOI 10.17487/RFC9325, November
2022, <https://www.rfc-editor.org/rfc/rfc9325>.
[SLSA] OpenSSF, "Supply-chain Levels for Software Artifacts
(SLSA) v1.0", April 2023, <https://slsa.dev/spec/v1.0/>.
[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 Eric Rescorla, Jari Arkko, Mirja
Kühlewind, Warren Kumari, Wes Hardaker, Luca Muscariello, Darrel
Miller, and Jonathan Hefner for their valuable architectural reviews,
security feedback, and interoperability discussions.
Authors' Addresses
Junjie Bu
Google
Email: jbu@google.com
R.V. Guha
Email: guha@guha.com
Shaun Smith
Hugging Face
Bu, et al. Expires 3 May 2027 [Page 31]
Internet-Draft ARD Manifest and Lookup October 2026
Email: shaun.smith@huggingface.co
Jaime Jiménez
Ericsson
Email: jaime.jimenez@ericsson.com
Jeffrey Damick
Amazon
Email: jdamick@amazon.com
Bu, et al. Expires 3 May 2027 [Page 32]