ARD Registry Builder

Agentic Resource Discovery (ARD) lets AI clients discover agents, MCP servers, skills, and APIs at runtime by search instead of hardcoding them. Publishers describe their resources in a static ai-catalog.json capability manifest; dynamic Agent Registries index those manifests and answer POST /search. This skill helps you engineer both — author, validate, test, and maintain them so they actually pass conformance and get discovered.

Two artifacts, one mental model — identity vs location:

• The manifest (ai-catalog.json, static) lists entries. Each entry's identifier is a permanent urn:air: URN (identity); its url/data is the movable endpoint (location).
• The registry (REST API, dynamic) is a service that searches indexed entries.

Never bake a hostname into a URN; never treat a URL as an identity. Almost every ARD mistake traces back to confusing these two.

Bundled tools (use these — don't reinvent them)

All scripts are stdlib-only Python 3.8+; validate_catalog.py uses the jsonschema library when present (recommended: pip install jsonschema) and falls back to a built-in checker.

Always validate after every edit, and validate the live URL after publishing — not just the local file.

Decide what the user needs

• "Create / scaffold / start a catalog" → Workflow 1.
• "Validate / check / is this valid / why won't it pass conformance / fix this manifest" → Workflow 2 (run validate_catalog.py first, before reading anything).
• "Test / probe my registry / does my /search work / is my API ARD-compliant" → Workflow 3.
• "Add an agent / bump a version / change an endpoint / maintain" → Workflow 4.
• "How does X work" (data model, API, trust, publishing) → read the matching reference below.

Workflow 1 — Build a manifest

1. Pick the closest template and scaffold it: python scripts/new_catalog.py --template enterprise --publisher mycorp.com --host "MyCorp AI" --out ./ai-catalog.json. (Without scaffolding, copy a file from assets/templates/.)
2. For each resource, set identifier (urn:air:<publisher>:<namespace?>:<name>), displayName, type (the artifact's media type), and exactly one of url or data.
3. Add description, tags, capabilities, and especially representativeQueries (2–5) — the single biggest lever for being found by semantic search.
4. Add trustManifest only when you have real identity/attestations; keep simple entries lean.
5. Choose the publisher domain to match the deployment context (enterprise FQDN, public namespace like github.com:you, or agent.localhost/example.com for local-only). See references/data-model.md.
6. Validate: python scripts/validate_catalog.py ./ai-catalog.json. Fix until it passes.

Workflow 2 — Validate / debug a manifest

1. Run the validator first, before reading the file by hand — it pinpoints issues fast: python scripts/validate_catalog.py <path-or-url>.
2. Read findings by severity. ERROR must be fixed; WARN should be (use --strict in CI to enforce); INFO is advice. Every finding names a JSON path and a stable code.
3. Map the code to a fix using references/validation-rules.md. The high-frequency ones:
   • urn-wrong-nid → change urn:ai: to urn:air:.
   • value-or-reference → keep exactly one of url / data.
   • schema (oneOf/required/pattern/minItems) → fix the structure the message names.
   • urn-localhost / urn-publisher-fqdn → use a verifiable or reserved-placeholder domain.
   • trust-domain-mismatch → make the trustManifest.identity domain match the URN publisher.
4. Re-run until clean. For CI, use --json (machine output) and/or --strict (fail on warnings).

Workflow 3 — Test a live registry API

1. Probe it: python scripts/test_registry.py https://registry.example.com/api/v1. The tester sends a real POST /search, validates the results envelope (each item is a catalog entry carrying a score 0–100 and a source), confirms a malformed request is rejected with 400 + errorCode + message, and checks optional /agents and /explore (skipped, not failed, when a server returns 404/501).
2. Required checks failing → the server is not ARD-conformant on the mandated floor (/search). Fix the envelope/status against references/registry-api.md.
3. For exploratory calls, hit endpoints directly with curl (see references/registry-api.md).

Workflow 4 — Update / maintain

1. Edit the entry. Keep the identifier URN stable — it is a permanent contract. To move an endpoint, change url (or data), never the URN.
2. Bump the entry's version and refresh updatedAt (ISO 8601) when the artifact changes.
3. Adding a resource → append an entry; ensure its identifier is unique (the validator flags duplicates).
4. Re-validate the file; if it is already published, also validate the live URL and re-probe any registry. Treat "passes validation" as the definition of done.

Golden rules (the why behind the checks)

• URN = identity, url/data = location. Stable URNs keep search indexes, client references, and orchestration working while infrastructure moves underneath them.
• The publisher segment must be a verifiable FQDN. Registries extract it and bind it to trustManifest.identity to stop namespace squatting. localhost and bare words break this.
• Exactly one of url or data. Predictable parsing in enterprise pipelines depends on it.
• score is relevance, not trust. Never gate safety on a search score; verify trustManifest independently.
• Validate early, validate often, validate the live URL. Most "it won't index" problems are schema or hosting issues a 1-second validator run would have caught.

Reference files

Read the one matching the task; each has a table of contents.

• references/data-model.md — manifest/entry fields, URN format, media types, value-or-reference, trust manifest, and the known urn:air: vs urn:ai: doc inconsistencies.
• references/registry-api.md — /search, /explore, /agents, the query/filter model, federation modes, and error codes.
• references/validation-rules.md — every check the validator runs, with its code and severity.
• references/publishing.md — well-known URI, CORS, DNS discovery, and public reference registries to test against.

Evals

evals/evals.json holds realistic task prompts for the skill-creator evaluation loop. Use it to benchmark or regression-test changes to this skill.