DEV Community

Cover image for The Universal Agent Registry: How We're Solving AI Agent Discovery
Michael Kantor
Michael Kantor

Posted on

The Universal Agent Registry: How We're Solving AI Agent Discovery

#ai #agents #interopability #web3

MIT's Project NANDA predicts an "Internet of Agents" where billions of autonomous AI agents discover each other, verify capabilities, and coordinate tasks.

We're already at 59,000+ indexed agents across ecosystems like NANDA, Virtuals, OpenRouter, and on-chain registries. And that's just what we've indexed so far.

But here's the thing: a single database won't scale to billions. The early internet didn't put all websites in one server. It built DNS and HTTP as federated protocols.

We're building the same thing for agents.

The Universal Registry for the best AI Agents

The goal isn't one registry to rule them all. It's a registry of registries that can discover and verify each other. Enter, the Hashgraph Online Registry Broker

Flora Nodes

Flora nodes are the backbone of the federated network. Each Flora is a multi-signature coordination account where multiple parties maintain shared state through consensus. Floras:

  • Coordinate through cryptographic consensus
  • Maintain verifiable state across members
  • Can join and federate with other Floras
  • Enable horizontal scaling without centralization Individual agent accounts (Petals) can participate in Floras, pooling resources and coordinating on tasks. The registry aggregates agents from external registries into a unified search. Every indexed agent gets a Universal Agent ID (UAID) that works regardless of where the agent lives or what protocol it speaks.

Protocol Agnostic

We don't pick winners. The registry indexes from multiple ecosystems:
MCP: Anthropic's Model Context Protocol. SSE-based servers with tools and resources.
A2A: Google's Agent-to-Agent protocol. Endpoints and capability cards.
OpenRouter: LLM model routing with chat capabilities.
ERC-8004: On-chain agent identity on EVM chains and Solana.
Aggregated Registries: NANDA, Virtuals, AgentVerse, Coinbase X402, PulseMCP, and others.

What's a UAID?

A Universal Agent ID is a portable identifier that encodes everything needed to locate and verify an agent:

uaid:aid:openrouter-adapter;uid=openrouter/auto;registry=openrouter;proto=openrouter-adapter
Enter fullscreen mode Exit fullscreen mode

The UAID contains:

  • aid: The agent identifier within the registry
  • uid: The unique ID in the source system
  • registry: Which registry the agent came from
  • proto: The communication protocol This means you can reference an agent without knowing which ecosystem it lives in. The registry handles resolution. ## Code Examples All examples use the @hashgraphonline/standards-sdk. Install with: 
npm install @hashgraphonline/standards-sdk
Enter fullscreen mode Exit fullscreen mode

Initialize the Client 

import { RegistryBrokerClient } from '@hashgraphonline/standards-sdk';
const client = new RegistryBrokerClient({ 
  baseUrl: 'https://hol.org/registry/api/v1' 
});
Enter fullscreen mode Exit fullscreen mode

Searching for Agents

Search across all indexed registries:

const results = await client.search({
  q: 'weather forecast',
  protocols: ['a2a', 'mcp'],
  limit: 20,
});
for (const agent of results.hits) {
  console.log(`${agent.name} (${agent.uaid})`);
  console.log(`  Registry: ${agent.registry}`);
  console.log(`  Protocol: ${agent.communicationProtocol}`);
}
Enter fullscreen mode Exit fullscreen mode

Filter by specific registries:

// NANDA research agents
const nandaAgents = await client.search({
  registries: ['nanda'],
  limit: 10,
});
// Virtuals Protocol agents
const virtualsAgents = await client.search({
  registries: ['virtuals-protocol'],
  limit: 10,
});
// On-chain verified agents
const onchainAgents = await client.search({
  registries: ['erc-8004', 'erc-8004-solana'],
  verified: true,
  limit: 10,
});
Enter fullscreen mode Exit fullscreen mode

Filter by capabilities and trust:

const trustedAgents = await client.search({
  q: 'trading',
  minTrust: 80,
  capabilities: ['TEXT_GENERATION', 'DATA_ANALYSIS'],
  online: true,
  limit: 20,
});
Enter fullscreen mode Exit fullscreen mode

Resolving an Agent

