| Internet-Draft | DAWN Entity MDI | November 2026 |
| Zhang | Expires 18 May 2027 | [Page] |
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.¶
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.¶
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.¶
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:¶
[I-D.jakab-dawn-agent-discovery-mdns] defines
mDNS/DNS-SD discovery for A2A agents and MCP servers under
_agents._tcp.¶
[I-D.cui-dawn-local-llm-api-discovery] proposes a
separate _llm-api._tcp service type for local LLM API
endpoints, re-implementing the same mDNS/DNS-SD discovery pattern
already defined for agents but with a different service type and
a different set of TXT keys.¶
Future categories (tools, tasks, data sources, models, workloads, brokers, application endpoints) risk each requiring yet another service type and metadata schema.¶
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.¶
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.¶
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:¶
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 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:¶
agent with a stable name, e.g., an A2A
agent advertising an AgentCard.¶
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.¶
This document defines the abstract content of the generalized MDI common header and the framework for extending it. It does NOT define:¶
a discovery, query, resolution, or transport protocol, and it does not bind MDI to DNS or to any other carrier;¶
a wire format, serialization, or schema; representations are illustrative (Appendix A);¶
a new capability card, or a replacement for AgentCard, MCP server manifests, model cards, or any existing descriptor;¶
identity verification, authentication, authorization, policy evaluation, or attestation procedures;¶
capability exchange, negotiation, selection, registration, or invocation semantics.¶
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.¶
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.¶
| 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 |
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.¶
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.¶
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:¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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).¶
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.¶
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.¶
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.¶
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.¶
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:¶
the Entity Type value (or values) it applies to;¶
the protocol values (proto axis) used for that type;¶
the native description document that the Capability Reference (descriptor reference) locates, and how it is retrieved;¶
the value space of capability-summary tags for the type, if a shared tag space is needed;¶
any type- or protocol-specific TXT/SVCB keys, named with a registered prefix.¶
A profile MUST NOT relax the MUST elements or the constraints of Section 4.3.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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: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.¶
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.¶
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.¶
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:¶
Enumeration exposure: because all entity types share one service type, a single browse exposes the presence of every type on the link. Deployments that consider tool, model, or workload presence more sensitive than agent presence SHOULD minimize the advertised hints for those types (small TXT records, no capability tags) and rely on Stage 2 access control; the model supports this because the descriptor reference can require authorization that discovery does not perform.¶
Subtype filtering: clients that care about one
type or protocol browse the corresponding DNS-SD subtype, e.g.,
_openresponses._sub._agents._tcp for LLM API services,
_tool._sub._agents._tcp for tools, without any change to
the core model or to generic clients.¶
Adding support for a new kind of entity is a three-step procedure; none of the steps touches the core model:¶
Register the Entity Type value in the "DAWN Entity Types" registry (Section 12.1), with a definition and, when available, a profile reference.¶
If the type uses protocols not yet registered, register the protocol values (Section 12.3) with their profiles.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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).¶
Illustrative only; no encoding is normative. The generalized MDI model is encoding-neutral per [RFC3444]; these examples show one possible JSON binding.¶
{
"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" }
}
¶
{
"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" }
}
¶
{
"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.¶
The table sketches how the generalized MDI elements surface in the converging discovery documents. Field names are indicative; full mappings belong to binding 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 |
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:¶
| 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.¶
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.¶