Internet-Draft DAWN Entity MDI November 2026
Zhang Expires 18 May 2027 [Page]
Workgroup:
DAWN Working Group
Internet-Draft:
draft-zhangb-dawn-entity-mdi-00
Published:
Intended Status:
Standards Track
Expires:
Author:
B. Zhang, Ed.
Pengcheng Laboratory

Generalizing the DAWN MDI for All Entity Types

Abstract

The DAWN Minimum Discoverable Information (MDI) information model [I-D.cui-dawn-mdi-model] defines a small, encoding-neutral common header -- three mandatory elements, a short set of recommended and optional elements, and the minimal constraints among them. In parallel, local-discovery work [I-D.jakab-dawn-agent-discovery-mdns] [I-D.blwm-dawn-common-discovery-parameters] has converged on a single-DNS-SD-service-type model in which one generic service type carries instances of every agent protocol, distinguished by a protocol key, with one instance per protocol and a descriptor reference pointing to richer metadata.

This document generalizes the MDI information model so that the same minimal header describes any DAWN entity. In the context of DAWN, entities include, but are not limited to, AI agents and AI resources [I-D.farrel-dawn-terminology]. An AI resource may be an individual named agent or a service such as a catalog that will further the discovery process, and the model is designed to extend cleanly to tools, tasks, data sources, models, workloads, brokers, and application endpoints. The generalization reuses the existing agent MDI without change: the element set, the constraints, and the DNS-SD binding are inherited, and extension is achieved by opening the value space of one element (entity type) and by per-type profiles, not by new core elements. Clients discover agents, MCP servers, LLM API services, and future entity types with a single browse; operators manage one service type.

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 18 May 2027.

▲

Table of Contents

1. Introduction

The DAWN working group has produced two converging lines of work. First, the MDI information model [I-D.cui-dawn-mdi-model] defines the minimum information an entity must provide to be discoverable: exactly three mandatory elements (Entity Identifier, Entity Type, Endpoint), a short set of recommended and optional elements, and minimal constraints, in an encoding-neutral form derivable into many concrete data models. Second, local and global discovery work [I-D.jakab-dawn-agent-discovery-mdns] [I-D.blwm-dawn-common-discovery-parameters] converged on the same structure: one generic DNS-SD service type (_agents._tcp) carries instances of every agent protocol, the protocol is named in a proto key rather than in the service type, one service instance is advertised per protocol, and a descriptor reference (desc-ref, or cardUrl for A2A) points to the full protocol-native description.

The DAWN terminology [I-D.farrel-dawn-terminology] clarifies that, in the context of DAWN, entities include, but are not limited to, AI agents and AI resources. The charter further clarifies that an AI resource "may be an individual named agent or a service such as a catalog that will further the discovery process." This document uses "entity" as the general term for any discoverable object in DAWN.

In parallel, several drafts define discovery for specific entity categories:

Reviewers have observed that the structures arrived at by the agent discovery work and the common discovery parameters work — a protocol key, a version key, an endpoint path, and one service instance per protocol — are equally applicable to an LLM API profile such as Open Responses, which could be "one more protocol in that model, under the same service type rather than a separate one." This document adopts that observation as its core design principle and takes the next step implied by that convergence: it generalizes the MDI information model so that the same minimal header describes any DAWN entity.

1.1. Motivation: Stopping Per-Entity-Type Discovery Proliferation

A clear pattern has emerged in the DAWN progress: every new category of discoverable entity is being given its own discovery protocol definition, even when the underlying discovery mechanism is identical.

The most concrete example is [I-D.cui-dawn-local-llm-api-discovery]. That draft defines discovery for local LLM API services using a brand-new DNS-SD service type, _llm-api._tcp, with a set of TXT keys (txtvers, api, protovers, scheme, base, auth) that are functionally equivalent to the keys already standardized for agent discovery in [I-D.blwm-dawn-common-discovery-parameters] (txtvers, proto, proto-ver, path, auth). The discovery transport (mDNS with PTR/SRV/TXT/A records), the two-stage discovery flow (browse then resolve), and the per-instance rules are identical to those in [I-D.jakab-dawn-agent-discovery-mdns]. The only substantive difference is the entity category: an LLM API service instead of an agent.

