| Internet-Draft | OAN Resource Discovery | November 2026 |
| Xu, et al. | Expires 19 May 2027 | [Page] |
This document describes a trust-governed resource identity and discovery architecture for OpenAgenet (OAN). It covers callable agents, skills, Model Context Protocol (MCP) servers, tools, and application programming interfaces. Registrars verify registration authority, a Root accepts versioned resource packages, and authorized Discovery Nodes expose verified candidates. Consumers verify package integrity, acceptance, and current state before using a resource through its native protocol or artifact format.¶
The architecture can be profiled with Decentralized Identifier (DID) document concepts and credential-based assertions. This document does not define a new DID method, media type, URI scheme, transport protocol, ranking algorithm, blockchain protocol, agent invocation protocol, or product-native schema.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 19 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. 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.¶
Open agent ecosystems are moving beyond a single "agent service" abstraction. They can include callable agent services, reusable skills, MCP-compatible servers, ordinary HTTP or RPC tools, and domain-specific APIs. These resources may be implemented by different operators and may be invoked through different protocols. A relying party therefore needs a layer that can answer trust and discovery questions before product-specific interaction begins:¶
What stable resource identity is being advertised?¶
What type of resource is it?¶
Which provider or controller is bound to the resource identity?¶
Which Registrar checked the registration evidence?¶
Which Root authority accepted the versioned package?¶
Which Discovery Node is authorized to expose the resource for the requested domain?¶
Which hashes, proofs, versions, and lifecycle states must be verified before use?¶
OpenAgenet (OAN) is an open architecture for resource identity, governed registration, trusted package publication, authorization-aware discovery, and pre-use verification. OAN is intentionally protocol-neutral at the interaction layer. After OAN checks pass, a consumer can use MCP, A2A, HTTP, RPC, a Skill runtime, or another product-native protocol. OAN does not replace those protocols; it supplies the trust path used to find and approach resources safely.¶
The central abstraction in this document is a discoverable resource, not only an agent. A discoverable resource is a product-shaped subject with a stable resource identifier, resource metadata, versioned package material, and verifiable Root acceptance. The initial resource types are:¶
This resource-first model allows OAN to support common agent ecosystem assets without forcing all of them into one runtime protocol or one artifact format.¶
The model also supports external identifier associations, optional runtime identity bindings, and federation among independently governed trust domains.¶
Closed platforms can combine account identity, approval workflow, search, artifact hosting, ranking, and invocation policy into one administrative system. In an open multi-operator environment, those functions need clearer boundaries. A Discovery result should not be trusted merely because it appears in a catalog. A CDN location should not become a trust anchor. A local ranking score should not override revocation state. A Registrar should not be able to register a resource whose subject key it never verified. A valid old package should not silently remain current after the Root has accepted a newer or revoked state.¶
The architectural gap is the lack of a common trust path that binds:¶
stable resource identity;¶
resource type and semantic metadata;¶
subject-control proof;¶
Registrar-issued registration evidence;¶
Registrar authorization state;¶
Root verification and package acceptance;¶
package, metadata, and identity-document hashes;¶
Discovery authorization scope;¶
signed Discovery response provenance; and¶
pre-use verification by consumers.¶
This document specifies that path at the architectural level.¶
This document defines architectural requirements for OAN roles and trust objects, independently of source code, hosting provider, or storage backend. It covers:¶
architectural roles and their trust boundaries;¶
discoverable resource types and identity expectations;¶
common resource package semantics;¶
Root proof and hash-binding requirements;¶
registration and Root verification behavior;¶
infrastructure authorization and governance-state boundaries;¶
CDN distribution semantics;¶
authorization-aware Discovery behavior;¶
lifecycle, versioning, and consistency expectations;¶
pre-use verification by resource consumers; and¶
security and privacy considerations.¶
Architectural conformance means satisfying the applicable role requirements. Direct wire interoperability additionally requires a shared binding defining object encodings, proof inputs, algorithms, version selection, and message exchange. This document does not specify that complete binding. Its field names and JSON examples illustrate semantic objects rather than a wire schema.¶
A profile constrains architectural choices for a use case; a binding maps those choices to representations and transport. An extension adds a capability. Local policy selects acceptable authorities and assurance requirements, but MUST NOT override mandatory verification. Peers MUST use a mutually supported binding, whether selected by configuration or negotiation, and MUST reject an unsupported required binding rather than guess its semantics.¶
Verifiable objects and role behavior form the interoperability boundary. Operators can vary review policy, ranking, search, and internal processing while retaining common verification semantics. Root authority is scoped to a trust domain; independent domains can federate without a global superior Root. Required extensions need explicit recognition and failure behavior in the selected binding so that unsupported features cannot weaken trust decisions.¶
This document does not define:¶
a new DID method or identifier syntax;¶
a new URI scheme;¶
a new media type;¶
a new transport protocol;¶
a replacement for MCP, A2A, HTTP APIs, RPC, Skill packaging, or other interaction protocols;¶
a ranking, recommendation, reputation, or semantic retrieval algorithm;¶
a business ontology or product marketplace policy;¶
a blockchain protocol or smart contract interface;¶
a Root key-management ceremony;¶
a database schema, repository layout, or implementation language;¶
a requirement to use any particular open-source codebase or hosted service;¶
a user interface or operator review workflow; or¶
a mandatory artifact hosting model for Skill files, API specifications, MCP manifests, executable code, or other product-native payloads.¶
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.¶
A callable business resource, represented as an OAN resource of type
agent_service. It can expose an agent-to-agent endpoint, an HTTP endpoint,
an RPC endpoint, an MCP-related binding, or another product-native
interaction endpoint.¶
A governance-recognized domain used to determine whether a Discovery Node is authorized to expose a resource. Capability domains are distinct from local custom tags and ranking features.¶
A content distribution service that stores and serves Root-published packages, identity documents, metadata, manifests, and related artifacts. A CDN Service is not a protocol trust authority in this architecture.¶
A resource that can be registered, Root-verified, distributed, indexed,
discovered, and verified before use. Initial OAN resource types are
agent_service, skill, mcp_server, and tool_api.¶
An infrastructure service that synchronizes Root-verified resource packages, verifies them, applies authorization-domain filtering, builds local indexes, and returns signed discovery responses.¶
The current authorization lifecycle state of an infrastructure subject, such as a Registrar Node, Discovery Node, or credential issuer. Governance state is separate from ordinary resource package lifecycle state.¶
A resource of type mcp_server that describes an MCP-compatible server and
its OAN-facing identity, endpoint, metadata, and verification material.¶
An infrastructure service that assists resource providers, checks candidate resource material, verifies subject control, issues registration evidence, and submits complete registration packages to the Root Node.¶
A user agent, application, orchestrator, service, or other relying party that queries Discovery and verifies resource material before download, invocation, or other use.¶
The identity-facing document for a discoverable resource. A deployment can express it as a DID Document profile or another verifiable representation that provides equivalent identifier, key, endpoint or artifact-reference, metadata, and verification properties.¶
A versioned Root-verified package that binds a resource identifier, resource type, package version, resource identity document, resource metadata, hashes, lifecycle state, and Root proof.¶
The subject, operator, or organization responsible for preparing and controlling a discoverable resource.¶
The trust anchor role for one OAN trust domain. It verifies Registrar submissions, accepts or rejects resource packages, signs Root proofs, publishes package facts, maintains or consumes infrastructure authorization state, and coordinates downstream distribution. A Root Node is not assumed to be globally unique across all OAN deployments.¶
A resource of type skill that describes a capability. A Skill can refer to
one or more Agent Service, MCP Server, or Tool/API implementations. The
Skill artifact itself can be hosted outside OAN, provided that OAN metadata
includes verifiable references.¶
A resource of type tool_api that describes a callable tool, API, function
gateway, enterprise connector, or similar interface.¶
OAN separates governance, registration, Root acceptance, distribution, Discovery, and product-native use. The high-level relationship is:¶
Resource Provider | prepares resource identity, metadata, package, hashes v Registrar Node | verifies subject control and issues registration evidence | submits signed upstream request v Root Node | verifies Registrar authorization, evidence, hashes, package | signs Root proof and queues publication v CDN Service | distributes Root-published packages and metadata v Discovery Node | verifies packages, enforces authorized domains, signs responses v Resource Consumer | verifies Discovery response and selected package before use v Product-native protocol or artifact retrieval¶
The architecture has several important invariants:¶
Root acceptance is the authoritative resource-package trust event within the applicable trust domain.¶
Registrar review is not sufficient without Root verification.¶
CDN distribution is not a trust decision.¶
Discovery indexing is not a Root lifecycle state.¶
Discovery ranking is not authorization.¶
Product-native invocation or artifact retrieval begins only after OAN verification has succeeded.¶
Within its trust domain, the Root Node is responsible for:¶
verifying Registrar-origin resource submissions;¶
verifying signed upstream envelopes, timestamp freshness, nonce uniqueness, and body-hash binding;¶
verifying registration evidence, issuer authorization, and subject-control binding;¶
verifying resource identity document structure, resource type consistency, package hashes, metadata hashes, and package versions;¶
creating Root proofs over accepted package claims;¶
preserving versioned resource package history;¶
publishing or queuing packages for CDN distribution;¶
notifying or enabling Discovery synchronization;¶
issuing or validating infrastructure authorization credentials when the deployment profile uses them; and¶
enforcing current governance state for infrastructure subjects.¶
The Root Node MUST NOT treat CDN location, Discovery ranking, local search signals, or Registrar policy recommendation as a substitute for Root verification.¶
A Registrar Node is the onboarding and submission gateway for resources. It is responsible for:¶
assisting resource providers with draft resource identity documents and metadata;¶
validating resource type, resource identifier, metadata, package version, hashes, and hash algorithm fields;¶
verifying subject authority and required external-controller authorization;¶
issuing registration evidence after successful policy review and subject-control verification;¶
preserving local evidence for audit and resubmission; and¶
submitting complete resource packages to the Root Node with a signed upstream envelope.¶
A Registrar Node MUST NOT issue authoritative registration evidence for a resource subject unless the subject-control proof or an equivalent verified binding has succeeded. A Registrar Node MUST fail closed for Root-facing authoritative submission when its own infrastructure authorization credential or current governance state is missing, stale beyond policy, suspended, revoked, expired, or unknown.¶
A Discovery Node is responsible for:¶
synchronizing Root-verified resource packages from approved distribution locations;¶
verifying Root proofs, package hashes, metadata hashes, identity-document hashes, and lifecycle state;¶
enforcing its authorized capability domains;¶
maintaining accepted and rejected package state;¶
building local indexes over accepted packages; and¶
returning signed Discovery responses.¶
Discovery Nodes MAY use local ranking, semantic matching, reputation, or operator policy after package verification and authorization filtering. These local signals MUST NOT cause a resource to be exposed outside the Discovery Node's authorized domains, override Root revocation state, or hide verification failures.¶
The CDN Service is a distribution layer. It stores and serves Root-published resource packages, identity documents, metadata, manifests, and related artifacts. The CDN Service is not an OAN trust authority, is not necessarily a chain-governed infrastructure subject, and does not decide whether a resource is accepted.¶
Relying parties MUST verify Root proofs and package hashes after fetching content from a CDN Service. A manifest entry, storage location, URL, or CDN identity MUST NOT be treated as sufficient proof of resource trust.¶
A Resource Provider prepares the resource identity document, metadata, endpoint descriptors, artifact references, package version, and hash material. The provider supplies evidence of applicable subject or controller authority and maintains product-native endpoints or artifacts. OAN does not require Discovery Nodes or CDN Services to host provider-native Skill files, OpenAPI specifications, MCP manifests, executables, or other external payloads.¶
A Resource Consumer queries Discovery and verifies selected candidates before use. It is responsible for checking the Discovery response signature, Root proofs, hashes, lifecycle state, endpoint or artifact-reference binding, resource type consistency, and any product-specific credential requirements. After these checks pass, the consumer can use the relevant product-native protocol or retrieve the referenced artifact.¶
A resource subject, its controller, its metadata publisher, its service operator, and its credential issuer can be different parties. A controller is authorized to manage the resource identity within the selected profile; that relationship does not automatically grant business invocation rights or permission to sign all runtime messages as the resource. A resource can use its own operational verification material even when externally controlled.¶
For DID-based resources, DID Core [DID-CORE] defines controller and
verification-relationship concepts, while the selected DID method defines
authorization for create, update, and deactivate operations. Merely adding a
controller value to a proposed document does not establish authority over the
previously accepted state. A DID Document need not carry an embedded signature;
its authenticity can be established by method-specific resolution and evidence.
An OAN Root proof binds package acceptance and does not replace those method rules.
These OAN authorization requirements are not a claim that DID Core mandates
one universal document-update signature format or controller-transfer protocol.¶
For a self-controlled resource, the applicant proves the applicable subject authority. For an externally controlled resource, the Registrar and Root MUST verify the controller's authority and a scoped authorization for the submitted resource and operation. That authorization MUST bind the resource identifier, submitted content or digest, purpose, intended accepting authority, and validity conditions, with replay protection. Resource-key possession alone MUST NOT replace required external-controller authorization.¶
A profile permitting delegation MUST define allowed scope, further delegation, path validation, cycle detection, and bounded chain processing. A controller reference alone is not a validated delegation chain. These requirements do not mandate arbitrary-depth delegation or one operational key-management product.¶
For example, an accepted issuer can attest to enterprise E's association with controller C, while C authorizes resource R and R authorizes a subordinate resource S. A relying party tracing S to E validates each applicable control relationship and the identity attestation, including scope and current status. The attestation about E does not certify every capability of R or S. Missing evidence supports no verified-enterprise conclusion; it does not establish that the represented provider is necessarily illegitimate.¶
An OAN resource identity model separates stable identity, package version, protocol version, and endpoint or artifact version.¶
The stable resource identifier identifies the resource subject. It SHOULD NOT encode a package version, endpoint version, protocol version, cryptographic algorithm, mutable URL, or mutable descriptive metadata.¶
The package version identifies a Root-verified release of resource identity and metadata. A resource can publish multiple package versions under the same stable resource identifier. A new resource identifier SHOULD be used when the controller boundary, trust boundary, or core product semantics change enough that treating the change as a new package version would mislead relying parties.¶
The protocol or interface version identifies a product-native interface such as an MCP version, HTTP API version, A2A profile, Skill format version, schema version, or endpoint contract version. OAN can record these versions as metadata, but it does not define their native semantics.¶
An OAN deployment that implements this document SHOULD support the following initial resource types:¶
| Resource Type | Product Form | Typical OAN Material |
|---|---|---|
agent_service
|
Callable agent service | endpoint, supported protocols, capabilities |
skill
|
Capability description or package | artifact URI, digest, semantics, implementations |
mcp_server
|
MCP-compatible server | endpoint, transport, protocol hints, tools summary |
tool_api
|
Tool or API | endpoint or schema reference, auth mode, policy |
Resource-type-specific data SHOULD be represented in typed extension fields or profile-specific objects rather than by creating unrelated package formats.¶
When a deployment uses a DID-based identifier profile, the resource identity document SHOULD make the product form explicit in its OAN metadata. A deployment MAY use subject-code conventions, method-specific syntax, or another profile mechanism to distinguish resource types. When such a mechanism is used, the following values MUST be mutually consistent:¶
the public resource identifier;¶
the resource type declared in the registration submission;¶
the resource type declared in OAN metadata; and¶
the resource type bound by the Root proof.¶
Registrars, Root Nodes, Discovery Nodes, and consumers MUST reject or quarantine resource packages where the resource identifier profile and declared resource type conflict, unless a future OAN profile explicitly defines an alias or migration rule.¶
A Resource Identity Document SHOULD contain or reference:¶
the stable resource identifier;¶
verification methods and verification relationships needed by the profile;¶
controller or provider information;¶
resource type and product-form metadata;¶
semantic metadata used for discovery;¶
capability tags or capability domains;¶
endpoint descriptors for service resources;¶
artifact references for resource types that use external artifacts;¶
credential references or registration evidence references;¶
package version information;¶
lifecycle-state information or references; and¶
extension fields, with clear criticality semantics where supported.¶
The document MUST NOT be trusted merely because it resolves or parses. It is trusted only when it is bound to a verified package, Root proof, and acceptable current lifecycle state.¶
Capability metadata has two components:¶
governance-recognized capability domains; and¶
custom tags, local labels, search hints, embeddings, examples, or other descriptive fields.¶
Only governance-recognized capability domains can expand Discovery authorization scope. Custom tags MAY refine local search after authorization has succeeded, but they MUST NOT cause a Discovery Node to expose a resource outside its authorized domains.¶
Unknown non-critical extension fields MAY be ignored. Unknown critical fields MUST cause rejection by a verifier that does not understand them.¶
A resource MAY retain identifiers assigned by external platforms, enterprise directories, industrial identification systems, or other identifier schemes. An association MUST identify the native value, namespace or issuance scope, relationship being asserted, and declaring party, and MUST be bound to the applicable resource revision. A resolver location MAY be provided separately; it is neither the identifier's ownership proof nor necessarily its authority. Local identifier strings need not be rewritten as DIDs or absolute URIs.¶
Root acceptance protects the association as submitted metadata; it does not necessarily establish that the external association is true. Control, equivalence, membership, and descriptive reference are different relationships. Equal names, URLs, or alias declarations MUST NOT alone establish control or identifier equivalence. DID-specific equivalence properties, when used, retain their applicable method and data-model semantics in DID Core [DID-CORE].¶
Associations need not be one-to-one. Profiles MUST define their update and withdrawal semantics, including external reassignment or reuse. An old valid signature does not indefinitely establish current external ownership.¶
Some resources, especially skill, can reference external artifacts. Examples
include Skill files, MCP manifests, OpenAPI descriptions, source archives,
schemas, or executable packages. OAN does not require these artifacts to be
hosted by a Discovery Node or CDN Service.¶
An external artifact reference SHOULD include:¶
URI;¶
media type or profile identifier;¶
expected version;¶
digest algorithm;¶
digest value;¶
retrieval policy where applicable; and¶
the identity or package claims that bind the artifact to the resource.¶
The Root proof can make the reference and digest trustworthy as accepted metadata. It does not make the remote artifact host trustworthy. Consumers MUST verify the artifact digest after retrieval when the artifact is used for a trust-sensitive purpose.¶
The ResourcePackage is the common Root-verified registry object. It binds a resource identity document, normalized metadata, version information, hashes, lifecycle state, and Root proof.¶
A ResourcePackage SHOULD include:¶
resourceDid or an equivalent stable resource identifier;¶
resourceType;¶
packageVersion;¶
the resource identity document or a verifiable reference to it;¶
resource metadata;¶
didDocumentHash;¶
metadataHash;¶
packageHash;¶
hashAlgorithm;¶
lifecycle state;¶
Registrar identity and registration evidence reference;¶
Root proof claims;¶
publication cursor or sequence where applicable; and¶
endpoint or artifact-reference metadata needed for verification.¶
The Root proof over an accepted package MUST bind at least:¶
stable resource identifier;¶
resource type;¶
package version;¶
identity-document hash;¶
metadata hash;¶
package hash;¶
hash algorithm identifier; and¶
lifecycle state at the time of acceptance or publication.¶
The proof MUST also bind any critical extension fields affecting verification. It SHOULD bind Registrar identity, registration evidence reference, and the publication cursor when those values form part of the acceptance claim.¶
OAN relies on hash binding. A binding MUST define exact input bytes for each digest or signature. It can preserve an original byte representation or select a deterministic canonicalization; canonicalization is not required for arbitrary opaque artifact bytes. Objects whose signed or hashed representation needs such a definition include:¶
resource identity documents;¶
normalized resource metadata;¶
registration evidence;¶
signed upstream envelopes;¶
ResourcePackage payloads;¶
Root proof claims;¶
Discovery response payloads; and¶
trusted invocation or access envelopes, when used.¶
Hashes MUST identify their algorithm. A bare digest value without an algorithm identifier is insufficient for interoperable verification.¶
Profiles MUST define the exact input for each digest and signature: raw bytes or a specified canonical object; character and value encoding; duplicate-key handling; unknown signed fields; and inclusion or exclusion of proofs and self-referencing digest fields. A package digest cannot recursively include its own final value. Mutable distribution fields MUST NOT be implicitly added to an immutable signed claim. Equivalent digest encodings, if accepted, MUST be explicitly defined and MUST NOT conflate different algorithms.¶
Verification MUST compare signed claims with the actual outer object, not just validate a signature mathematically. Profiles SHOULD supply cross-language vectors covering unknown fields, field ordering, altered identities, algorithm substitution, conflicting content at one revision, and transformed displays. Different proof suites MUST be selected by explicit profile rules rather than unauthorized trial-and-error fallback.¶
Package-version lifecycle is distinct from resource-identifier lifecycle. A package version can be superseded, suspended, expired, or revoked while the stable resource identifier remains active. If the resource identity itself is deactivated, the resource subject is inactive even if older package files are still reachable from caches.¶
Discovery Nodes SHOULD return the latest active package version by default. When a Discovery Node returns a historical version, the response MUST indicate the exact version, package hash, metadata hash, Root proof reference, lifecycle state, and whether the version is recommended for new use.¶
OAN separates governance review, credential issuance, subject-control proof, runtime verification, and resource package lifecycle.¶
Operator review, legal review, organizational checks, contact validation, or manual approval can be useful before a Registrar, Discovery Node, credential issuer, or ordinary resource is admitted. These processes are policy decisions. They are not protocol proofs by themselves.¶
Email addresses, phone numbers, SMS codes, web account login, and similar account-centric factors MAY be used in private review workflows. They MUST NOT be required as OAN protocol trust primitives for cross-network interoperability.¶
After review and cryptographic checks succeed, an authorized issuer can issue a credential or credential-like assertion. A registration credential binds the issuer, subject resource identifier, credential type, claims, issuance time, expiration time if present, and proof.¶
The credential is the protocol-facing result of review. It does not replace Root acceptance, package verification, or current lifecycle-state checks.¶
Subject-control proof binds the applicant's authority to the resource and submitted content. For self-controlled resources it proves resource-key authority; for externally controlled resources it includes controller authorization as specified in the identity model. The proof SHOULD be challenge-response based and bind:¶
challenge identifier;¶
resource identifier;¶
Registrar identifier;¶
identity-document hash or equivalent stable representation hash;¶
proof purpose;¶
verification method;¶
nonce;¶
issuance time; and¶
expiration time.¶
The Registrar MUST verify subject-control proof before issuing authoritative registration evidence. Root verification MUST ensure that registration evidence remains bound to the subject-control process and target resource identifier.¶
A Registrar or another accepted issuer MAY attest to organization identity, platform-account control, qualifications, or an external identifier association. The evidence MUST identify its subject, claim, issuer, applicable scope, validity conditions, and status mechanism when required. A registration credential MUST NOT be interpreted as real-world identity verification unless its actual claims and accepted issuance policy establish that fact.¶
Issuer acceptance is scoped: authorization to attest one fact does not authorize every external claim. External credential verification does not replace controller authorization, Root acceptance, or target-side business permission. A resource manager is responsible under the applicable policy for accurate registered descriptions and timely material updates; traceability alone does not guarantee runtime conformance or define legal liability.¶
Third-party collected records MAY describe external services, with the collector identified as the source. The collector's control covers its description record, not the external service. Such records MUST NOT be labeled provider-authorized without corresponding evidence or replace a provider-authorized record solely because both refer to the same URL or external identifier. Source relationships remain explicit when records are linked or deduplicated.¶
Under an enterprise-verified admission policy, a Registrar checks the entity behind a controller and issues claims identifying that review and its policy. Root verifies the accepted issuer's authority and the binding of those claims; it need not repeat the underlying enterprise investigation. Minimal public claims or restricted evidence references can support this process without publishing identity documents or personal review records.¶
Optional evidence can bind an artifact digest, build provenance, deployment instance, model measurement, or capability inventory to a resource revision. The binding MUST identify the claim type, subject, evidence producer, covered object or measurement scope, and applicable validity conditions. A declared fingerprint or evidence URL alone is not a successful verification result. Consumers evaluate the evidence under their accepted verification policy; Root acceptance of the reference does not certify the running implementation.¶
A capability-inventory binding can compare a live tool or operation list with an accepted baseline. It MUST define covered fields, completeness, ordering, canonicalization and digest algorithm, baseline revision, and how the live observation is authenticated and scoped. An MCP tool list is one possible inventory, not a required OAN object. Differences require a new accepted baseline or explicit mismatch handling before relying on the affected claim. A matching digest establishes consistency only for the covered observation; it proves neither tool safety nor that execution remains unchanged afterward.¶
Infrastructure subjects, such as Registrar Nodes, Discovery Nodes, and future third-party credential issuers, can have lifecycle state governed by a bulletin, committee process, on-chain event source, or another deployment-specific governance mechanism.¶
This infrastructure governance state is separate from ordinary resource package state. It governs whether an infrastructure subject is active, suspended, revoked, expired, unknown, or otherwise inactive. It does not by itself create a resource package, validate a DID Document, host an artifact, or make a Discovery result trustworthy.¶
Where an OAN deployment uses Root-issued infrastructure authorization credentials, effective infrastructure authorization is the conjunction of:¶
a valid Root-issued authorization credential for the infrastructure subject; and¶
latest governance-derived state showing that the same subject and role are active within the applicable scope.¶
If either condition is missing, stale beyond policy, suspended, revoked, expired, or unknown, infrastructure peers MUST fail closed for trust-sensitive operations.¶
The two conditions MUST refer to the same subject, role, trust domain, and applicable scope. Combining unrelated credentials and governance facts does not establish authorization. Source state time or coverage MUST be distinct from local retrieval time; rereading an old projection cannot make it current.¶
Governance facts, protocol authorization credentials, resource acceptance, distribution, discovery, and business execution have different responsibilities. A governance event can establish infrastructure status; it does not establish a resource document's correctness or authorize a particular business action. An indexer or state projection relays source facts and MUST NOT independently expand their scope. A credential remains insufficient when applicable current governance state has become inactive.¶
Governance evidence MUST identify its authority, revision or checkpoint scope, and validity conditions. A verifier MUST distinguish native source proofs, assertions by an accepted state attester, and unproved index responses. The selected governance binding defines their encoding, freshness limits, and failure behavior, including any additional attester the verifier trusts. Lightweight clients can use scoped state assertions under that trust model.¶
An OAN deployment MAY publish infrastructure lifecycle outcomes through blockchain events. Infrastructure peers combine these facts with applicable authorization credentials as described above. Resource packages, credentials, artifacts, and business payloads remain separate service-side objects; ordinary consumers need not subscribe to the ledger.¶
An on-chain profile MUST define when relevant facts become effective and how non-final or rolled-back state is handled. Finality does not remove projection delay or cache staleness. This document specifies no confirmation count, consensus algorithm, contract ABI, wallet, or indexer implementation. Ordinary resource registration, discovery, and invocation do not require individual ledger transactions. An optional ledger commitment proves inclusion of the committed object, not its current validity or business truth.¶
A governance bulletin can publish infrastructure authorization outcomes, package publication events, or other deployment-specific facts. A profile MAY implement the bulletin as an append-only signed log, an on-chain event stream, a committee-approved record, or a combination of these mechanisms.¶
The bulletin MUST NOT be assumed to store complete resource identity documents, full credentials, private credential material, resource packages, external artifacts, or product-native payloads unless a future profile explicitly defines such storage. In the architecture described here, resource package trust remains based on Root verification, Root proof, hashes, package state, and Discovery verification.¶
A trust domain is the scope within which specified authorities and assertion policies apply. It need not coincide with one operator or administrative boundary.¶
One logical Root can have multiple service instances without creating multiple independent authorities. Independent Roots instead govern separate trust domains and MAY federate under explicit acceptance policies. This architecture does not require a global superior Root or a particular replication protocol. Hierarchical, scope-limited delegation is possible but is not the mandatory topology.¶
Root proofs, current-state evidence, and infrastructure authorization MUST be attributable to their applicable trust domain and authority. Even a globally unique resource identifier can have distinct acceptance records in different domains. Root endpoints and identifier routing hints locate services; they MUST NOT independently establish trust anchors.¶
A relying party MUST explicitly determine which remote authority it accepts, for which assertion types, roles, scopes, and validity conditions. Acceptance need not be symmetric and MUST NOT be assumed transitive. Acceptance of organization attestations does not grant acceptance of infrastructure delegation. A multi-homed Registrar or Discovery Node MUST keep the authorization scope of each domain distinct; permission granted in one domain does not expand another.¶
Direct validation of a remote Root's package and local reacceptance of remote material are different paths. Local reacceptance MUST identify the local authority and retained source evidence, and MUST NOT masquerade as the remote Root's original assertion or erase source restrictions. A new local assertion does not by itself renew an external credential's validity.¶
Versions and current-state revisions are compared within their defined authority scope. Different Roots' revision numbers or receipt times are not a global order. Conflicting packages, controllers, or lifecycle states MUST NOT be silently merged because signatures verify. Without an agreed coordinating authority or migration rule, a relying party MUST retain the conflict and apply an explicit selection or rejection policy.¶
Federation profiles MUST define the effects of source revocation, withdrawal of inter-domain acceptance, and local policy changes on new assertions and cached evidence. Historical authenticity remains distinct from current acceptability. This document does not require a globally synchronized registry, cross-chain bridge, cross-Root transaction consensus, or online Root traversal for every business invocation.¶
The standard OAN registration flow is:¶
The Resource Provider prepares a resource identity document, metadata, package version, hashes, endpoint descriptors, or artifact references.¶
The Registrar validates resource type, resource identifier consistency, identity-document shape, metadata, hashes, and hash algorithm fields.¶
The applicant proves subject authority and, for externally controlled resources, supplies the controller authorization defined in the identity model.¶
The Registrar applies local policy and issues registration evidence.¶
The Registrar creates a complete registration submission.¶
The Registrar signs an upstream request envelope and submits it to Root.¶
Root verifies infrastructure authorization, request integrity, freshness, replay protection, registration evidence, subject-control binding, hashes, and package semantics.¶
Root accepts or rejects the package.¶
On acceptance, Root archives the version, creates a Root proof, and queues package publication and Discovery synchronization.¶
Create and update operations SHOULD use a complete-document path. Root SHOULD verify a complete new resource identity representation rather than applying ambiguous partial patches.¶
Registrar-to-Root submissions and other trusted upstream writes MUST use an authenticated, integrity-protected envelope. Its signed content MUST bind:¶
request identifier;¶
protocol version or profile identifier;¶
request purpose;¶
HTTP method or equivalent operation;¶
path or target operation name;¶
audience identifier;¶
signer identifier;¶
timestamp;¶
nonce;¶
body hash;¶
canonicalization or byte-representation rule.¶
The envelope carries a proof over those inputs. The proof's final signature value is excluded from its own signature input; the selected proof suite defines how proof options and algorithm identifiers are authenticated.¶
Receivers MUST verify the sender's authorization state, proof validity, body hash, timestamp freshness, nonce uniqueness, audience binding, and expected operation before processing the body.¶
For an existing resource, update authority MUST be evaluated against the previously accepted control state. Validating only the proposed document's self-declared keys or controller is insufficient. A transfer from controller A to B requires A's authorization under that prior state, unless an explicitly authorized recovery procedure applies. B's acceptance MAY also be required but cannot substitute for A's authorization.¶
Receivers MUST distinguish ordinary updates, key rotation, controller transfer, and recovery. Recovery MUST have a defined authority and verifiable provenance; it MUST NOT permit any Registrar to reset a resource using an unrelated new self-signature. Concurrent updates MUST be checked against an expected prior revision or equivalent state condition within the acceptance decision, so that conflicting transfers cannot both succeed from one old state.¶
For example, when R is controlled by A, A authorizes the revision assigning control to B. Root evaluates that request against the accepted A-controlled revision. Only after acceptance does B authorize subsequent updates.¶
Root verification MUST be deterministic and auditable. At a minimum, Root MUST verify:¶
the Registrar is currently authorized for the requested operation;¶
the upstream envelope signature is valid;¶
the request timestamp is fresh according to policy;¶
the nonce has not been replayed within the replay window;¶
the body hash matches the received body;¶
the resource identifier syntax or profile is valid;¶
the identity document is bound to the submitted resource identifier;¶
the declared resource type is consistent across submitted objects;¶
the identity-document hash matches the submitted identity document;¶
the metadata hash matches normalized metadata;¶
the package hash and hash algorithm are valid;¶
registration evidence is issued by an authorized Registrar;¶
registration evidence is bound to the target resource identifier;¶
subject-control proof or an equivalent verified binding is present; and¶
the requested lifecycle transition is valid.¶
Root MUST reject a submission if a required verification step fails. Silent partial acceptance is unsafe because downstream consumers can treat Root acceptance as evidence that the complete trust path succeeded.¶
Verification can be optimized within a trust boundary, but an upstream boolean report cannot replace required checks across that boundary. If a profile permits an accepted attestation to discharge a check, it MUST specify the attester's authority, exact object binding, check scope, and validity. Reused results MUST remain bound to unchanged material and applicable policy; time-sensitive governance or lifecycle conclusions need the current checks required by policy.¶
Within the replay scope defined by a profile, concurrent use of the same valid nonce MUST NOT admit the message more than once. Cleanup, restart, or state migration MUST NOT reopen a still-valid replay window. Persistent state or an equivalent mechanism invalidating old messages MAY provide this property. Scope and retention MUST account for the authenticated context and permitted clock tolerance. Replay protection unavailable for a protected write MUST cause explicit failure rather than bypass.¶
Consuming a nonce does not prove that registration completed. A new envelope for the same logical submission differs from replaying an old signed message. The registration binding MUST provide an idempotency or conditional-submission contract binding a logical operation to its content and authority scope. Reuse of that identity with different content MUST conflict. A lost response SHOULD be recoverable by correlating the accepted result rather than creating a new resource or revision blindly. No database or internal receipt format is mandated.¶
On successful verification, Root SHOULD:¶
archive the accepted identity document and metadata;¶
assign or confirm the package version;¶
create Root proof claims over required package fields;¶
create or update the latest-version index;¶
record publication state or cursor information;¶
queue CDN publication or equivalent distribution; and¶
make Discovery synchronization possible.¶
A successful Root response indicates Root acceptance of a specific package version. It does not prove product quality, endpoint liveness, ranking value, or suitability for a particular task.¶
The acceptance result MUST bind the resource, trust domain, submitted content, accepted revision or digest, and achieved stage. Reliably confirmed acceptance MUST survive a process failure with recoverable package state and publication intent, or an equivalent reconstruction path. It does not imply immediate visibility at every Discovery Node. When the submission outcome is unknown, clients SHOULD reconcile existing acceptance before retrying a state change.¶
Root MUST distinguish repeat delivery of identical content from conflicting content at the same revision. The registration binding defines comparable revisions within an authority; timestamps alone need not provide that ordering.¶
OAN distribution has two layers:¶
Root-to-Discovery distribution of Root-verified package material; and¶
provider-to-consumer distribution of product-native external artifacts.¶
The CDN Service belongs to the Root-to-Discovery distribution path. It can serve ResourcePackages, identity documents, metadata, manifests, and package indexes. It does not make bytes trustworthy.¶
Provider-to-consumer artifact distribution remains outside the OAN core. A Skill file, MCP manifest, OpenAPI document, source archive, executable, or other artifact can be hosted by the provider, a repository, object storage, an institutional website, or another distribution service. OAN verifies the reference, digest, package binding, publisher identity, and Root proof; it does not require OAN infrastructure to host the artifact.¶
Discovery Nodes and consumers MUST verify fetched package material before using it. Verification includes Root proof, package hash, metadata hash, identity-document hash, resource type, lifecycle state, and applicable bulletin or publication facts.¶
Before treating a discovered resource as trusted for downloading, invocation, composition, or other use, a Resource Consumer MUST perform the applicable checks below. Profiles MUST identify which conditional checks apply and MUST NOT omit checks needed for the claimed assurance:¶
Discovery response signature and freshness;¶
Discovery Node authorization, where required by the profile;¶
selected candidate identifier and resource type;¶
ResourcePackage Root proof;¶
identity-document hash;¶
metadata hash;¶
package hash and hash algorithm;¶
package version and lifecycle state;¶
endpoint descriptor or artifact-reference binding;¶
external artifact digest after retrieval, when an artifact is used;¶
credential requirements and issuer authorization where applicable;¶
resource identifier and resource type consistency; and¶
timestamp, nonce, audience, target, and body-hash binding for signed access or invocation envelopes.¶
For service resources, a client MUST complete applicable verification before invocation. For Skill resources, it MUST verify the referenced file or manifest before using it to resolve or invoke implementation resources.¶
OAN verification is a pre-use guard. After it succeeds, control moves to the product-native protocol or artifact format. Product-native behavior remains outside this document.¶
The object used MUST be the object verified. Consumers MUST retain the selected identity, revision or digest, endpoint or artifact binding, and applicable security profile through actual use. Resolving a different package, changing routes, or following a redirect cannot silently inherit the first object's verification result. Artifact digests cover the retrieved bytes, not merely the URL or a server-supplied digest. This reduces substitution risk; it does not prove that remote runtime code permanently matches its description.¶
Embedded middleware, colocated enforcement, and delegated gateways can apply identity evidence at native protocol boundaries. A directory-only or one-sided integration MUST NOT claim mutual authentication of actual business exchanges.¶
For protected exchanges, the selected binding MUST require verification and local authorization before execution, response verification before trusted consumption, and protection against bypass of an external enforcement boundary. It MUST distinguish original-subject forwarding from delegated proxy signing, and define canonical native inputs, target and operation binding, correlation, replay, errors, and covered asynchronous operations. Controller authority and gateway channel authentication do not substitute for resource-message identity or task access control. Native TLS and authorization remain in force.¶
Timeout does not prove non-execution. A fresh nonce does not make repetition of a side-effecting operation safe; retry needs known non-delivery or a defined idempotency contract. Otherwise outcomes require reconciliation. For streams authenticated only by terminal proof, prior chunks remain provisional and MUST NOT cause actions requiring authenticated input before successful verification. Interruption without a valid completion proof is not authenticated completion. Per-event authenticated delivery is a separate optional security binding.¶
OAN uses multiple lifecycle scopes. Implementations MUST keep them distinct.¶
Registrar draft state is local onboarding workflow state. Example states can include draft, challenged, control-verified, credentialed, submitted, accepted, or rejected. Draft existence MUST NOT imply Root acceptance or Discovery visibility.¶
Resource package state is Root-governed version state. Example states include accepted, published, active, superseded, suspended, expired, and revoked. These states apply to a versioned package, not necessarily to every historical package or to every local Discovery index row.¶
Root MUST avoid ambiguous current-version state for the same resource identifier. Discovery Nodes SHOULD suppress revoked, suspended, expired, or otherwise inactive package versions from default trusted query results.¶
Historical package integrity, current revision, and permission for current use are separate checks. Authoritative current-state evidence binds the issuing authority and trust domain, resource identifier, state revision, applicable package digest or revision, lifecycle state, and validity conditions. A profile selects its representation, such as an online status response, signed short-lived statement, or status-list mechanism.¶
For a signed current-state statement, those conditions include observation or effective time, issuance time, and expiry. The verifier MUST check the issuer's authority for current-state assertions and enforce expiry and its maximum acceptable observation age. A freshly signed Discovery response carrying an old statement does not reset that age. The selected binding defines clock tolerance and any propagation bounds; expiry alone does not provide instantaneous revocation. This architecture specifies no universal expiry duration or revocation deadline.¶
A remembered highest verified state can detect rollback, but first-time clients also need a trusted freshness basis; local cache history cannot solve their initial old-state replay. A recent HTTP response or locally pinned historical Root snapshot alone does not establish live revocation or governance status. Reindexing MUST NOT extend source validity. Key revocation, credential status, resource deactivation, and individual package suspension remain distinct events.¶
Profiles MAY authorize a separate governance path to suspend or revoke one resource or revision without requiring its controller to cooperate. Such a path MUST identify the acting authority, scope, target, state revision, proof, and any restoration rules. It MUST NOT be inferred from arbitrary operator access or from the mere ability to issue registration credentials. Governance process and appeals are outside this document. Resource action is distinct from revoking all historical packages associated with a Registrar.¶
An admitting Registrar can receive reports and retain evidence for review or escalation. A report is an allegation, not an authoritative status change. Only a designated status authority can issue the verifiable suspension or revocation decision. A Discovery operator's local suppression remains a local policy action unless that operator is separately authorized to change resource state. Status distribution and consumer checks convey the resulting decision; reporting channels and review procedures remain operational policy.¶
Discovery index state is local to a Discovery Node. Example states include fetched, accepted, indexed, rejected, quarantined, or stale. These states describe Discovery-local processing outcomes. They do not modify Root package lifecycle state.¶
Root acceptance, CDN publication, Discovery synchronization, and query visibility can be asynchronous. A newly accepted package may not be immediately queryable. This is acceptable if implementations expose enough state for operators and consumers to distinguish publication delay, verification failure, authorization-domain filtering, and query mismatch.¶
Discovery MUST NOT compensate for staleness by accepting unverifiable packages. If synchronization is stale beyond policy, Discovery SHOULD fail closed for trust-sensitive results or clearly mark the response freshness state.¶
Marking stale evidence is not permission to claim a mandatory current-state check passed. Newer inactive state MUST take precedence over a reachable old active package, including while replacement material is still being distributed. Root acceptance, CDN recoverable availability, receiver verification, and query readiness SHOULD be independently distinguishable; one slow receiver need not block all other receivers. No fixed delivery deadline is implied.¶
Concurrent registration in multiple domains, migration between domains, and key rotation of one logical Root are different operations. Migration requires authorization by the resource's currently valid controller or a defined recovery authority, independent admission by the destination, and explicit source/target record relationships and cutover conditions. Changing a Root URL alone does not transfer authority or reconcile conflicting state.¶
Identifier preservation depends on the selected identifier method's routing and authority rules; this architecture does not promise unchanged identifiers for every scheme. When a new identifier is necessary, continuity requires authorized association evidence, not name matching. Profiles MUST address an unavailable or compromised source domain without silently bypassing prior control; a source-root migration acknowledgement is not inherently required for every independent registration in another domain. Migration does not automatically transfer business privileges or erase historical authenticity. Detailed cross-domain transaction and recovery messages belong in migration profiles.¶
OAN is an identity, registration, package, and discovery trust layer. It can be used before or around product-native protocols.¶
OAN can discover and verify an mcp_server resource, then allow an MCP
client to connect using MCP semantics. OAN does not define MCP tool
behavior.¶
OAN can discover and verify an agent_service resource and provide identity
and package evidence before the agent interaction protocol begins. OAN does
not define the full task conversation.¶
OAN can discover and verify a tool_api resource, endpoint descriptor, and
schema or artifact reference. The API's business semantics remain native to
that API.¶
OAN can discover and verify a skill resource and its external artifact
reference. Skill package format, execution, and composition semantics remain
outside the OAN core.¶
The following lists summarize the semantic content of registration and discovery objects. Bindings define concrete schemas and can convey content directly or through verifiable references. These summaries do not relax the proof, authorization, and verification requirements defined above.¶
A registration submission SHOULD contain:¶
Registrar identifier;¶
resource identifier;¶
resource type;¶
complete resource identity document;¶
normalized metadata;¶
package version;¶
identity-document hash;¶
metadata hash;¶
package hash;¶
hash algorithm;¶
registration evidence;¶
subject-control proof or equivalent binding; and¶
signed upstream envelope.¶
Registration evidence SHOULD contain:¶
A Discovery candidate SHOULD contain:¶
Precise errors improve interoperability and operations. Implementations SHOULD distinguish at least the following categories:¶
| Category | Example | Expected Behavior |
|---|---|---|
| syntax | malformed object | reject before trust checks |
| crypto | bad signature | reject and audit signer |
| authorization | inactive Registrar | reject as unauthorized |
| freshness | stale timestamp | reject as expired |
| replay | repeated nonce | reject and audit |
| binding | wrong resource identifier | reject as mismatch |
| hash | metadata hash mismatch | reject or quarantine |
| scope | out-of-domain package | do not index |
| state | revoked package | suppress from trusted results |
| artifact | digest mismatch | do not use artifact |
External error messages MAY avoid exposing sensitive operator details, but internal logs SHOULD preserve enough information for audit and debugging.¶
The threat analysis uses the general guidance in [RFC3552].¶
A Registrar can attempt to register resources without verifying subject control or after losing authorization. Root MUST verify Registrar authorization, signed upstream envelopes, freshness, replay protection, registration evidence, and subject-control binding.¶
An applicant can try to register a resource identifier controlled by another party. Registrars MUST verify subject-control proof before issuing authoritative registration evidence, and Root MUST verify that the evidence remains bound to the target resource.¶
A CDN or intermediary can serve modified packages or stale manifests. Discovery Nodes and consumers MUST verify Root proofs and all relevant hashes after retrieval.¶
A Discovery Node can expose resources outside its authorized domains. Discovery implementations MUST enforce authorized-domain filtering before indexing or returning trusted candidates.¶
Local ranking, semantic search, or reputation features can be mistaken for trust decisions. Implementations MUST apply ranking only after Root package verification and Discovery authorization filtering.¶
A stale cache can return superseded or revoked resources. Discovery Nodes SHOULD track freshness and fail closed for trust-sensitive results when lifecycle state is stale beyond policy.¶
Attackers can replay upstream submissions or signed invocation envelopes. Signed envelopes MUST bind timestamp, nonce, audience, operation, and body hash. Receivers MUST enforce freshness windows and nonce uniqueness.¶
A request prepared for one resource can be redirected to another endpoint. Consumers and service resources SHOULD bind signed access or invocation envelopes to the selected target identifier and verified endpoint metadata.¶
A Skill file, MCP manifest, API description, or executable can be replaced at its external host. Consumers MUST verify artifact digests and package binding before use.¶
Independent implementations can compute different hashes for the same logical object. Bindings MUST define the signed or hashed representation, including canonicalization where used, and SHOULD provide test vectors.¶
Identity documents, descriptors, and artifact references can trigger costly retrieval or access to unintended services. Verifiers SHOULD bound input size, nesting, reference depth, redirects, and retrieval time, and restrict destinations. An advertised URL MUST NOT itself authorize access to private network services or disclosure of credentials to another origin. A required check that exceeds those limits fails explicitly rather than being skipped.¶
A compromised Root signing key can undermine a trust domain. Deployments SHOULD define key rotation, compromise response, revocation, and recovery procedures. Higher-assurance deployments SHOULD consider threshold signing or other operational controls.¶
Attackers can submit many registrations, trigger expensive verification, or overload Discovery queries. Registrars, Root Nodes, CDN Services, and Discovery Nodes SHOULD apply rate limits, quotas, backpressure, input size limits, and monitoring.¶
OAN metadata can reveal provider identities, service endpoints, capability areas, business relationships, policy requirements, and organizational structure. Deployments SHOULD minimize public metadata and avoid publishing private endpoint details, unnecessary internal schemas, private credentials, or sensitive operational information.¶
Discovery queries can reveal user or enterprise intent. Discovery Nodes SHOULD provide transport confidentiality, access control where appropriate, retention limits, privacy-preserving logs, and clear operator policies for query data.¶
External artifact references can leak which users or organizations retrieve a Skill, API description, or package from a third-party host. Consumers SHOULD consider retrieval privacy and artifact caching policies for sensitive deployments.¶
This document makes no IANA requests.¶
Future OAN profiles that define media types, URI schemes, HTTP fields, well- known URIs, registries, or protocol parameter values are expected to include their own IANA considerations.¶
This section is to be removed before publication as an RFC.¶
A research implementation of OAN has been developed with
separate Root, Registrar, Discovery, and CDN services; resource-oriented
registration; did:oan resource identifiers; first-class resource types for
Agent Service, Skill, MCP Server, and Tool/API; subject-control proof;
Registrar-issued registration evidence; Root-verified ResourcePackage objects;
signed upstream envelopes; Root-to-CDN package publication; Discovery package
verification; authorized-domain filtering; signed Discovery responses; and
pre-use verification examples.¶
The open-source project is available at https://github.com/OpenAgenet. The repository set is expected to evolve as the implementation and draft are refined. The existence of this code is intended to support experimentation, review, and interoperability feedback; it is not required for conformance.¶
Implementation details such as repository layout, programming language, database backend, HTTP route names, local file paths, and operator tooling are not specified by this document.¶
An implementation or deployment can be reviewed against the following checklist:¶
resource type consistency is checked across identifiers, metadata, submissions, packages, and Root proofs;¶
subject-control proof is required before authoritative registration evidence is issued;¶
trusted upstream writes are signed and bind method, path, audience, timestamp, nonce, and body hash;¶
Registrar and Discovery infrastructure authorization checks fail closed when state is missing, stale, suspended, revoked, expired, or unknown;¶
Root proof binds resource identifier, resource type, package version, identity-document hash, metadata hash, package hash, hash algorithm, and lifecycle state;¶
CDN content is verified after retrieval;¶
Discovery enforces authorized domains before ranking or returning trusted candidates;¶
custom tags do not expand authorization scope;¶
latest active package version is returned by default;¶
historical versions are explicitly identified when returned;¶
external artifacts are verified by digest before use;¶
signed Discovery responses are verified by consumers; and¶
replayed or stale signed envelopes are rejected.¶
Where the corresponding features are supported, the review also checks that:¶
updates and transfers are authorized against previously accepted control;¶
concurrent updates cannot both consume one exclusive prior-state condition;¶
concurrent nonce replay and restart do not reopen an active replay window;¶
an uncertain submission can be reconciled without blind duplicate mutation;¶
scanned synchronization progress is not confused with accepted content;¶
repair never restores an obsolete active state over a newer suspension;¶
external-identifier association does not imply verified external ownership;¶
governance evidence and credentials refer to the same authority scope;¶
cross-Root acceptance is explicit, scoped, and not assumed transitive;¶
independent Roots' conflicting revisions are not silently merged; and¶
verified package and endpoint bindings survive through actual use.¶
The HTTPS identifiers below are illustrative stable identifiers, not a new identifier method or a definition of did:oan syntax. A concrete profile defines their authority and resolution semantics. The examples omit fields not needed to illustrate each relationship and are not complete test vectors.¶
The following JSON fragment illustrates a ResourcePackage. It is not a mandatory wire format.¶
{
"resourceDid": "https://resources.example.org/id/translator",
"resourceType": "agent_service",
"packageVersion": "3",
"lifecycleState": "active",
"didDocumentHash": "sha256:012345...",
"metadataHash": "sha256:abcdef...",
"packageHash": "sha256:789abc...",
"hashAlgorithm": "sha256",
"metadata": {
"name": "Example Translator",
"capabilityTags": ["translation", "translation.zh-en"],
"customTags": ["legal-contract-translation"],
"protocolBindings": ["https"]
},
"registrarDid": "https://registrar.example.org/id",
"rootProof": {
"type": "ExampleDataIntegrityProof2026",
"verificationMethod": "https://root.example.org/id#key-1",
"packageClaims": {
"resourceDid": "https://resources.example.org/id/translator",
"resourceType": "agent_service",
"packageVersion": "3",
"didDocumentHash": "sha256:012345...",
"metadataHash": "sha256:abcdef...",
"packageHash": "sha256:789abc...",
"hashAlgorithm": "sha256",
"lifecycleState": "active"
},
"proofValue": "..."
}
}
¶
The following JSON fragment illustrates an external artifact reference for a Skill resource. It is not a mandatory wire format.¶
{
"resourceDid": "https://resources.example.org/id/invoice-review",
"resourceType": "skill",
"packageVersion": "1.0.0",
"artifact": {
"uri": "https://example.org/skills/invoice-review.skill.json",
"mediaType": "application/example-skill+json",
"version": "1.0.0",
"digest": "sha256:13579b...",
"retrievalPolicy": "public-read"
},
"implementedBy": [
{
"resourceDid": "https://resources.example.org/id/mcp",
"resourceType": "mcp_server"
}
]
}
¶
The following JSON fragment illustrates a signed Discovery response. It is not a mandatory wire format.¶
{
"discoveryDid": "https://discovery.example.org/id",
"issuedAt": "2026-06-06T08:01:00Z",
"expiresAt": "2026-06-06T08:06:00Z",
"resultScope": {"completeForQuery": true},
"queryHash": "sha256:2468ac...",
"results": [
{
"resourceDid": "https://resources.example.org/id/translator",
"resourceType": "agent_service",
"packageVersion": "3",
"packageHash": "sha256:789abc...",
"metadataHash": "sha256:abcdef...",
"lifecycleState": "active",
"matchedTags": ["translation.zh-en"],
"rootProofRef": "root-proof:4812"
}
],
"proof": {
"type": "ExampleDataIntegrityProof2026",
"verificationMethod": "https://discovery.example.org/id#key-1",
"proofValue": "..."
}
}
¶
The authors thank participants in discussions on open agent networks, resource identity, trusted discovery, and cross-protocol agent interoperability.¶