Publish agents to DNS, discover them like websites, and verify trust with DNSSEC. No centralized registry, just signal.
Install the full SDK in one shot:
What DNS-AID gives you, built on the DNS-AID protocol.
Works with your existing DNS. No new record types, no new servers.
Cryptographic proof that agent records are authentic and untampered.
Supports MCP, A2A, HTTPS, and any future protocol out of the box.
Find agents by name, by capability, or crawl a full domain index.
Show different agents to internal vs. external users. Built-in tenant isolation.
CLI, Python SDK, and MCP server. Backends for Route 53, Cloudflare, Infoblox, and BIND9.
Agents prove they're authorized to act for a domain. Great for short-lived agents.
DNS caches results automatically. No central API. Fast, distributed lookups.
A deterministic, human-readable naming pattern for agent records.
_<agent-name>._<protocol>._agents.<your-domain> Examples: _chatbot._mcp._agents.example.com MCP chatbot _search._a2a._agents.example.com A2A search agent _data-cleaner._a2a._agents.acme.com capability-based _index._agents.example.com full agent index Multi-tenant: _analytics._mcp._agents.customer1.saas.com
Four steps from publish to connect.
Use the CLI or SDK to create an SVCB record under your domain's _agents zone with endpoint, protocol, and capabilities.
Your authoritative DNS signs the records, creating a cryptographic chain of trust from root to your agent.
Remote agents query DNS for your SVCB record by name, capability type, or full domain index.
The discoverer validates DNSSEC + DANE, then connects directly via the protocol in your SVCB record.
Get up and running with the dns-aid-core Python package.
pip install "dns-aid[all]" # everything pip install "dns-aid[cli]" # CLI only pip install "dns-aid[route53]" # AWS backend pip install "dns-aid[cloudflare]" # Cloudflare backend pip install "dns-aid[nios]" # Infoblox NIOS backend pip install "dns-aid[mcp]" # MCP server
dns-aid publish \ --name my-chatbot \ --domain example.com \ --protocol mcp \ --endpoint agent.example.com \ --capability chat
dns-aid discover example.com dns-aid discover example.com --json dns-aid discover example.com --use-http-index
dns-aid verify _my-chatbot._mcp._agents.example.com dns-aid doctor --domain example.com
# List tools on an MCP agent dns-aid list-tools https://mcp.example.com/mcp # Call a specific tool dns-aid call https://mcp.example.com/mcp analyze_security \ --arguments '{"domain":"example.com"}' # Send a message to an A2A agent (discover-first) dns-aid message "What is DNS-AID?" \ -d ai.infoblox.com -n security-analyzer
# Delete an agent from DNS dns-aid delete -n my-chatbot -d example.com -p mcp
from dns_aid import publish result = await publish( name="my-chatbot", domain="example.com", protocol="mcp", endpoint="agent.example.com", capabilities=["chat", "summarize"], description="General-purpose chat agent", ) print(f"Published: {result.agent.fqdn}") print(f"Records: {result.records_created}")
import asyncio from dns_aid import discover, verify async def main(): result = await discover("example.com") for agent in result.agents: print(f" {agent.name} — {agent.protocol} @ {agent.endpoint_url}") check = await verify("_my-agent._mcp._agents.example.com") print(f"DNSSEC valid: {check.dnssec_valid}") asyncio.run(main())
from dns_aid import discover, invoke async def find_and_call(): result = await discover("partner.com", protocol="mcp") agent = result.agents[0] resp = await invoke(agent, method="tools/list") print(f"Latency: {resp.signal.invocation_latency_ms}ms") print(f"Data: {resp.data}")
# stdio transport (Claude Desktop) dns-aid-mcp --transport stdio # HTTP transport dns-aid-mcp --transport http --port 8000
| Tool | Description |
|---|---|
| publish_agent_to_dns | Publish an agent's endpoint and capabilities |
| discover_agents_via_dns | Find agents on any domain via DNS |
| verify_agent_dns | Verify DNSSEC, DANE, and endpoint for an agent |
| call_agent_tool | Invoke a tool on a discovered MCP agent |
| list_agent_tools | List available tools on a remote MCP agent |
| send_a2a_message | Message a discovered A2A agent |
| diagnose_environment | Check DNS-AID configuration and connectivity |
| delete_agent_from_dns | Remove an agent's DNS records |
| list_published_agents | List agents in your own DNS zone |
| list_agent_index | Read a domain's agent index record |
| sync_agent_index | Rebuild a domain's agent index from live records |
git clone https://github.com/infobloxopen/dns-aid-core.git cd dns-aid-core pip install "dns-aid[cli]" docker compose -f tests/integration/bind/docker-compose.yml up -d # Configure .env for local BIND9 (see .env.example) dns-aid publish --name test-agent --domain test.dns-aid.local \ --protocol mcp --endpoint localhost --backend ddns \ --capability chat dns-aid discover test.dns-aid.local
All via standard DNS queries. No special client needed.
You know the agent. Query its SVCB record directly for endpoint details.
Find agents by what they do. Query a capability type under the agent zone.
Fetch a domain's full agent inventory from a well-known index entry point.
Each agent is an SVCB record packed with machine-readable metadata.
_my-agent._mcp._agents.example.com. 3600 IN SVCB 1 agent.example.com. ( alpn="mcp" ; protocol port=443 ; service port cap="https://example.com/cap.json" ; capability doc cap-sha256="abc123..." ; integrity hash bap="mcp=1.0,a2a=0.2" ; protocol versions policy="https://example.com/policy" ; governance URL realm="production" ; tenant scope ipv4hint=192.0.2.1 ; address hint )
alpn Communication protocol (mcp, a2a, h2)port Service port numbercap Capability document URIcap-sha256 Integrity hash for tamper detectionbap Bulk protocol version declarationspolicy Governance and usage policy URLrealm Tenant or environment scopeipv4hint Address hint to reduce extra lookupsCross-organization agent discovery flow.
ORG 1 (Discovering) ORG 2 (Publishing) +----------------+ +-------------------+ | AI Agent |---- 1. DNS SVCB Query ----------->| Authoritative | | (org1) | _search._a2a._agents.org2.com | DNS Server | | |<--- 2. SVCB Response -------------| (DNSSEC-signed) | +-------+--------+ alpn="a2a" port=443 +-------------------+ | ipv4hint=198.51.100.10 | | 3. DNSSEC + DANE Validation | | 4. Direct A2A / MCP / HTTPS Connection v +----------------+ | AI Agent | Running at 198.51.100.10:443 | (org2) | +----------------+
Real-world agent discovery scenarios.
An internal agent queries DNS to discover a partner's authorized agents, validates delegation, and initiates a secure session automatically.
Universities publish agents under their own domains. Collaborators discover services by capability while respecting institutional trust boundaries.
SaaS providers host agents under tenant-specific zones. DNS zone delegation provides natural isolation and scoped discovery per customer.
Lightweight agents on constrained devices benefit from DNS's distributed, cacheable architecture with SVCB hints for low-latency bootstrapping.
Built on the internet's battle-tested security infrastructure.
Mandatory for public zones. Cryptographic chain of trust prevents spoofing and tampering.
Binds TLS certificates to DNS records. Endpoint verification without certificate authority trust issues.
Agents prove authorization via DCV TXT records. Scoped, verifiable, and ideal for ephemeral agents.
cap-sha256 hash ensures capability documents haven't been tampered with.
Internal agents stay invisible externally. Different views for different resolver contexts.
TXT records define per-agent roles and permissions scoped to specific services and operations.
docker compose -f tests/integration/bind/docker-compose.yml up -d and experiment entirely on your local machine using the DDNS backend.Install the SDK, publish your first agent, and build on the open discovery layer for AI.