Understanding ARD+JSON: The Emerging Architecture for Agent Resource Discovery

Computer screen showing ChatGPT search interface

What the emerging Agent Resource Discovery (ARD) specification means for developers, and what current implementations tell us about preparing websites for AI-driven interactions.

Websites have established ways of making their content discoverable. Search engines follow links, process sitemaps, interpret structured data, and index pages so people can find relevant information. These mechanisms have evolved around discovering and understanding content.

AI agents introduce another requirement. An agent may need to identify a service, determine what it can do, and understand how to interact with it programmatically. The capability might be exposed through an API, an MCP server, another agent, or a set of instructions describing a specific workflow.

The challenge is that these resources are often distributed across different platforms and protocols. Even when a service is publicly available, an AI client may have no straightforward way to discover that it exists.

Agent Resource Discovery (ARD) is an emerging specification designed to address this problem. It proposes a common framework for publishing descriptions of agent-accessible resources, indexing them through registries, and retrieving them when they are relevant to a task.

ARD was introduced publicly in June 2026, and its architecture was subsequently described in an IETF Internet-Draft published October 30, 2026. The IETF documents remain works in progress, but publicly accessible implementations already provide useful evidence of how the approach can work.

Understanding the Discovery Problem

Consider a website that exposes an API for retrieving product information, a skill that helps users prepare support requests, and an MCP server that provides access to selected business operations.

Each resource might function correctly on its own. An API can have valid documentation, a skill can contain clear instructions, and an MCP server can expose properly defined tools. However, an external AI client still needs to know where to find those resources.

Current integrations commonly depend on configuration that identifies specific tools or services in advance. ARD proposes moving some of that discovery work into a separate layer.

The architecture introduces two important components: manifests and registries.

A manifest describes the resources published by an organization. A registry can collect those descriptions and make them searchable. When an agent needs a capability, it can retrieve a known publisher’s manifest or query a registry for resources matching the task.

Once a resource is selected, interaction happens through its native protocol. ARD handles discovery; it does not become the execution system.

This separation is important because it allows different technologies to participate without requiring them to adopt a common runtime.

How ARD Uses JSON to Describe Resources

The current ARD Manifest and Lookup draft proposes a JSON manifest with the media type application/ard+json. For ordinary web publishing, the proposed location is:

https://example.com/.well-known/ard.json

The document contains an entries array. Each entry identifies a resource, describes its purpose, and provides either a URL pointing to its descriptor or an inline description.

The required fields include identifier, displayName, type, and exactly one of url or data. Other fields help discovery services understand when the resource might be useful.

For example, a simplified manifest describing a project-inquiry skill could look like this:

{
  "entries": [
    {
      "identifier": "urn:air:example.com:skill:project-inquiry",
      "displayName": "Project Inquiry",
      "type": "application/agent-skills+md",
      "url": "https://example.com/.well-known/agent-skills/project-inquiry/SKILL.md",
      "description": "Instructions for preparing a project inquiry.",
      "capabilities": [
        "ProjectBriefPreparation",
        "ContactRouting"
      ],
      "representativeQueries": [
        "how do I prepare a project brief?",
        "where can I submit a project inquiry?"
      ]
    }
  ]
}

This is an illustrative example following the proposed entry format, not a claim about a deployed service.

The identifier provides a stable resource identity anchored to the publisher’s domain. The type indicates that the referenced resource is an Agent Skill written in Markdown. The URL points to the actual skill document.

The representativeQueries field is particularly interesting. It describes realistic requests that might cause an agent to look for this capability. A registry supporting semantic search can use those examples as signals for matching user intent to relevant resources.

Publishing the manifest does not mean an AI client can automatically complete the inquiry. The referenced skill still needs to provide useful instructions, and any action requiring access to an external service must be supported separately.

What Existing Implementations Demonstrate

ARD is still evolving, but several publicly available projects demonstrate meaningful parts of the proposed architecture.

Hugging Face’s hf-discover provides an open-source discovery client and server for finding AI skills, MCP servers, and other resources. Its documentation includes command-line searching, registry querying, and navigation between discovery services.

This demonstrates an important architectural distinction. A client can search for relevant capabilities instead of loading every available tool description into its working context. It can then retrieve the specific resource information needed for the selected task.

A different implementation is visible in Ora’s published ARD manifest. Its JSON catalog contains entries describing MCP services, an A2A agent, an Agent Skill, API resources, and a discovery registry.

The entries expose resource identifiers, types, descriptions, capabilities, and example queries. Some also contain publisher identity metadata. This provides a concrete example of how one domain can advertise different types of agent-accessible resources through a single discovery document.