If this pattern is not corrected, the DAWN working group will face the following consequences:

  • Duplicated standardization work. Each new entity category will require a dedicated discovery draft, a dedicated IANA service-name registration, a dedicated set of TXT keys, and a dedicated manifest format — even though the discovery mechanism is the same.

  • Inconsistent discovery behavior. Clients that need to find both agents and LLM APIs on the same local network must browse two different service types, parse two different TXT key sets, and implement two different manifest formats, even though the underlying information is structurally identical.

  • Increased client implementation complexity. Every new entity type multiplies the client code paths for browsing, parsing, and dispatching — code that differs only in field names, not in logic.

  • Poor extensibility. Adding a new entity type (e.g., a tool, a data source, a model, a workload) would require a new service-type registration and a new discovery draft, creating a linear growth of standards work for a constant discovery mechanism.

  • Operator burden. Network operators would need to configure, firewall, and monitor a growing number of service types, one per entity category, even though all of them carry the same kind of information.

The root cause is that the entity category (what the entity is) and the discovery transport (how the entity is found) have been coupled. Once they are separated, a single discovery transport serves all entity categories, and new categories are added by registering an entity type value rather than by defining a new discovery protocol.

This document makes that separation. It defines one generalized MDI information model and one extensible entity type registry, layered on top of the existing _agents._tcp service type and the common discovery parameters. The LLM API discovery defined in [I-D.cui-dawn-local-llm-api-discovery] is absorbed as the type=service case with proto=openresponses, eliminating the need for _llm-api._tcp entirely. Future entity categories will be added the same way: a new type value, the same service type, the same DNS keys, the same model.

1.2. Design Principles

The principles of [I-D.cui-dawn-mdi-model], Section 4 — encoding-neutral model, thin core with rich references, discovery-time only, freshness as first-class — are inherited without change. This document adds three principles that govern the generalization:

Reuse before extension:
No new core element is introduced for any current or future entity type. A type is expressed through the value space of the Entity Type element, through profile-specific values of existing elements (e.g., capability-summary tags), and through the extension mechanism. An implementation that ignores Entity Type entirely still obtains a valid MDI instance for an agent: the generalized model degrades to the agent MDI.
Orthogonal axes:
Entity type says WHAT the resource is; the protocol keys say HOW to speak to it. The two are independent. A model resource may expose an Open Responses endpoint; an agent may expose both an A2A and an MCP endpoint. Neither axis is encoded in the DNS-SD service type.
Uniform multiplicity:
The settled rule — one service instance per protocol, with instances of the same logical entity carrying the same descriptor reference so clients can tell they belong together [I-D.blwm-dawn-common-discovery-parameters] — extends uniformly: one service instance per (entity, protocol) pair. The unit of multiplicity is the instance, not the record or the key.

1.3. Requirements Language

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.

2. Terminology

This document uses the terms defined in [I-D.farrel-dawn-terminology] and [I-D.cui-dawn-mdi-model], including Entity, AI resource, Discovery Information, Discoverable Object, Capability Card, Trust Indicator, Minimum Discoverable Information (MDI), publisher scope, and binding. In the context of DAWN, entities include, but are not limited to, AI agents and AI resources [I-D.farrel-dawn-terminology]. This document uses "entity" as the general term and adds:

Entity type:
The coarse kind of an entity, carried in the Entity Type element (Section 4.2). Values are registered in the DAWN Entity Type registry (Section 12).
Profile:
A document that binds the MDI model to one entity type (and, where needed, to specific protocol values), specifying the applicable value spaces, the native description document that the descriptor reference locates, and any type-specific keys. A profile reuses the core model and MUST NOT relax its rules.
Named agent:
An entity of type agent with a stable name, e.g., an A2A agent advertising an AgentCard.
Discovery-furthering service:
An entity of type catalog whose descriptor reference locates a catalog document that lists further entities (or references to them), extending the discovery process beyond the link-local browse.

3. Scope and Non-Goals

This document defines the abstract content of the generalized MDI common header and the framework for extending it. It does NOT define:

The non-goals of [I-D.cui-dawn-mdi-model], Section 3 apply unchanged. MDI remains advertised information, positioned strictly below verification: by itself it asserts nothing a discovering party should treat as verified.