Get full details for a specific UAID:

const resolved = await client.resolveUaid(uaid);
console.log(`Name: ${resolved.agent.name}`);
console.log(`Available: ${resolved.agent.available}`);
console.log(`Endpoints:`, resolved.agent.endpoints);
console.log(`Profile:`, resolved.agent.profile);
Enter fullscreen mode Exit fullscreen mode

Registering an AI Agent

Register your agent to make it discoverable:

import { 
  ProfileType, 
  AIAgentType, 
  AIAgentCapability 
} from '@hashgraphonline/standards-sdk';
const result = await client.registerAgent({
  profile: {
    version: '1.0',
    type: ProfileType.AI_AGENT,
    display_name: 'My Weather Agent',
    alias: 'weather-agent-v1',
    bio: 'Real-time weather data and forecasts for any location',
    properties: {
      tags: ['weather', 'forecast', 'api'],
    },
    aiAgent: {
      type: AIAgentType.AUTONOMOUS,
      model: 'gpt-4-turbo',
      capabilities: [
        AIAgentCapability.TEXT_GENERATION,
        AIAgentCapability.DATA_RETRIEVAL,
      ],
      creator: 'My Organization',
    },
  },
  communicationProtocol: 'a2a',
  endpoint: 'https://my-agent.example.com/a2a',
  registry: 'hashgraph-online',
});
console.log(`Registered! UAID: ${result.uaid}`);
console.log(`Agent ID: ${result.agentId}`);
Enter fullscreen mode Exit fullscreen mode

Registering an MCP Server

Register an MCP server with tools and resources:

import { 
  ProfileType, 
  MCPServerCapability 
} from '@hashgraphonline/standards-sdk';
const result = await client.registerAgent({
  profile: {
    version: '1.0',
    type: ProfileType.MCP_SERVER,
    display_name: 'Postgres Analytics',
    alias: 'pg-analytics',
    bio: 'Read-only analytics queries over PostgreSQL',
    properties: {
      tags: ['database', 'analytics', 'postgresql'],
    },
    mcpServer: {
      version: '2024.10',
      description: 'Query analytics data from PostgreSQL',
      connectionInfo: {
        url: 'https://mcp.example.com/pg-analytics/sse',
        transport: 'sse',
      },
      services: [
        MCPServerCapability.TOOL_PROVIDER,
        MCPServerCapability.DATABASE_INTEGRATION,
      ],
      tools: [
        { name: 'run_query', description: 'Execute a read-only SQL query' },
        { name: 'get_schema', description: 'Retrieve table schema' },
      ],
      maintainer: 'My Organization',
      docs: 'https://docs.example.com/pg-analytics',
    },
  },
  communicationProtocol: 'mcp',
  registry: 'hashgraph-online',
});
console.log(`MCP Server registered: ${result.uaid}`);
Enter fullscreen mode Exit fullscreen mode

Multi-Registry Registration

Register to the main registry and additional chains in one call:

const result = await client.registerAgent({
  profile: { /* ... */ },
  communicationProtocol: 'a2a',
  endpoint: 'https://my-agent.example.com/a2a',
  registry: 'hashgraph-online',
  additionalRegistries: ['erc-8004:base-sepolia', 'erc-8004-solana'],
});
// Check status of additional registrations
for (const entry of result.additionalRegistries ?? []) {
  console.log(`${entry.registry}: ${entry.status}`);
  if (entry.agentId) {
    console.log(`  On-chain ID: ${entry.agentId}`);
  }
}
Enter fullscreen mode Exit fullscreen mode

Chat Sessions

Create a chat session and send messages:

// Create session
const session = await client.chat.createSession({
  uaid,
  historyTtlSeconds: 900,
});
console.log(`Session: ${session.sessionId}`);
// Send message
const response = await client.chat.sendMessage({
  sessionId: session.sessionId,
  uaid,
  message: 'What can you help me with?',
});
console.log(`Response: ${response.message}`);
// Get history
const history = await client.chat.getHistory(session.sessionId);
console.log(`Messages: ${history.history.length}`);
// End session
await client.chat.endSession(session.sessionId);
Enter fullscreen mode Exit fullscreen mode

Encrypted Conversations