Desvela publishes another ARD manifest, including references to its discovery registry and MCP-accessible services. Its registry documentation describes the indexing of agent-related discovery files across public websites.

Nevermined’s published manifest illustrates an extension of the same idea. Alongside resource descriptions, some entries contain metadata about payment methods, prices, and service availability. ARD’s JSON-LD approach permits additional vocabularies, allowing publishers to describe specialized requirements without changing the basic discovery model.

These examples establish that manifests and discovery implementations exist beyond specification documents. They do not establish universal compatibility, comprehensive crawling, or automatic support across all AI assistants.

Practical Implementation Considerations

For a development team evaluating ARD, the first step should be understanding which resources the website actually makes available.

A conventional content website may have little reason to advertise executable capabilities. A platform exposing documented APIs, MCP tools, Agent Skills, or agent-to-agent interfaces has a more immediate use case.

The following practices are worth considering during implementation.

Use the current discovery location. The proposed path is /.well-known/ard.json. Earlier ARD implementations used /.well-known/ai-catalog.json, and some clients still reference that location. Supporting older paths may help compatibility, but the current specification identifies ard.json as the preferred publishing location.

Describe actual capabilities. Each entry should point to a maintained resource with a working descriptor. Metadata should accurately reflect what the resource supports, including any limitations on access or execution.

Write queries around user intent. The specification recommends two to five representative queries per entry. These should reflect how someone would naturally request the capability, rather than repeating generic promotional descriptions. Accurate examples give registries more useful signals for matching.

Validate the manifest and its references. Valid JSON is only the beginning. Publishers should check required fields, domain-anchored identifiers, supported media types, and the rule that each entry contains either url or data. The ARD specification repository provides schema definitions and conformance-testing tools for this purpose.

Treat discovery as a security boundary. A resource appearing in a manifest does not make it trustworthy. The architecture provides for signed trust metadata and cryptographic content digests, but the presence of an identifier or an unsigned identity claim alone does not prove publisher authority. Consumers still need to authenticate services and enforce authorization before performing protected operations.

Maintain the discovery layer as part of deployment. When resource locations, versions, or capabilities change, the manifest needs to remain consistent with the underlying implementation. A discoverable resource that no longer works creates problems for both automated clients and the people relying on them.

These considerations are especially relevant to established websites. An organization does not necessarily need to rebuild its platform to publish a discovery manifest. However, publishing the file is useful only when it accurately represents resources that can be retrieved or used.

Where ARD Fits Alongside MCP, Agent Skills, and llms.txt

ARD addresses a different part of the interaction process from several other emerging technologies.

The Model Context Protocol defines how AI applications communicate with tools and contextual resources. Agent Skills provide reusable instructions and supporting materials for particular tasks. The proposed llms.txt format is intended to help language-model systems locate useful website content and documentation.

ARD can reference applicable resources without replacing those underlying formats or protocols.

For example, a website could publish an Agent Skill describing how to prepare a technical support request. Its ARD manifest could advertise the skill and link to its instructions. An agent that discovers the entry could retrieve the skill and determine whether it is applicable.

If the workflow also requires submitting information to a secured API, that interaction remains subject to the API’s own authentication, authorization, and operational rules.

The distinction helps keep discovery metadata separate from the systems responsible for performing actions.

It also avoids treating every new machine-readable file as another form of search optimization. ARD is concerned with discovering software capabilities. Whether those capabilities are trustworthy, usable, and appropriate for a particular request depends on additional factors.

Preparing for a More Discoverable Web

ARD’s direction is promising because it builds on familiar Internet principles: domain-based publishing, HTTP, structured metadata, and independently operated discovery services.

There are still open questions. The October 2026 IETF documents have not become approved standards, the implementation ecosystem continues to evolve, and differences between specification versions remain visible in existing tools.

It is also important to distinguish a published manifest from successful discovery. A website can make its resources available without guaranteeing that any particular registry will index them or that an AI assistant will use them.

For developers, the practical opportunity is to begin thinking about capabilities as resources that can be described and maintained independently of the interfaces exposing them.

A website’s navigation explains how people can explore its content. Its APIs and services define what software can do. ARD proposes a way to make those software capabilities easier to discover across systems.

As more digital platforms support agent-driven interactions, that distinction is likely to become increasingly relevant. The useful work today is understanding the emerging architecture, testing real implementations, and keeping capability descriptions accurate as the standards develop.

Exploring how emerging AI technologies could fit into your existing website or digital platform? Let’s talk about what’s possible.