4. Generalized MDI Information Model

An MDI instance is the common header published or returned for one entity. Only three elements are mandatory — Entity Identifier, Entity Type, and Endpoint — so that an entity can be discoverable with a very small record; in constrained carriers, a binding may derive mandatory values from the carrier itself. The element set is exactly that of [I-D.cui-dawn-mdi-model], Section 5, read with "entity" used as the general term. Table 1 states the correspondence; Section 4.1 restates the structure for convenience.

Table 1: Element Correspondence with the MDI Model
This document [I-D.cui-dawn-mdi-model] Semantics
Entity Identifier Entity Identifier unchanged
Entity Type Entity Type value space opened (Section 12)
Entity Summary Entity Summary unchanged
Endpoint Endpoint unchanged
Capability Summary Capability Summary unchanged; tag space per type
Capability Reference Capability Reference unchanged
Trust Reference Trust Reference unchanged
Authentication Hint Authentication Hint unchanged
Freshness Freshness unchanged
Provenance Provenance unchanged
Scope Hint Scope Hint unchanged
Operational Hint Operational Hint unchanged
Extension Extension unchanged

4.1. Structure

The structure of an MDI instance is unchanged from [I-D.cui-dawn-mdi-model], Figure 1:

+--------------+   describes exactly one
| MDI Instance |--------------------------->  entity
+--------------+
  |- entity-identifier                          (1)
  |- entity-type                                (1)
  |- entity-summary                             (0..n)
  |- Endpoint { locator-type, locator,
  |             protocols (1..n) }              (1..n)
  |- capability-summary                         (0..n)
  |- capability-reference : Reference           (0..n)
  |- trust-reference      : Reference           (0..n)
  |- authentication-hint { scheme, metadata? }  (0..n)
  |- freshness { version?, valid-from?,
  |              valid-until?, refresh-hint? }  (0..1)
  |- provenance { publisher,
  |               responsible-party? }          (0..1)
  |- scope-hint                                 (0..n)
  |- operational-hint { status?, detail? }      (0..1)
  |- extension { name, value }                  (0..n)

  Reference = { ref-type, locator, digest? }

A Reference is a typed pointer, unchanged from the MDI model: the ref-type says how to interpret the locator, and the optional digest is an integrity digest over the object the locator identifies.

4.2. Elements

Element definitions, status, and classes (static / mainly-static / dynamic) are those of [I-D.cui-dawn-mdi-model], Section 5.2 and are not repeated here. The only semantic delta is Entity Type:

Entity Type: the kind of entity, from the DAWN Entity Type registry (Section 12). The initial value space is agent, catalog, service, tool, task, data-source, model, workload, broker, and application-endpoint; it is designed to be extended. Entity Type lets a discovering party triage before fetching anything. The value agent is the default (Section 5.1): an instance that does not state an Entity Type denotes a named agent, so every advertisement formed under [I-D.jakab-dawn-agent-discovery-mdns] remains valid under this model.

4.3. Minimal Constraints

Constraints 1-5 of [I-D.cui-dawn-mdi-model], Section 5.3 apply unchanged, with "Entity Identifier" read as the same. This document adds one rule; a binding MAY tighten it but MUST NOT relax it:

  1. 6. Entity Type does not alter the semantics of any other element, and absence of Entity Type means agent. A consumer MUST ignore an Entity Type value it does not recognize, treating the instance as an opaque entity; it MUST NOT fail to parse the remaining elements, and it MUST still apply the Security Considerations of Section 10.

5. Entity Type Registry and Initial Values

Entity Type values are registered in a new registry, "DAWN Entity Types" (Section 12). Registration requires a short definition and, where applicable, a profile reference; it does not require changes to this document. Values MUST be 1-32 characters, lowercase letters, digits, and hyphens, beginning with a letter.

This section defines the initial values. For each value it states the definition, the typical protocol values (the proto axis, Section 7), and the native description document that the Capability Reference / descriptor reference typically locates.

5.1. agent

Definition: an individual named agent — an autonomous or semi-autonomous entity that interacts using an agent protocol. This is the default entity type and the baseline profile of [I-D.jakab-dawn-agent-discovery-mdns].

