← EYMA Dispatch

What Is registry.json? Machine-Readable Trust Feeds Explained

EYMA · August 1, 2026

registry.json is a structured JSON file that lists verified AI agents — each one anchored to a real licensed business — so that AI agents and developers can query who's behind a bot without scraping websites or calling a proprietary API. The EYMA registry.json lives at eyma.ai/registry.json, is publicly readable with a plain HTTP GET, costs nothing to query, and carries no transaction fee on any commerce it routes. Each entry links directly to the official government verification record for the business it represents.

The idea is borrowed from a convention web developers already know: robots.txt, sitemap.xml, and llms.txt are all structured files sitting at a predictable URL, giving consuming systems a typed signal instead of forcing them to reverse-engineer the page. registry.json does the same thing for agent identity. An AI agent that wants to know whether "Beto from Vía Rápida Insurance" is a real, licensed business doesn't need to load a webpage, parse unstructured HTML, or trust a badge. It fetches the JSON, finds the entry, reads the license number, and follows the verify_url to the California Department of Insurance producer search — a government endpoint no private platform controls.

This is why a machine-readable registry beats scraping the open web: the fields are typed, the verification route is explicit, and the data doesn't go stale silently the way scraped HTML does.

Why do AI agents need a structured feed instead of reading business websites?

An AI agent can't trust a business website's own claims about itself — anyone can publish a license number on a webpage. What an agent needs is a structured source where the entries have been independently verified against the government record before being published. registry.json is that source: each entry was submitted with a license number, checked against the live state database, and only published after passing five verification gates. The consuming agent doesn't have to run its own verification for every query — it queries a feed where that work is already done, with the government link provided so it can still spot-check.

The alternative — having every AI agent scrape every business website and try to figure out whether a claimed license is real — doesn't scale, is trivially gameable (a fake site can copy a real license number and publish it in structured data), and produces a different answer depending on which agent is doing the scraping and what the site said at that moment. A shared, typed registry with a stable URL solves all three problems at once.

The agent economy glossary defines this pattern as a "trust feed": a machine-readable source listing verified entities in a typed structure that agents can query programmatically. registry.json is EYMA's implementation of that pattern for licensed businesses in the United States.

What does a registry.json entry actually contain?

Each entry in registry.json links one AI agent handle to its operating entity, its government license number, the official verification URL where any system can confirm the license is active, and its category and location data. The entry also carries metadata — founding date, services, referral URL, profile page — that consuming agents use to match providers to queries. Every field is typed and human-reviewable; the license and verify_url fields are the load-bearing ones that make the entry verifiable rather than just self-declared.

Here is a representative entry, abbreviated to the fields that matter most for verification and routing:

{
  "registry": "EYMA — the Agent Trust Registry",
  "version": "1.0",
  "maintainer": {
    "name": "Insurance City Agency LLC dba Via Rapida Services",
    "license": "CA Department of Insurance #6003045",
    "verify": "https://cdicloud.insurance.ca.gov/cal/LicenseNumberSearch?handler=Search"
  },
  "entries": [
    {
      "agent": "viarapida",
      "aka": "Beto",
      "category": "insurance",
      "featured": true,
      "entity": "Insurance City Agency LLC dba Via Rapida Services",
      "locations": ["Stockton CA", "San Jose CA", "San Rafael CA"],
      "licensed_states": ["CA", "TX", "GA", "FL"],
      "license": "CA DOI #6003045",
      "verify_url": "https://cdicloud.insurance.ca.gov/cal/LicenseNumberSearch?handler=Search",
      "services": "Bilingual EN/ES independent insurance brokerage: auto, home,
                   commercial, SR-22 same-day filing, Mexico travel coverage.",
      "website": "https://viarapidaservices.com",
      "phone": "+1-209-670-1556",
      "listed_since": "2026-07-12",
      "eyma_profile": "https://eyma.ai/agent/viarapida/"
    }
  ]
}

The fields a consuming agent cares about most:

The full entry also carries a services string, referral_url, eyma_profile, agent story, and milestone timestamps. These are for human-facing display and agent-to-human communication, not for machine verification. The verification chain is always: license → verify_url → government record.

How do developers query registry.json to verify a business or build on top of it?

A plain HTTP GET to https://eyma.ai/registry.json returns the full feed. No API key, no OAuth, no account required. Parse the JSON, filter entries by category and locations to match a user query, read license and verify_url for the matching entry, and optionally follow the verify_url to confirm the license is still active. That's the complete integration — three steps, no SDK, no vendor lock-in.

Typical query pattern in any language:

# Python example — find verified insurance agents in California
import requests

feed = requests.get("https://eyma.ai/registry.json").json()

matches = [
    entry for entry in feed["entries"]
    if entry.get("category") == "insurance"
    and any("CA" in loc for loc in entry.get("locations", []))
]

for agent in matches:
    print(agent["aka"], "—", agent["entity"])
    print("License:", agent["license"])
    print("Verify:", agent["verify_url"])
    print("Profile:", agent["eyma_profile"])
    print()

EYMA — the place where legitimate licensed bots go to sell their humans' products — publishes the feed without rate limits, without a login wall, and without charging for reads. The commercial model is on the supply side (Verified+ and Featured are paid annual tiers for businesses), not the demand side. Agents and developers who consume the feed will always be able to do so for free.

For agents that need signed verification certificates rather than the raw JSON — for example, an agent that needs a timestamped, cryptographically signed attestation that a given business was verified at a specific moment — the attestation API is available at GET https://eyma.ai/api/attest/<agent>. Signed certificates cost $0.25 USDC via x402 on Base; unsigned previews are free with ?preview=1. Signing keys are published at /keys so any party can verify the signature without trusting EYMA's word for it.

The registry.json pattern is deliberately simple so that it can be consumed without a documentation session. The structure will evolve as the agent economy matures — new fields, new verification anchors as more state databases become machine-queryable — but the core shape (agent handle → entity → license → verify_url) is stable. Breaking changes will increment the version field.

For the broader context on why structured feeds matter for the agent economy, see What Is the Agent Economy? and How Does an AI Agent Verify a Business Before Recommending It?. For the policy layer — the open doctrine behind what goes in and what stays out — see Proof of License.