For sensitive agent-to-agent communication:

// Initialize with encryption key
const setup = await RegistryBrokerClient.initializeAgent({
  baseUrl: 'https://hol.org/registry/api/v1',
  uaid: myAgentUaid,
  ensureEncryptionKey: { 
    generateIfMissing: true,
    label: 'my-agent-key',
  },
});
// Start encrypted conversation
const conversation = await setup.client.chat.startConversation({
  uaid: targetAgentUaid,
  senderUaid: myAgentUaid,
  encryption: { preference: 'required' },
  onSessionCreated: (sessionId) => {
    console.log(`Session created: ${sessionId}`);
  },
});
// Send encrypted message
await conversation.send({
  plaintext: 'This message is end-to-end encrypted.',
});
// Get and decrypt history
const history = await setup.client.chat.getHistory(
  conversation.sessionId,
  { decrypt: true }
);
for (const entry of history.decryptedHistory ?? []) {
  console.log(`[${entry.entry.role}] ${entry.plaintext}`);
}
Enter fullscreen mode Exit fullscreen mode

Agent Feedback

Submit feedback after interacting with an agent:

// Check eligibility
const eligibility = await client.checkAgentFeedbackEligibility(uaid, {
  sessionId,
});
if (eligibility.eligible) {
  // Submit feedback
  const submission = await client.submitAgentFeedback(uaid, {
    sessionId,
    score: 92,
    tag1: 'helpful',
    tag2: 'accurate',
  });

  console.log(`Feedback submitted: ${submission.feedbackId}`);
}
// Read aggregate feedback
const feedback = await client.getAgentFeedback(uaid);
console.log(`Average score: ${feedback.summary.averageScore}`);
console.log(`Total reviews: ${feedback.summary.totalReviews}`);
Enter fullscreen mode Exit fullscreen mode

Authentication

For operations that require identity (registration, feedback):

// Authenticate with ledger credentials
await client.authenticateWithLedgerCredentials({
  accountId: process.env.HEDERA_ACCOUNT_ID!,
  network: 'hedera:testnet',
  hederaPrivateKey: process.env.HEDERA_PRIVATE_KEY!,
  expiresInMinutes: 30,
  label: 'my-app',
});
// Now registration and other authenticated operations work
const result = await client.registerAgent({ /* ... */ });
Enter fullscreen mode Exit fullscreen mode

Trust

Discovery is useless if every result is spam. When you're searching for an agent to manage your portfolio or handle customer requests, you need to know it actually works and isn't a scam.
The registry tracks trust signals. We probe endpoints to verify they're live and respond correctly to their stated protocol. We aggregate feedback from users who've actually interacted with an agent. For agents registered on ERC-8004 chains, we can verify who owns them cryptographically.
You can filter search results by these signals. Only show verified agents. Only show agents that are currently online. Only show agents above a certain trust score. The API supports all of this:

const trustedAgents = await client.search({
  verified: true,
  online: true,
  minTrust: 80,
});
Enter fullscreen mode Exit fullscreen mode

The Bigger Picture

MIT's NANDA research points to a future with billions of agents. That's not hyperbole. If every person has a few personal agents, every company has hundreds, and every IoT device has one, we get there fast.
The infrastructure to support that doesn't exist yet. DNS took decades to build. We don't have decades.
So we're building incrementally. Today it's 59,000 agents across a dozen registries. Next it's 100 registries. Then it's Flora nodes running in multiple regions, each maintaining consensus on the global namespace.
The adapter system lets us add new registries quickly. Anyone building an agent ecosystem can submit an adapter. We index it, assign UAIDs, and it shows up in search.
The Flora architecture will let anyone run a node. If you want to host registry infrastructure for your region or industry, you'll be able to spin up a Flora, join consensus, and serve data. No permission required.

Try It

The registry is live at hol.org/registry.

npm install @hashgraphonline/standards-sdk
Enter fullscreen mode Exit fullscreen mode

Or on Deno:

deno add jsr:@hol-org/standards-sdk
Enter fullscreen mode Exit fullscreen mode

Docs: hol.org/docs/libraries/standards-sdk
GitHub: github.com/hashgraph-online/standards-sdk

Top comments (0)