Typical protocols: a2a (Agent2Agent), mcp (Model Context Protocol), and other registered agent protocols.

Typical description document: the protocol-native agent description — for A2A, the AgentCard located by cardUrl; for MCP, the server metadata document.

5.2. catalog

Definition: a discovery-furthering service: a service whose description enumerates or indexes further entities, so that discovering it advances the discovery process beyond the initial browse. A catalog is a service, specialized by its role in the discovery process.

Typical protocols: https (or the catalog's native query protocol).

Typical description document: a catalog document — a list whose entries are MDI instances or references to them. Resolution of a catalog is recursive discovery (Section 7.3); implementations SHOULD bound recursion and apply the dereferencing protections of Section 10 to every step.

5.3. service

Definition: a network service that provides AI-related capability but is not itself a named agent — e.g., an LLM API service, an embedding endpoint, a retrieval service, or an inference gateway. The LLM API service of [I-D.cui-dawn-local-llm-api-discovery] is an entity of this type.

Typical protocols: openresponses (Open Responses API profile), and other registered API profiles.

Typical description document: the API profile definition and service metadata; the endpoint path is carried directly in the instance.

5.4. tool

Definition: a callable tool or capability server — an entity exposing a set of invocable tools rather than an agent persona. An MCP server advertising tool capabilities is the canonical example; it may equally be advertised as an agent when its role in a deployment is agent-like.

Typical protocols: mcp, and registered tool protocols.

Typical description document: the tool/capability manifest listing the exposed tools.

5.5. task

Definition: a discoverable unit of work — a task definition, job template, or task-queue endpoint that a discovering party may inspect, claim, or schedule according to semantics defined outside MDI.

Typical protocols: the task protocol registered for the deployment.

Typical description document: the task specification or queue descriptor.

5.6. data-source

Definition: a source of data usable by entities or discovering parties — a dataset, stream, knowledge base, or data-serving endpoint.

Typical protocols: https, and registered data protocols.

Typical description document: the dataset/data-service description (a data card or catalog entry).

5.7. model

Definition: a machine-learning model exposed as a discoverable entity — a model endpoint, a model-serving front end, or a model card pointer. Where the model is reachable through an API, the endpoint and protocol are carried as for any entity; the model card is located by the Capability Reference.

Typical protocols: openresponses, and registered serving protocols.

Typical description document: the model card.

5.8. workload

Definition: a schedulable or running workload — a computation, training job, inference batch, or similar unit of execution advertised for discovery, monitoring, or handoff.

Typical protocols: the workload-management protocol registered for the deployment.

Typical description document: the workload descriptor or status document.

5.9. broker

Definition: an intermediary that mediates interaction among entities — e.g., a message broker, an agent broker, or an orchestrator that routes tasks or messages. Unlike a catalog, a broker primarily furthers interaction after discovery.

Typical protocols: the broker's native protocol.

Typical description document: the broker metadata document.

5.10. application-endpoint

Definition: an application endpoint through which users or other applications interact with entities — e.g., a UI endpoint, a webhook receiver, or an application-facing API exposed for integration.

Typical protocols: https, and registered application protocols.

Typical description document: the application endpoint description.

6. Profiles

A profile binds the generalized model to an entity type and protocol values. Profiles are the extension mechanism: adding an entity type or a protocol defines a profile (or amends one); the core model does not change. A profile MUST specify:

A profile MUST NOT relax the MUST elements or the constraints of Section 4.3.

6.1. Agent Profile (Baseline, Reused)

The agent profile is defined by [I-D.jakab-dawn-agent-discovery-mdns] with the common parameter set of [I-D.blwm-dawn-common-discovery-parameters], and it is reused here unchanged. No element of this profile is modified by the generalization. A discovering party that implements only the agent profile interoperates with every advertisement in this document.

6.2. LLM API Service Profile

The LLM API service profile aligns [I-D.cui-dawn-local-llm-api-discovery] with the common model, as anticipated by the observation that an LLM API profile is one more protocol under the same service type:

  • Entity Type: service.

  • Protocol value: openresponses, identified by proto=openresponses (the api key of [I-D.cui-dawn-local-llm-api-discovery] corresponds to the common proto key); the protocol version is carried in proto-ver (the protovers key corresponds to proto-ver), e.g., proto-ver=2026-04-24.

  • Endpoint: the SRV/SVCB target and port give the host and port; the base path is carried in the common path key (the base key corresponds to path); the API base URL is constructed from scheme (https unless a binding states otherwise), host, port, and path.

  • Authentication hint: the common authentication hint, simplified as the auth key with values required/none; auth=none does not constitute authorization.

One instance describes one API profile at one base path on one listener, exactly as in [I-D.cui-dawn-local-llm-api-discovery]; a listener offering several API profiles publishes one instance per profile.

6.3. Other Type Profiles (Template)

Profiles for catalog, tool, task, data-source, model, workload, broker, and application-endpoint follow the same template and are expected as separate documents or future revisions of this one. Until a profile is defined, advertisements of that type carry the core elements only: Entity Type, Entity Identifier, Endpoint (locator and protocols), and, SHOULD, a Capability Reference to the type's native description document. This is sufficient for enumeration, triage, and recursive discovery (for catalogs), and it is the sense in which the model is elastic: a new entity type is discoverable from the day its registry value is assigned, with full profile detail added later without breaking early implementations.

7. Discovery Procedure and DNS-SD Binding

7.1. Single Service Type, Single Browse

All entity types are advertised under one generic DNS-SD service type, following the settled architecture of [I-D.jakab-dawn-agent-discovery-mdns] and [I-D.blwm-dawn-common-discovery-parameters]. The service type name is agents with transport tcp (_agents._tcp) per [I-D.blwm-dawn-common-discovery-parameters]; the earlier spelling _agent._tcp of [I-D.jakab-dawn-agent-discovery-mdns] denotes the same model and the two spellings are to be reconciled in IANA registration (Section 12.2). A separate service type per entity type (e.g., _llm-api._tcp, _tool._tcp) is explicitly NOT used, for the reasons documented in [I-D.blwm-dawn-common-discovery-parameters], Appendix B.5: each additional service type requires its own registration, reconfiguration of mDNS gateways and proxies, splits instance-name uniqueness, and fragments what clients must browse.

A discovering party browses _agents._tcp.local. once and learns, per instance: the Entity Type from the rtype key (absent means agent), the protocol from the proto key, the entity identifier, the endpoint (SRV/SVCB), lightweight selection hints, and the descriptor reference.

7.2. Protocol Values

Protocol values (the proto key) are registered in the "DAWN Entity Protocols" registry (Section 12.3). Values are lowercase, digits, and hyphens (e.g., a2a, mcp, openresponses). A protocol value names the application protocol spoken at the advertised endpoint; it is registered together with the profile that defines its use. Note that an MCP server is discovered by proto=mcp with rtype=tool or rtype=agent according to its role, and an LLM API service by proto=openresponses with rtype=service: entity type and protocol vary independently.

7.3. Two-Stage Discovery and Catalog Recursion

Discovery proceeds in two stages, unchanged from [I-D.jakab-dawn-agent-discovery-mdns]: Stage 1 browses and resolves DNS-SD records for enumeration and lightweight selection; Stage 2 retrieves the protocol-native description (AgentCard, MCP manifest, model card, catalog document, ...) from the descriptor reference and proceeds entirely in the entity's own protocol.

For a catalog entity, Stage 2 retrieval yields further entities (MDI instances or references), and the discovering party applies Stage 2 to each selected entry. Recursion SHOULD be bounded (a small default maximum depth, e.g., 3), each hop is subject to the dereferencing protections of Section 10, and cached entries from a catalog are governed by their own Freshness and by the carrier lifetime, whichever expires earlier.

7.4. TXT and SVCB Keys

The common key set of [I-D.blwm-dawn-common-discovery-parameters] is reused unchanged: txtvers (MUST), proto (SHOULD), desc-ref, desc-ref-digest, proto-ver, path, well-known, title (SHOULD), and alpn (SVCB). [I-D.jakab-dawn-agent-discovery-mdns] adds the agent descriptor keys agentId, cardUrl, caps, ver, and protocol-specific keys. This document adds exactly one common key:

rtype:
the Entity Type value (Section 5). SHOULD be present; absence means agent. A consumer MUST ignore an unrecognized rtype value (Constraint 6, Section 4.3). Values are lowercase, digits, and hyphens.

Key names follow the common conventions: lowercase, digits, and hyphens, at most nine characters where possible, so one vocabulary serves both TXT and SVCB encodings. Type- or protocol-specific keys use the registered value as a prefix followed by a hyphen (e.g., a2a- binding pattern), so independently registered profiles cannot collide. Exactly one TXT record is used per service instance, and one service instance is advertised per (entity, protocol) pair; instances of the same logical entity carry the same descriptor reference so a client can tell they belong together.

7.5. Instance Naming

The Entity Identifier is used as the initial candidate for the "Instance" portion of the DNS-SD service instance name, encoded as a single DNS label per [RFC6763], Section 4.1.1, with literal dots and backslashes escaped per Section 4.3 of that document. If the label would exceed 63 octets or cannot be represented, the advertising implementation does not silently truncate; it advertises under an explicitly configured alternate instance name or does not advertise. mDNS conflict resolution of [RFC6762] applies; the TXT identifier key (e.g., agentId) continues to carry the original Entity Identifier after any renaming, exactly as for agents.

7.6. Transition and Coexistence

Deployments and implementations of the earlier, per-type service types (_agent._tcp spellings, _llm-api._tcp) can dual-advertise during transition, as already contemplated for other coexisting agent discovery approaches. New entity types register only rtype values and publish under the single generic service type; no new service type is needed for a new entity type, ever.

8. Deployment Considerations

The deployment considerations of [I-D.jakab-dawn-agent-discovery-mdns], Section 7 apply unchanged: link-local scope of mDNS, separation of discovery from reachability and trust, and compatibility with multicast filtering and local policy. Two additional notes:

9. Extensibility Guidelines

Adding support for a new kind of entity is a three-step procedure; none of the steps touches the core model:

  1. Register the Entity Type value in the "DAWN Entity Types" registry (Section 12.1), with a definition and, when available, a profile reference.

  2. If the type uses protocols not yet registered, register the protocol values (Section 12.3) with their profiles.

  3. Publish the profile (Section 6), specifying value spaces, the native description document, and type-specific keys. Until the profile exists, advertisements carry the core elements only (Section 6.3).

Clients written to this document require no update to enumerate and Stage-1-triage the new type (they ignore the unknown rtype value per Constraint 6 but still parse the instance), and require an update only to interpret the new type's native description in Stage 2. This is the elasticity property: extension is registration plus profile, never core change.

10. Security Considerations

The Security Considerations of [I-D.cui-dawn-mdi-model] and [I-D.jakab-dawn-agent-discovery-mdns] apply unchanged and are not restated. In brief: MDI is advertised, unauthenticated information; any element can be forged; identifiers are names, not identities; digests give integrity of referenced bytes, not trust; trust is established in Stage 2 by the entity protocol's own mechanisms; reference locators are untrusted input and the usual dereferencing protections apply; and implementations MUST NOT draw conclusions from the absence of an element.

Generalization adds no new attack surface beyond enumeration exposure (Section 8): an advertiser forges an rtype value as easily as any other TXT key, and a discovering party MUST NOT treat a recognized entity type as more trustworthy than an unrecognized one. Catalog recursion (Section 7.3) multiplies untrusted dereferences and MUST be bounded and policy-filtered like any other reference following.

11. Privacy Considerations

The Privacy Considerations of [I-D.cui-dawn-mdi-model] apply unchanged: publishing MDI can reveal entity names, endpoints, organizational structure, capability hints, and scope information. Publishers SHOULD minimize public MDI to what discovery requires and place sensitive detail behind access-controlled references. Because one browse now enumerates every entity type, minimization applies across types, not only to agents.

12. IANA Considerations

12.1. DAWN Entity Types Registry

IANA is requested to create the "DAWN Entity Types" registry, with registration procedure "Specification Required" [RFC8126] and values of the lexical form of Section 5. The initial contents are the values defined in Section 5: agent, catalog, service, tool, task, data-source, model, workload, broker, application-endpoint.

12.2. Service Name Registration

This document uses the generic service type _agents._tcp of [I-D.blwm-dawn-common-discovery-parameters]. Should this usage be progressed, registration of the service name agents for TCP in the Service Name and Transport Protocol Port Number Registry [RFC6335] is requested, following the underscored-service-name conventions of [RFC8552], with no fixed port number (the port is conveyed per instance in SRV/SVCB). The relationship between the spellings _agent._tcp [I-D.jakab-dawn-agent-discovery-mdns] and _agents._tcp [I-D.blwm-dawn-common-discovery-parameters] is to be reconciled at registration time; this document makes no independent request. No per-type service names (llm-api, tool, etc.) are requested now or anticipated.

12.3. DAWN Entity Protocols Registry

IANA is requested to create the "DAWN Entity Protocols" registry, with registration procedure "Specification Required". The initial contents are: a2a (Agent2Agent protocol), mcp (Model Context Protocol), openresponses (Open Responses API profile), https (generic HTTPS endpoint). This document defines the common key rtype (Section 7.4).

13. References

13.1. Normative References

[I-D.blwm-dawn-common-discovery-parameters]
Brockners, F., Jakab, L., Williams, N., and J. Mozley, "Common Agent DNS Discovery Parameters", Work in Progress, Internet-Draft, draft-blwm-dawn-common-discovery-parameters, , <https://datatracker.ietf.org/doc/draft-blwm-dawn-common-discovery-parameters/>.
[I-D.cui-dawn-mdi-model]
Cui, Y. and K. Yao, "Minimum Public Discovery Information: Requirements and Common Semantics", Work in Progress, Internet-Draft, draft-cui-dawn-mdi-model, , <https://datatracker.ietf.org/doc/draft-cui-dawn-mdi-model/>.
[I-D.farrel-dawn-terminology]
Farrel, A., Yao, K., Schott, R., and N. Williams, "Terminology for the Discovery of Agents, Workloads, and Named Entities (DAWN)", Work in Progress, Internet-Draft, draft-farrel-dawn-terminology, , <https://datatracker.ietf.org/doc/draft-farrel-dawn-terminology/>.
[I-D.jakab-dawn-agent-discovery-mdns]
Jakab, L., "Agent Discovery Using mDNS", Work in Progress, Internet-Draft, draft-jakab-dawn-agent-discovery-mdns, , <https://datatracker.ietf.org/doc/draft-jakab-dawn-agent-discovery-mdns/>.
[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, , <https://www.rfc-editor.org/rfc/rfc2119>.
[RFC6335]
Cotton, M., Eggert, L., Touch, J., Westerlund, M., and S. Cheshire, "Internet Assigned Numbers Authority (IANA) Procedures for the Management of the Service Name and Transport Protocol Port Number Registry", BCP 165, RFC 6335, , <https://www.rfc-editor.org/rfc/rfc6335>.
[RFC6762]
Cheshire, S. and M. Krochmal, "Multicast DNS", RFC 6762, , <https://www.rfc-editor.org/rfc/rfc6762>.
[RFC6763]
Cheshire, S. and M. Krochmal, "DNS-Based Service Discovery", RFC 6763, , <https://www.rfc-editor.org/rfc/rfc6763>.
[RFC8126]
Cotton, M., Leiba, B., and T. Narten, "Guidelines for Writing an IANA Considerations Section in RFCs", BCP 26, RFC 8126, , <https://www.rfc-editor.org/rfc/rfc8126>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, , <https://www.rfc-editor.org/rfc/rfc8174>.
[RFC8552]
Crocker, D., "Scoped Interpretation of DNS Resource Records through "Underscored" Naming of Attribute Leaves", BCP 222, RFC 8552, , <https://www.rfc-editor.org/rfc/rfc8552>.

13.2. Informative References

[I-D.cui-dawn-local-llm-api-discovery]
Cui, Y., "Discovery of LLM API Services in Local Networks", Work in Progress, Internet-Draft, draft-cui-dawn-local-llm-api-discovery, , <https://datatracker.ietf.org/doc/draft-cui-dawn-local-llm-api-discovery/>.
[I-D.mozleywilliams-dawn-dnsaid]
Mozley, J. and N. Williams, "DNS-Based Agent Discovery (DNSAID)", Work in Progress, Internet-Draft, draft-mozleywilliams-dawn-dnsaid, , <https://datatracker.ietf.org/doc/draft-mozleywilliams-dawn-dnsaid/>.
[RFC3444]
Pras, A. and J. Schoenwaelder, "On the Difference between Information Models and Data Models", RFC 3444, , <https://www.rfc-editor.org/rfc/rfc3444>.

Appendix A. Illustrative JSON Examples

Illustrative only; no encoding is normative. The generalized MDI model is encoding-neutral per [RFC3444]; these examples show one possible JSON binding.

A.1. Named Agent (A2A)

{
  "entity_id": "urn:example:agent:invoice-bot",
  "entity_type": "agent",
  "endpoint": [
    { "locator_type": "uri",
      "locator": "https://example.com/agent",
      "protocols": [ "a2a" ] }
  ],
  "capability_ref": [
    { "ref_type": "uri",
      "locator": "https://example.com/.well-known/agent-card.json" }
  ],
  "freshness": { "valid_until": "2027-03-01T00:00:00Z" }
}

A.2. LLM API Service (Open Responses)

{
  "entity_id": "office-llm",
  "entity_type": "service",
  "entity_summary": [ "Office LLM API (Open Responses)" ],
  "endpoint": [
    { "locator_type": "uri",
      "locator": "https://llm-node.local:8443/v1",
      "protocols": [ "openresponses" ] }
  ],
  "authentication_hint": [
    { "scheme": "bearer", "metadata": "required" }
  ],
  "freshness": { "version": "2026-04-24" }
}

A.3. Catalog (Discovery-Furthering Service)

{
  "entity_id": "lab-catalog",
  "entity_type": "catalog",
  "entity_summary": [ "Lab entity catalog" ],
  "endpoint": [
    { "locator_type": "uri",
      "locator": "https://catalog.example.com/mdi",
      "protocols": [ "https" ] }
  ],
  "capability_ref": [
    { "ref_type": "uri",
      "locator": "https://catalog.example.com/mdi",
      "digest": "sha-256=<base64url digest of the catalog document>" }
  ]
}

The catalog document located by capability_ref is a list whose entries are MDI instances (Section 4.1) or references to them; its own entries need not repeat the catalog's own scope hints.

Appendix B. Mapping Across the Converging Documents

The table sketches how the generalized MDI elements surface in the converging discovery documents. Field names are indicative; full mappings belong to binding documents.

Table 2: MDI Element Mapping Across Documents
MDI element MDI model (cui) jakab (_agent) blwm (_agents) local llm-api
Entity Identifier entity-identifier agentId / cardUrl instance name instance name
Entity Type entity-type (default: agent) rtype (this doc) (fixed: service)
Endpoint locator locator SRV target+port SVCB target+port SRV target
Endpoint protocols protocols proto proto api
Capability Reference capability-reference cardUrl desc-ref (path/base)
Capability Summary capability-summary caps (profile) n/a
Freshness version version ver proto-ver protovers
Authentication Hint auth-hint n/a (profile) auth
Human-readable name entity-summary instance name title instance name

Appendix C. How This Document Absorbs draft-cui-dawn-local-llm-api-discovery

The LLM API discovery draft [I-D.cui-dawn-local-llm-api-discovery] proposes a separate _llm-api._tcp service type. Under this specification, the same capability is achieved as follows:

Table 3: LLM API Draft to This Specification Mapping
LLM API draft This specification
_llm-api._tcp service type _agents._tcp (reused)
api=openresponses proto=openresponses (common key)
protovers=2026-04-24 proto-ver=2026-04-24 (common key)
scheme=https derived from alpn (h2 → https)
base=/v1 path=/v1 (common key)
auth=required auth=required (common key)
(no type) rtype=service (new common key)

No information is lost. The client discovers LLM APIs with the same single browse that finds agents and MCP servers.

Appendix D. Acknowledgements

Thanks to the DAWN WG participants for discussions on entity discovery, and to the authors of [I-D.jakab-dawn-agent-discovery-mdns], [I-D.blwm-dawn-common-discovery-parameters], [I-D.mozleywilliams-dawn-dnsaid], and [I-D.cui-dawn-mdi-model] whose work this document builds upon.

Author's Address

Bin Zhang (editor)
Pengcheng Laboratory
Sibilong Street
Shenzhen
China