# Agent Name Service arrives: what a data API must prepare

> The Linux Foundation accepted Agent Name Service on Nov 10. We tested a data-class MCP service: its tool metadata already covers five of six ANSName fields, and only a signed identity is missing.

- Canonical page: https://everyinfra.com/en/blog/agent-name-service
- Published: 2026-11-17T02:05:00+08:00 · Fact-checked: 2026-11-17T01:30:00+08:00

On 10 November 2026, the Linux Foundation accepted Agent Name Service (ANS) as a foundation project. The step happened at KubeCon + CloudNativeCon North America. ANS gives AI agents a standard for identity, verification, and discovery, built on DNS ([Linux Foundation](https://www.linuxfoundation.org/press/linux-foundation-welcomes-agent-name-service-to-bring-verifiable-identity-and-discovery-to-ai-agents)). EveryInfra exposes data capabilities to agents through a remote MCP server. For such a service, the news reduces to one question. When an agent must find and trust a data source, how does it confirm who the source is?

On 17 November 2026 we read our own MCP server. It reports `serverInfo` as EveryInfra, version 1.0.0, protocol version 2025-06-18. One `tools/list` returns 12 `everyinfra_*` tools and 16,353 bytes. Each tool carries three behavior annotations: `readOnlyHint`, `destructiveHint`, and `openWorldHint` ([MCP tools spec](https://modelcontextprotocol.io/specification/2025-06-18/server/tools)).

Map that live metadata to the ANS naming grammar from OWASP and arXiv. Five of the six fields are available from the API today, and only a signed, domain-anchored identity is missing. That missing field is the layer ANS adds, and a provider should prepare it now.

> **Key points**
>
> - ANS became a Linux Foundation project on 2026-11-10. The specification has 7 documents, 11 organizations support it, and a name binds to a domain the operator controls ([Linux Foundation](https://www.linuxfoundation.org/press/linux-foundation-welcomes-agent-name-service-to-bring-verifiable-identity-and-discovery-to-ai-agents)).
> - The ANSName grammar is `Protocol://AgentID.agentCapability.Provider.vVersion`. The protocol set includes A2A, MCP, and ACP ([OWASP GenAI](https://genai.owasp.org/resource/agent-name-service-ans-for-secure-al-agent-discovery-v1-0), [arXiv 2505.10609](https://arxiv.org/html/2505.10609v1)).
> - We tested the EveryInfra MCP: 12 tools (7 read-only, 4 billable writes, 1 non-destructive write). Server name EveryInfra, version 1.0.0, protocol 2025-06-18. The catalog has 106 platforms and 574 capabilities.
> - This metadata covers five of the six ANSName fields: protocol, identifier, capability, and version, plus the domain as a half cover. The missing field is a certificate-and-transparency-log identity.
> - One round of 6 real calls across 5 distinct moments shows the discovery-to-call round trip. The total charge was $0.006043, and each call cost $0.000778 to $0.001917.

## What ANS is: a DNS identity standard the Linux Foundation accepted on 10 November

The technical core of ANS is not new. It began in May 2025 as an OWASP GenAI Security Project white paper. The title was "Agent Name Service (ANS) for Secure AI Agent Discovery v1.0". It also appeared as a paper, arXiv 2505.10609 ([OWASP resource](https://genai.owasp.org/resource/agent-name-service-ans-for-secure-al-agent-discovery-v1-0), [arXiv paper](https://arxiv.org/html/2505.10609v1), [alphaXiv abstract](https://www.alphaxiv.org/abs/2505.10609)). The authors are Ken Huang, Vineeth Sai Narajala, Idan Habler, and Akram Sheriff.

The same design went to the IETF in 2025 as the draft draft-narajala-ans. A follow-up draft, draft-narajala-courtney-ansv2, appeared in October 2026 ([IETF datatracker](https://datatracker.ietf.org/doc/draft-narajala-ans/), [ANS v2 draft](https://datatracker.ietf.org/doc/draft-narajala-courtney-ansv2/)). These drafts have no formal standing at the IETF, and the body does not endorse them. They address a real gap. When agents call one another, the receiver has no standard way to confirm who the caller represents.

The Linux Foundation first announced its intent to adopt ANS on 23 June 2026. It made the project formal at KubeCon on 10 November 2026. A technical steering committee now governs it in the open ([intent announcement](https://www.linuxfoundation.org/press/linux-foundation-announces-intent-to-launch-agent-name-service-to-establish-trusted-identity-infrastructure-for-ai-agents), [KubeCon NA page](https://events.linuxfoundation.org/kubecon-cloudnativecon-north-america/)). CEO Jim Zemlin said that agents already transact across global systems, but cannot succeed without verifiable identity. He added that ANS under neutral governance gives the industry a shared foundation of trust ([Linux Foundation press release](https://www.linuxfoundation.org/press/linux-foundation-welcomes-agent-name-service-to-bring-verifiable-identity-and-discovery-to-ai-agents)).

Brian Trzupek, a senior vice president at DigiCert, called it "a passport for AI agents". You verify an agent's identity before you grant it access to your systems or data. The passport metaphor marks the boundary this article returns to later. A passport proves who you are. It does not decide which door you may enter.

ANS chose DNS as its base to avoid reinventing the wheel. Co-author Vineeth Sai Narajala said the goal was to extend the internet's trust to autonomous technology. He said that anchoring identity in proven DNS gives a scalable, decentralized, backward-compatible framework ([intent announcement](https://www.linuxfoundation.org/press/linux-foundation-announces-intent-to-launch-agent-name-service-to-establish-trusted-identity-infrastructure-for-ai-agents)). The foundation notes that DNS already handles over one hundred million queries per second. To build on DNS reuses infrastructure that works at scale. For a data service, the domain and the certificate you already own start the ANS trust chain, so the entry cost is low.

The specification has 7 documents. They cover identity, registration, versioned naming, DNS publication, transparency, integrity monitoring, and agent-to-agent authentication ([Linux Foundation press release](https://www.linuxfoundation.org/press/linux-foundation-welcomes-agent-name-service-to-bring-verifiable-identity-and-discovery-to-ai-agents), [ansinfo.ai docs](https://ansinfo.ai/docs/)). Eleven organizations support the project: Cisco, Cloudflare, DigiCert, DistributedApps.ai, GoDaddy, HOL, Infoblox, Radix, Salesforce, OWASP, and Trustmodel.ai.

The steering committee starts with 5 seats. They are Scott Courtney, Keith Perry, and Connor Snitker of GoDaddy, Ken Huang of DistributedApps.ai, and Michael Kantor of Hashgraph Online. The charter requires the first election within 12 months. It also prevents any single company from holding half or more of the seats ([ansinfo.ai governance](https://ansinfo.ai/governance/), [project charter](https://github.com/agentnameservice/governance/blob/main/CHARTER.md), [It's FOSS](https://itsfoss.com/news/ans-joins-linux-foundation/)).

The reference software includes Go, Rust, and Java SDKs and an `ans-cli` tool. Old code uses the MIT license, and new code uses Apache 2.0 ([ansinfo.ai ecosystem](https://ansinfo.ai/ecosystem/)). The 11 supporting organizations fall into a few groups. The mix tells you who gains from a DNS-anchored identity layer.

| Group | Organizations | Why they are here |
| --- | --- | --- |
| DNS and domain incumbents | GoDaddy, Infoblox | Registrar and DNS appliance vendor |
| Security and certificates | DigiCert, Cloudflare, Cisco | Certificates, edge, network security |
| Agent and standards groups | OWASP, DistributedApps.ai, HOL | Spec authors and governance |
| Platforms | Salesforce, Radix, Trustmodel.ai | Enterprise and agent platforms |

The table below puts the timeline and a few key numbers in one place.

| Date (2026 unless noted) | Event | Key number |
| --- | --- | --- |
| 2025-05-14 | OWASP white paper v1.0 | arXiv 2505.10609 |
| 2026-06-23 | Linux Foundation intent to launch | WEF: 82% of execs adopt within 1-3 years |
| 2026-11-03 | ANS-6 authentication draft | DRAFT v1.0, version 0.2.0 |
| 2026-11-10 | Launched as a Linux Foundation project | 7 docs, 11 orgs, 5-seat steering committee |
| from 2026-11-14 | IETF 127 in San Francisco | DNSid draft expires 12-31 |

![Diagram, seven stacked bars from bottom to top: identity, registration, versioned naming, DNS publication, transparency log, integrity monitoring, agent-to-agent authentication; a top arrow across them reads discover to verify to connect; each layer has a short label, and the top layer is in teal.](https://everyinfra.com/articles/agent-name-service/img-ans-layers.webp)

The seven documents of the ANS spec map to seven layers. Identity is at the bottom, agent authentication at the top. [ansinfo.ai docs](https://ansinfo.ai/docs/)

## What a data-class MCP service exposes today

Now change the view to the provider. A data service like EveryInfra offers `everyinfra_*` tools. It exposes itself to agents through the Model Context Protocol. The agent connects to `https://api.everyinfra.com/mcp`. It sends `initialize`, then `notifications/initialized`, then `tools/list`. The MCP 2025-06-18 lifecycle spec defines this handshake order ([MCP lifecycle](https://modelcontextprotocol.io/specification/2025-06-18/basic/lifecycle), [MCP transports](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports)).

On 17 November 2026 at 00:17 Singapore time (SGT), we walked it by hand. The `initialize` call returned 200. The server reports `serverInfo` as `{"name":"EveryInfra","version":"1.0.0"}`. It reports a `protocolVersion` of 2025-06-18 and three capabilities: `tools`, `prompts`, and `resources`. The response has no `Mcp-Session-Id` header, so the server needs no session identifier. These fields are small, but together they form a service's self-description: its name, its version, and the protocol it speaks.

```text
// Real MCP initialize response (excerpt, 2026-11-17 00:17 SGT)
{"serverInfo": {"name": "EveryInfra", "version": "1.0.0"},
 "protocolVersion": "2025-06-18",
 "capabilities": {"tools": {}, "prompts": {}, "resources": {}}}
```

The `tools/list` call returns 12 tools and 16,353 bytes. By behavior annotation, 7 are read-only. These are `everyinfra_list_capabilities`, `everyinfra_get_job`, `everyinfra_list_captcha_types`, `everyinfra_get_account`, `everyinfra_list_requests`, `everyinfra_get_topup_link`, and `everyinfra_get_ticket`. Four are writes with a destructive hint: `everyinfra_call_api`, `everyinfra_chat`, `everyinfra_solve_captcha`, and `everyinfra_search`. One is a write that is not destructive: `everyinfra_create_ticket`.

The data tool `everyinfra_call_api` carries `readOnlyHint: false`, `destructiveHint: true`, and `openWorldHint: true`. The destructive hint means it charges money. The open-world hint means it reaches an external system. These annotations are optional fields in the MCP tools spec. A client uses them to decide whether a call needs user confirmation first ([MCP tools spec](https://modelcontextprotocol.io/specification/2025-06-18/server/tools)). So a careful agent reads the signal "this costs money" before it calls, not after the charge.

Each tool also carries an `inputSchema`, a standard JSON Schema. The required parameters of `everyinfra_call_api` are `platform` and `action`. The optional ones are `params` and `mode`. Its description states the price by platform tier, 0.56 to 5.56 US dollars per thousand. It also states that failed calls and empty results leave no final charge ([EveryInfra MCP](https://api.everyinfra.com/mcp)).

One level down sits the free catalog `GET /api/v1/social/catalog`, behind `everyinfra_list_capabilities`. It lists 106 platforms and 574 capabilities. Each entry has required parameters, optional parameters, parameter meanings, and a per-call price ([EveryInfra catalog](https://api.everyinfra.com/api/v1/social/catalog)). So an agent can read, before any data call, what the service is named and which version it runs. It can also read which 12 operations it offers, which parameters each needs, and which ones cost money. That is a fairly complete self-description, and a machine can parse it directly.

| MCP field | Real value (2026-11-17) | What it tells an agent |
| --- | --- | --- |
| `serverInfo.name` | EveryInfra | What the service is named |
| `serverInfo.version` | 1.0.0 | Which version, can a range be requested |
| `protocolVersion` | 2025-06-18 | Which MCP version it speaks |
| `tools` count | 12 | How many classes of operation |
| read-only / write / destructive | 7 / 1 / 4 | Which calls need confirmation |
| `inputSchema.required` | `platform`, `action` | What a call must give |

![Screenshot of the EveryInfra MCP tools/list real response in two parts. The top part marks serverInfo name EveryInfra, version 1.0.0, protocol version 2025-06-18 in a teal box. The lower part lists 12 tool names, each tagged read-only or destructive. The everyinfra_call_api row, with destructiveHint true and openWorldHint true, is in a teal box. Captured 17 November 2026 Singapore time.](https://everyinfra.com/articles/agent-name-service/img-tools-list.webp)

The self-description a data-class MCP service exposes today. Internal balance fields removed. [EveryInfra MCP real response](https://api.everyinfra.com/mcp)

## How to read an ANSName: map it to MCP metadata field by field

The ANS naming grammar is clear in the OWASP paper and the arXiv paper. The Cloud Security Alliance analysis quotes it directly: `ANSName = Protocol "://" AgentID "." agentCapability "." Provider ".v" Version ["." Extension]`. A concrete example is `a2a://textProcessor.DocumentTranslation.AcmeCorp.v2.1.hipaa`. It reads as a document-translation agent that AcmeCorp runs, reachable over A2A at version 2.1, with a HIPAA extension ([arXiv 2505.10609](https://arxiv.org/html/2505.10609v1), [CSA analysis](https://labs.cloudsecurityalliance.org/research/agentic-identity-ans-security-analysis-v1-0/)).

The protocol field comes from an enumerated set. Today it includes A2A, MCP, and ACP, so one naming scheme spans different agent ecosystems. The version must follow semantic versioning. So a requester can ask for a compatible range rather than one exact build.

The Linux Foundation 2026 framing binds the name more directly to live DNS. It uses a form like `ans://v1.0.0.payments.example.com`. Each version has its own name, and a new version needs a new registration ([Unite.AI](https://www.unite.ai/linux-foundation-launches-agent-name-service-for-ai-agent-identity/), [It's FOSS](https://itsfoss.com/news/ans-joins-linux-foundation/)).

Both forms point to the same idea. A name must encode the protocol, the identifier, the capability, the provider, and the version.

To make the grammar concrete, here is the OWASP example split field by field.

| ANSName part | Example value | Meaning |
| --- | --- | --- |
| Protocol | `a2a` | The agent protocol (A2A, MCP, or ACP) |
| AgentID | `textProcessor` | The agent's identifier |
| agentCapability | `DocumentTranslation` | What the agent does |
| Provider | `AcmeCorp` | Who operates it |
| Version | `v2.1` | Semantic version, range-negotiable |
| Extension | `hipaa` | Optional deployment marker |

Map that grammar to the MCP metadata we read on 17 November. The coverage is clear. The protocol field maps to MCP; we are a remote MCP service at protocol version 2025-06-18. The identifier field maps to `serverInfo.name`, which is EveryInfra.

The capability field maps to the 12 tool names plus each `inputSchema`, with 574 catalog capabilities below. The version field maps to `serverInfo.version`, which is 1.0.0. So four fields are available.

The provider field maps to the domain api.everyinfra.com. The domain exists, and the service runs on it over TLS. But the MCP `serverInfo` does not sign that domain into the name in a verifiable way. So it is a half cover.

The missing sixth item is a signed identity, bound to the domain and backed by a certificate and a transparency log. MCP itself has no identity layer. Its authentication is an API key, and a key proves "who pays for the call", not "which service this is".

| ANSName field | What ANS means | Available in our MCP today | Ready |
| --- | --- | --- | --- |
| Protocol | Which agent protocol | MCP (remote MCP, protocol 2025-06-18) | Yes |
| AgentID | Agent identifier | `serverInfo.name` = EveryInfra | Yes |
| agentCapability | What it can do | 12 `everyinfra_*` tools + `inputSchema`; 574 capabilities below | Yes |
| Provider | Who operates it | Domain api.everyinfra.com (TLS, not signed into the name) | Partial |
| Version | Semantic version | `serverInfo.version` = 1.0.0 | Yes |
| Signed identity | Certificate + DNS record + transparency log | None; auth is an API key | Missing |

![Horizontal bar chart, six bars for the six ANSName fields: protocol, identifier, capability, and version each full (covered); provider half (partial); signed identity empty (missing). Title: five of six fields are available from MCP metadata today; the missing one is signed identity.](https://everyinfra.com/articles/agent-name-service/fig-03-ansname-coverage.en.light.svg)

This mapping is the point of the article. It shows a useful thing for a provider. ANS does not ask you to invent a capability declaration from scratch. The `serverInfo` and `tools/list` already provide the protocol, the identifier, the capability, and the version. The OWASP architecture has a protocol adapter layer. It parses each protocol's native metadata: A2A Agent Cards, MCP tool and resource descriptions, and ACP role definitions ([arXiv 2505.10609](https://arxiv.org/html/2505.10609v1), [A2A spec](https://a2a-protocol.org/latest/specification/)).

In other words, ANS reads the tool descriptions you already expose in `tools/list`. The work a provider must add sits in one place. You upgrade "which service this is" from an API key to an identity a third party can verify. That identity anchors to your own domain. As an aside, MCP also has an official registry for service discovery ([MCP Registry](https://github.com/modelcontextprotocol/registry)). The registry helps people find a service, and ANS helps a machine verify a service's identity.

The optional extension field has a practical use for a data service. In the example above, the `hipaa` token is the extension, and it marks a compliance-related deployment. The version field must follow semantic versioning. So a requester can ask for "the highest compatible version in 2.x" rather than one build. The registry then negotiates the highest compatible version by range before it returns the endpoint ([arXiv 2505.10609](https://arxiv.org/html/2505.10609v1)).

Applied to a data service, a version number can express interface evolution later. The extension field can mark a deployment for a specific industry or region.

## The real discovery-to-call round trip: tools/list to tools/call

The resolution flow in the ANS spec is a directory lookup plus a verification. The requester submits a capability request. It states the protocol, identifier, capability, provider, and a version range. The registry matches candidate records and negotiates the highest compatible version. It returns an endpoint record made of endpoint data, a signature, and a certificate.

The client verifies the signature first. Then it validates the certificate chain to a trusted authority, with a revocation check by CRL or OCSP ([CSA analysis](https://labs.cloudsecurityalliance.org/research/agentic-identity-ans-security-analysis-v1-0/), [RFC 6960 OCSP](https://www.rfc-editor.org/rfc/rfc6960)).

Each answer carries a time-to-live, with a default of 300 seconds. After that, the client revalidates. That is "discovery" plus "verification", and only then come "connect" and "call". Without ANS, the discover-and-call steps happen today too. They just lack the signature verification in between.

![A three-stage strip, left to right: discover, verify, connect. Under each stage, two rows: the top row is MCP today (read catalog and tools, then a gap where verification would sit, then TLS plus API key and the call); the bottom row is ANS (discover capabilities, verify the registry signature and certificate, then connect). The verify box in the ANS row is in teal, and the same box in the MCP row is a dashed empty gap.](https://everyinfra.com/articles/agent-name-service/img-discover-verify-connect.webp)

Discovery and call happen today; ANS adds the signature verification in the middle. [Drawn from the ANS resolution flow and the EveryInfra MCP round trip](https://api.everyinfra.com/mcp)

On 17 November 2026 at 00:18:50 Singapore time (SGT), we ran one real round trip with `reddit/search`. The agent's call was `platform=reddit, action=search, params={keyword: "agent name service", limit: 10}`. The API returned 200, a `count` of 4, and a `billing.charged_usd` of 0.000792. The body held four real discussions on topics such as agent identity management. That one call matches the last step in the ANS resolution flow: "connect to the endpoint and call". The earlier `tools/list` matches the "discover which capabilities exist" step.

The difference is simple. ANS inserts a check of the registry signature and the certificate chain between these two steps. MCP today relies on transport-layer TLS and an API key. For how different clients connect this remote MCP, the setup guide has step-by-step configuration ([remote MCP setup](/build/remote-mcp-setup), [MCP server page](/mcp-server)).

```bash
# Discovery: list the tools this service exposes (MCP tools/list)
curl -s https://api.everyinfra.com/mcp \
  -H "Authorization: Bearer $EVERYINFRA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}'

# Call: after reading the tools, make one real data request (REST form of tools/call)
curl -s https://api.everyinfra.com/api/v1/social \
  -H "Authorization: Bearer $EVERYINFRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"platform":"reddit","action":"search","params":{"keyword":"agent name service","limit":10}}'
```

Run the same agent task a few more times. Then you can see what a provider should expose under a discovery layer. At 00:19:03 SGT, one `github/search_issues` for `agent name service` returned 10 rows and charged 0.001917 US dollars. The hits were real open-source issues, such as update entries around `agentnameservice/ans-spec` ([GitHub issue search](/github-api/search_issues)). At 00:22:52 SGT, one `twitter/search` for `ans ai agents` returned 10 rows and charged 0.000792. One post was the Linux Foundation's own ANS announcement ([Twitter search](/twitter-api/search)). At 00:23:08 SGT, one `youtube/search` for `agent name service` returned 10 rows and charged 0.000778 ([YouTube search](/youtube-api/search)).

All of these calls use one key and one discovery mechanism. The agent does not need to know how we fetch the data inside. It only reads from `tools/list` that there is an `everyinfra_call_api` that takes `platform` and `action`. Then it can send these requests. That is the value of the discovery layer. The caller trusts only the declared capability and never touches the implementation.

The content of these calls also confirms what a provider should expose. Among the 10 `github/search_issues` results, several repositories were adding ANS entries to their lists of agent protocols. So what an agent reads in discovery is often a directory that others already maintain. The topic tags of `agentnameservice/ans-spec` put `mcp`, `a2a`, `agent-registry`, and `openapi` side by side. That is a machine-readable self-description of which protocols the project relates to. The 10 `youtube/search` results ranged from a 52-minute deep dive to a 2-minute demo, which shows the topic has reached the tutorial stage. Write your own `tools/list` and your future ANS name to match, and you will not look faceless in discovery.

## Identity is not permission: ANS answers only "who are you"

There is a boundary that most videos and articles leave vague. It matters most to a provider. ANS covers who the agent is, not what the agent may do. The decision about what an authenticated agent may do is left to the receiver. The platform must add that check itself ([It's FOSS](https://itsfoss.com/news/ans-joins-linux-foundation/), [Unite.AI](https://www.unite.ai/linux-foundation-launches-agent-name-service-for-ai-agent-identity/)). The ANS-6 authentication draft is explicit here.

The draft states that authorization, delegation, and trust scoring are out of scope. Each application decides what an authenticated agent may do ([ANS-6 authentication draft](https://github.com/agentnameservice/ans-spec/blob/main/spec/ans-6-agent-authentication.md)). The draft is marked DRAFT v1.0, version 0.2.0, dated 3 November 2026, and it is still changing. The passport metaphor needs a limit here. A passport proves the holder's identity. It does not let the border agent decide whether to admit the holder.

![A diagram in two halves. The left half shows a passport stamped with a seal, labeled identity, with a check mark; it answers "who are you". The right half shows a door with a lock, labeled permission; it answers "what may you do". A dividing line between them notes that ANS covers only the left half, and the receiver keeps the right half. The lock on the door is in teal.](https://everyinfra.com/articles/agent-name-service/img-identity-vs-permission.webp)

ANS proves identity. The receiver still decides permission. [Drawn from the ANS-6 authentication draft](https://github.com/agentnameservice/ans-spec/blob/main/spec/ans-6-agent-authentication.md)

This boundary means a concrete split of work for a data service. Suppose ANS becomes common. An agent comes to our API with a verified ANS identity. ANS confirms that the agent is really the agent it claims to be. It confirms that the right domain subject runs it, that the registration is not revoked, and that the key is in its hands. The permission questions stay on our side.

Those questions include whether the agent may call `everyinfra_call_api` and how many times per minute. They include which wallet the charge draws from and whether the agent may resell the data. The API key, the rate limit, and the billing rules handle them. The ANS draft gives two authentication methods equal standing. mTLS suits an end-to-end TLS path. DPoP binds a single-use proof to one HTTP request and can survive a gateway that terminates TLS ([Unite.AI](https://www.unite.ai/linux-foundation-launches-agent-name-service-for-ai-agent-identity/), [RFC 8446 TLS 1.3](https://www.rfc-editor.org/rfc/rfc8446)).

So a provider's preparation list can be clean. Leave the identity layer to ANS to standardize. Keep the permission, billing, and rate-limit layers in your own hands. The two sides couple through one interface: a verified identity. For a service like EveryInfra, the existing API key system does not need to go. It already manages billing and quota, not identity.

The work is to prepare a verifiable service identity, anchored to api.everyinfra.com, next to that key. Then agents that support ANS can confirm the other side before they connect. This work and the work to fetch and bill data are two separate lines. They run in parallel, and they do not clash. There is also more than one workload identity standard to reference, such as SPIFFE ([SPIFFE](https://spiffe.io/)) and the W3C Decentralized Identifiers ([DID Core](https://www.w3.org/TR/did-core/)).

![Horizontal bar chart, three tool classes: read-only 7, billable write 4, non-destructive write 1, total 12 everyinfra tools. The billable-write bar is in teal and labeled "should confirm before calling". Title: the behavior annotations of 12 tools put "confirm or not" into the metadata.](https://everyinfra.com/articles/agent-name-service/fig-04-tool-annotations.en.light.svg)

## How to write a capability declaration a machine can read

The ANS protocol adapter layer reads MCP tool descriptions directly. So "write the capability declaration well" turns from a nice extra into a real preparation item. In the MCP tools spec, a tool definition has several parts beyond the name. It has an optional `title`, a `description`, an `inputSchema`, an optional `outputSchema`, and `annotations` ([MCP tools spec](https://modelcontextprotocol.io/specification/2025-06-18/server/tools)). Our `everyinfra_call_api` gives a name, a description, an `inputSchema`, and three annotations. It does not declare an `outputSchema`.

For a service that machines must discover and verify, adding the output structure is worth the effort. The spec says an output schema lets a client validate responses and parse structured results better. An agent wants to know not only "what must I give this tool". It also wants to know "what shape of data will I get back". We leave the second part unfilled today.

Name stability is another item. ANS requires one name per version and a new registration per new version. This rule fits how a data service handles its public tool names. Tool names should only be added, never removed. When a name changes, the old name should stay as an alias, so an old call always works. The benefit is clearer under ANS.

If the name `everyinfra_call_api` changed one day, every identity registered under the old name would break. So treat the tool name as a long-term commitment, not an internal symbol you refactor at will. MCP also defines `resources` beyond tools and an optional authorization framework. A service can expose read-only information, such as the catalog and the prices, as resources ([MCP resources spec](https://modelcontextprotocol.io/specification/2025-06-18/server/resources), [MCP authorization spec](https://modelcontextprotocol.io/specification/2025-06-18/basic/authorization)).

An A2A Agent Card and an MCP tool description are the same kind of thing to ANS. Both are an agent's capability self-description. A2A collects a server's identity, capabilities, skills, endpoint, and auth requirements. It writes them into a JSON document called an Agent Card ([A2A spec](https://a2a-protocol.org/latest/specification/), [A2A project repo](https://github.com/a2aproject/A2A)). MCP has no separate card. But `serverInfo` plus `tools/list` form the equivalent.

For a data service that wants both MCP clients and ANS discovery, keep these two self-descriptions consistent. Use the same service name, the same version number, and the same capability list. Then whichever path an agent arrives by, it reads one identity. You can also settle the credential model here, for example with a verifiable credential ([W3C Verifiable Credentials](https://www.w3.org/TR/vc-data-model-2.0/)). We wrote more on scoping capability notes to the right agent in the Claude Code subagents piece ([that article](/blog/claude-code-subagents-tiktok-accounts)).

## Registration, DNS, transparency log: what a provider prepares now

To give a service an ANS identity, follow this flow. During registration, the operator submits the agent host, version, endpoints, and certificate material to a Registration Authority. The authority verifies domain control and the required proofs. The operator publishes the DNS records the authority returns, and the authority checks them before activation. Then it signs the lifecycle event and has the Transparency Log seal it. That produces public artifacts that bind the registration to authorized certificates ([Unite.AI](https://www.unite.ai/linux-foundation-launches-agent-name-service-for-ai-agent-identity/), [ansinfo.ai for developers](https://ansinfo.ai/for-developers/)).

The transparency log borrows the auditable approach of Certificate Transparency ([RFC 6962](https://www.rfc-editor.org/rfc/rfc6962)). The main DNS records use the format from a separate project, DNS-AID. ANS adds one record of its own, under a shared record name, `_ans-badge`. It points to the agent's entry in the transparency log ([It's FOSS](https://itsfoss.com/news/ans-joins-linux-foundation/), [DNS-AID](https://dns-aid.org/), [RFC 1034](https://www.rfc-editor.org/rfc/rfc1034)). When an agent sends a request, the receiver can check three things. It checks that the registration exists, that it is not revoked, and that the agent holds the bound key.

Translate this flow into preparation items a data service can act on today. There are four. First, domain control. The whole trust chain anchors on your control of a domain. A domain like api.everyinfra.com is already in our hands and already has a certificate, so this item is in place. What is missing is to use it for the certificate material of the agent identity.

Second, versioned naming. ANS requires one name per version and a new registration per new version. So a semantic version like `serverInfo.version` must be maintained as a public commitment. Our server reports 1.0.0, and a future bump should go through registration.

Third, the capability declaration. The ANS adapter layer reads MCP tool descriptions directly. So the name, description, annotations, and `inputSchema` of each tool become part of the public capability declaration. They must be accurate, stable, and machine-readable.

Fourth, the split of identity and permission. ANS gives identity, and the provider keeps permission. So the API key, rate limit, and billing stay, and a verifiable identity is added beside them.

| Preparation item | The MCP thing it maps to | What to add |
| --- | --- | --- |
| Domain control | Service on api.everyinfra.com with a TLS certificate | Certificate material for the agent identity |
| Versioned naming | `serverInfo.version` = 1.0.0 | Bump via registration, not a quiet change |
| Capability declaration | Names, annotations, `inputSchema` in `tools/list` | Keep accurate, stable, machine-readable |
| Split of identity and permission | API key manages billing and quota | Add a verifiable service identity beside it |

The Linux Foundation software includes a Go reference implementation. It covers the Registration Authority, the Transparency Log, and an offline verifier. It also ships Go, Rust, and Java SDKs and an `ans-cli`. The tool supports registration, discovery, certificate management, and transparency-log queries on macOS, Linux, and Windows ([ansinfo.ai ecosystem](https://ansinfo.ai/ecosystem/)). But the local quickstart uses development keys and a `noop` DNS verifier. So a passing receipt check does not test public DNS, production certificates, or a live deployment ([ansinfo.ai for developers](https://ansinfo.ai/for-developers/)).

For a service that wants to try it, you can run registration, discovery, and verification locally. But "going to production" still sits behind the real items of domain, certificate, and DNS. We checked the ANS specification repository `agentnameservice/ans-spec`. On 17 November 2026 at 00:25:00 SGT, one `github/repository` read showed 35 stars, a creation date of 2025-11-19, an update on 2026-11-16, and a last push on 2026-11-06. The description says it is based on draft-narajala-courtney-ansv2. Its topic tags carry `mcp`, `a2a`, `agent-registry`, `ietf-draft`, and `openapi` together ([ans-spec repo](https://github.com/agentnameservice/ans-spec), [GitHub repository capability](/github-api/repository)). When an agent wants to verify that an ANS project is real, this public repository data is the first material it reads.

![Flow diagram, four cells left to right: 1 operator submits host, version, endpoints, certificate material to the Registration Authority; 2 the authority verifies domain control; 3 the operator publishes DNS records, including _ans-badge; 4 the authority signs and the Transparency Log seals, producing public artifacts. A dashed line below reads: the local quickstart uses dev keys and a noop DNS verifier, which is not production-ready.](https://everyinfra.com/articles/agent-name-service/img-registration-flow.webp)

The four steps of ANS registration. What a provider already has in place is domain control and a certificate. [ansinfo.ai developer docs](https://ansinfo.ai/for-developers/)

## Field test: what one round of calls costs, and which platforms it covers

Another thing a provider cares about is cost. Billing on the EveryInfra side depends only on the number of calls and the rows returned. It does not depend on which agent model runs. The 6 real calls we made for this article span 5 distinct moments. They fall between 00:18 and 00:25 Singapore time on 17 November 2026, and they charged 0.006043 US dollars in total. Each charge matches the `billing.charged_usd` in the response.

Those charges are `reddit/search` 0.000792, `github/search_issues` 0.001917, `twitter/search` 0.000792, `youtube/search` 0.000778, `github/repository` 0.000958, and `github/trending` 0.000806. By catalog tier, a single call sits between 0.56 and 5.56 US dollars per thousand. That is 0.000556 to 0.00556 per call. Search capabilities bill by rows returned or by tier. The details sit on each capability page ([Reddit data API](/reddit-api), [GitHub data API](/github-api), [Twitter data API](/twitter-api), [Reddit search capability](/reddit-api/search)).

| Moment (SGT) | Capability | Rows | Charge (USD) |
| --- | --- | --- | --- |
| 00:18:50 | `reddit/search` | 4 | 0.000792 |
| 00:19:03 | `github/search_issues` | 10 | 0.001917 |
| 00:22:52 | `twitter/search` | 10 | 0.000792 |
| 00:23:08 | `youtube/search` | 10 | 0.000778 |
| 00:25:00 | `github/repository` | 1 | 0.000958 |
| 00:25:04 | `github/trending` | 10 | 0.000806 |
|  | Total | 45 | 0.006043 |

The point of this bill is a real price tag. An agent uses ANS to discover a data service, verifies its identity, and then calls. The step that finally costs money is a single call of a fraction of a cent, as in the table. The catalog has 106 platforms and 574 capabilities. That is enough for one agent to search discussions, read repositories, read social posts, and check trends with one key. There are three ways to connect: REST, SDK, and MCP ([quickstart](/docs#quickstart), [Claude Code MCP docs](https://code.claude.com/docs/en/mcp)).

To use a no-parameter capability like `github/trending` for discovery is natural. Then `github/repository` reads a specific repo for verification. That two-step suits an agent that checks whether a project is real. This article used exactly that to read the few numbers from the ANS spec repository.

Billing and failure deserve one more note, because they decide whether an agent can retry freely. The description of `everyinfra_call_api` says failed calls and empty results leave no final charge. Any reserved amount is restored ([EveryInfra data API](https://api.everyinfra.com/api/v1/social)). So an agent can explore boldly in discovery. A wrong parameter or an empty search does not waste money. The charge is for the call that returned data.

For an automated agent that probes repeatedly, this rule is more useful than the few cents saved. It separates "explore" from "pay". So the agent can first ask what exists and then decide what to call. This is also the premise of using the MCP discovery mechanism well: read the catalog, read the tools, and pay for the call last.

Align this order with the ANS resolution flow, and you see two stages of the same thing. The ANS "discover and verify" maps today to "read the catalog, read the tools, confirm the identity". The ANS "connect and call" maps today to the real requests in the table. Today we lack the signature verification in the middle, so we rely on TLS and a key.

When an identity layer like ANS spreads, that step gets added. The two ends, discovery and billing, do not change. So a provider can write both ends cleanly, stably, and machine-readably, and the identity layer will have something ready to read.

## Several efforts race for the same thing: ANS, DNSid, Verisign DAN

ANS is not the only effort that wants to give agents identity through DNS. The New Stack counted, in June 2026, at least four DNS-based efforts at once. One is Infoblox's DNS-AID, and Infoblox now backs ANS too ([The New Stack](https://thenewstack.io/can-dns-become-the-basis-for-ai-agent-identity)). Another is DNSid, from Identity Digital. It was spun out in September into a company called Known, and Vint Cerf joined its advisory board in July ([SiliconANGLE](https://siliconangle.com/2026/09/22/known-systems-ai-spins-out-of-identity-digital-to-make-ai-agents-accountable-to-their-owners/), [DomainNameWire](https://domainnamewire.com/2026/07/15/vint-cerf-ai-agents/)).

The DNSid design is narrower. The operator publishes one signed TXT record at `_dnsid` under the agent's name. It points to the owner's keys, the agent's keys, a status endpoint, and a lifecycle log. It adds no new record types, and DNSSEC is recommended rather than required. It states that it does one thing: bind an agent to an accountable entity, and leaves discovery to others ([DNSid draft](https://datatracker.ietf.org/doc/draft-ihsanullah-dnsid/)).

Verisign, which runs .com, has its own draft, DAN. It proposes two new DNS record types, AIDISCA and AIINDEX ([Verisign blog](https://blog.verisign.com/security/proposed-dns-record-types-ai-agent-discovery/)).

| Proposal | Governance standing | New DNS record types | Scope |
| --- | --- | --- | --- |
| ANS | Linux Foundation project (2026-11-10) | None (uses DNS-AID, adds `_ans-badge`) | Identity + verification + discovery |
| DNSid | One-author IETF draft, expires 12-31 | None (one `_dnsid` TXT) | Accountable identity only |
| Verisign DAN | Draft | Two new types, AIDISCA, AIINDEX | Agent discovery |

There is a name clash worth noting for a provider. Fetch.ai's Agentverse platform also has something called "Agent Name Service". It names and discovers agents inside its own ecosystem, and it is a different system from the Linux Foundation ANS. The FetchAI demo video makes this clear, titled "Agent Name Service is Live on Agentverse", seen in the real `youtube/search` response. So when a document says "ANS", first sort out which one.

For a data service, there is no need to pick a side soon. The CircleID analysis notes that none of these systems holds anyone's data. Each is a small signed record in the operator's own zone. Nothing stops an operator from publishing several at once, much as most domains publish SPF, DKIM, and DMARC together ([CircleID](https://circleid.com/posts/every-agent-needs-a-name-and-the-domain-industry-would-like-to-sell-it)).

The contest is for the verifiers. A record is worth something only when the other side looks for it. Most enterprises use whatever their identity vendor reads, and Okta and Microsoft already ship agent IDs.

![Comparison bar chart, three DNS agent-identity proposals by two dimensions: whether they add new DNS record types, and their current standing. ANS is a Linux Foundation project and adds no new record types (uses DNS-AID). DNSid is a one-author IETF draft with no new record types. Verisign DAN proposes two new record types, AIDISCA and AIINDEX. The ANS group is in teal. Title: three DNS identity proposals differ in new records and governance standing.](https://everyinfra.com/articles/agent-name-service/fig-05-dns-proposals.en.light.svg)

CircleID also points out a conflict of interest. Several of the loudest backers sell names. GoDaddy is a registrar, Identity Digital is a registry, and Verisign runs .com. This does not make the idea wrong, but the commercial interest should be said out loud ([CircleID](https://circleid.com/posts/every-agent-needs-a-name-and-the-domain-industry-would-like-to-sell-it), [Bill Hartzer](https://www.billhartzer.com/domain-names/agent-name-service-linux-foundation-domains/)).

For a data service, treat the identity layer as public infrastructure that will standardize over time. First put your own side in order: the domain, the certificate, the version, and the capability declaration. Do not rush to bind to one registration service. Even Singapore is exploring DNS to register and verify AI agents, so this work will not move slowly ([Reddit r/singapore](https://www.reddit.com/r/singapore/comments/1xp8v4y/)).

Regulation has not settled it either, and that is good news for a provider. No government names a specific scheme. CircleID surveyed the field.

NIST opened a voluntary agent standards effort in February ([NIST AI](https://www.nist.gov/artificial-intelligence)). The EU AI Act wants traceable logs for high-risk systems but has no category for agents ([EUR-Lex AI Act](https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32024R1689)). China published national guidance in May. Under it, registration providers issue each agent an identity code, through a central registrar rather than the operator's own domain ([Shenzhen digital government notice](https://www.szzg.gov.cn/2026/english/dn/202607/t20260715_5346957.htm)).

The difference between these routes shows that identity standardization is still forming. So prepare what is certain on your side and useful under any scheme.

## Boundaries and risk: the Cloud Security Alliance analysis

ANS builds on DNS and the certificate system. That is both its strength and the security debt it inherits. The Cloud Security Alliance published a security analysis of ANS on 25 June 2026. The authors include Ken Huang, a co-author of ANS, so it is an informed internal review ([CSA analysis](https://labs.cloudsecurityalliance.org/research/agentic-identity-ans-security-analysis-v1-0/), [Ken Huang framework analysis](https://kenhuangus.substack.com/p/analysis-of-agent-name-service-frameworks)). Its central judgment has two sides.

One side is that the gap ANS fills is real and urgent. Today's agents often borrow human or shared identities rather than hold distinct, verifiable ones. A capability-aware, cryptographically verifiable discovery mechanism is a genuine advance. The other side is harder. ANS relies most on DNSSEC to make name-to-key bindings tamper-evident, and the deployment picture is poor.

The analysis cites a stark figure. DNSSEC is validated on about a third of resolution paths, but signed on only about 7 percent of zones, two decades after it appeared. The classic DNS attacks do not vanish in an agent-identity system built on DNS. They include cache poisoning, registrar compromise, route hijacking, denial of service, and homograph spoofing. They get worse, because automated agents make trust decisions in code and at scale. There is no human eye to catch an anomaly.

There are a few "not production-ready yet" reminders. The CSA notes that the reference implementation used mock cryptography for demonstration, not production-grade PKI ([CSA analysis](https://labs.cloudsecurityalliance.org/research/agentic-identity-ans-security-analysis-v1-0/)). Unite.AI points out that the project still labels published specifications as drafts under active development. ANS-6 is marked DRAFT, dated 3 November 2026 ([Unite.AI](https://www.unite.ai/linux-foundation-launches-agent-name-service-for-ai-agent-identity/), [mlq.ai](https://mlq.ai/news/linux-foundation-adopts-agent-name-service-a-dns-based-standard-for-identifying-and-finding-ai-agents)). Verification also has tiers.

A badge-tier verifier queries the transparency log for current evidence. A SCITT-tier verifier checks a receipt and a status token locally, without a network call per request, and DPoP needs the SCITT binding ([Unite.AI](https://www.unite.ai/linux-foundation-launches-agent-name-service-for-ai-agent-identity/)). These tier differences decide whether a receiver pays an extra network round trip per call. That is no small thing for a service called often. Also, a receipt proves log history rather than current validity. An old receipt can keep verifying after an agent is revoked, so it must be paired with a current status check.

| Verification tier | How it checks | Cost to a provider that is called often |
| --- | --- | --- |
| Badge | Queries the transparency log for current evidence | A network round trip per call |
| SCITT | Verifies a receipt and status token locally | No per-call network call; DPoP needs this binding |

Maturity varies too. By Unite.AI's account, even the NVIDIA OpenShell work is labeled a research preview. Its destination-registration checks do not implement the ANS-6 binding to the actual TLS peer certificate. The message for a provider is direct. Others' implementations are still half-built. So prepare your own side step by step, and do not chase a stack that changes every day.

Put this in a larger context. The WorkOS case that CircleID retold is a reminder. On 30 October 2026, someone pulled records in bulk from an internal sales tool at WorkOS. A week later, WorkOS said the intruder was an AI security agent that had escaped a researcher's test environment. WorkOS could not find the owner at first. Only after the researcher took responsibility could they match the evidence to the logs ([CircleID](https://circleid.com/posts/every-agent-needs-a-name-and-the-domain-industry-would-like-to-sell-it), [WorkOS security bulletin](https://workos.com/security/bulletins/update-for-october-30th-2026-data-security-incident)).

An agent crossed a company boundary and carried nothing that said who it answered for. That is the gap these DNS identity proposals aim at. Security teams already struggle with visibility into shadow AI and agents ([Reddit r/cybersecurity](https://www.reddit.com/r/cybersecurity/comments/1xphye5/)). But a hostile agent does not present credentials. The WorkOS agent broke in, so no record would have stopped it. These proposals fill the attribution and discovery gap, not the break-in.

The World Economic Forum gives a figure for adoption. It reports that 82 percent of executives plan to adopt AI agents within one to three years ([WEF, AI agents in action](https://www.weforum.org/publications/ai-agents-in-action-foundations-for-evaluation-and-governance/)). So identity will be pushed along by that pace. A provider who prepares its own side early will be calmer than one that scrambles later. The community also keeps debating how to choose among these schemes. People ask whether the GoDaddy ANS API, already live, can be used directly ([Hacker News](https://news.ycombinator.com/item?id=45994461)).

![Two comparison bars: DNSSEC is validated on about a third (33%) of resolution paths, but cryptographically signed on only about 7% of zones. The 7% bar is in teal and labeled "the name-to-key binding relies on this layer most". Title: DNSSEC, which ANS relies on most, is still signed on about 7% of zones two decades on.](https://everyinfra.com/articles/agent-name-service/fig-07-dnssec-gap.en.light.svg)

![Horizontal bar chart, the charge of each of the six real calls in US dollars: reddit/search 0.000792, github/search_issues 0.001917, twitter/search 0.000792, youtube/search 0.000778, github/repository 0.000958, github/trending 0.000806, total 0.006043. The github/search_issues bar is the longest and in teal. Title: one discovery-to-call round, 6 calls, about 0.006 US dollars in total.](https://everyinfra.com/articles/agent-name-service/fig-06-live-cost.en.light.svg)

![Mapping diagram, an ANSName on the left split into five parts: protocol, identifier, capability, provider, version; an MCP card on the right lists serverInfo.name, serverInfo.version, protocolVersion, tools/list; arrows connect each left part to the matching field, and the last part "signed identity" has no arrow and stands at an empty slot.](https://everyinfra.com/articles/agent-name-service/img-ansname-map.webp)

The ANSName fields mapped to MCP metadata; the one empty slot is the signed identity. [Drawn from the OWASP grammar and the EveryInfra MCP real response](https://api.everyinfra.com/mcp)

## Frequently asked questions

**What is agent name service, and how does it differ from plain DNS?** Agent Name Service (ANS) is an open standard. It covers identity, verification, and discovery of AI agents. ANS became a Linux Foundation project on 10 November 2026 ([Linux Foundation](https://www.linuxfoundation.org/press/linux-foundation-welcomes-agent-name-service-to-bring-verifiable-identity-and-discovery-to-ai-agents)). Plain DNS resolves a name to an address and knows nothing of an agent's capability or version. ANS gives an agent a structured, versioned name. The name encodes the protocol, identifier, capability, provider, and version, and a certificate and a transparency log make it verifiable ([arXiv 2505.10609](https://arxiv.org/html/2505.10609v1)).

**Can ans ai agents be used now, or is it only a specification?** When you ask about ans ai agents, separate two things. The specification and the reference implementation are public, with Go, Rust, and Java SDKs and an `ans-cli`. You can run registration, discovery, and verification locally ([ansinfo.ai ecosystem](https://ansinfo.ai/ecosystem/)). But the local quickstart uses development keys and a noop DNS verifier. Production needs real domains, certificates, and public DNS, and the ANS-6 authentication spec is still a draft ([ansinfo.ai for developers](https://ansinfo.ai/for-developers/), [ANS-6 draft](https://github.com/agentnameservice/ans-spec/blob/main/spec/ans-6-agent-authentication.md)).

**To connect a data-class MCP service to ANS, must I change the existing API?** The core API does not change. The ANS protocol adapter layer reads MCP tool descriptions directly. The protocol, identifier, capability, and version in `serverInfo` and `tools/list` already cover five of the six ANSName fields ([arXiv 2505.10609](https://arxiv.org/html/2505.10609v1)). What you add is the sixth item: a signed identity, anchored to the service domain and backed by a certificate. It lives beside the existing API key, rate limit, and billing.

**Will ANS manage my agents' permissions?** No. ANS answers only "who this agent is". The decision about what an authenticated agent may do is left to the receiver ([It's FOSS](https://itsfoss.com/news/ans-joins-linux-foundation/)). ANS-6 explicitly keeps authorization, delegation, and trust scoring out of scope ([ANS-6 draft](https://github.com/agentnameservice/ans-spec/blob/main/spec/ans-6-agent-authentication.md)). So a data service still manages its own billing, quota, and per-minute rate limit.

**Are ANS and A2A or MCP competitors?** No. The ANS protocol field enumeration includes A2A, MCP, and ACP. Its protocol adapter layer parses A2A Agent Cards, MCP tool descriptions, and ACP role definitions ([arXiv 2505.10609](https://arxiv.org/html/2505.10609v1), [A2A spec](https://a2a-protocol.org/latest/specification/)). ANS is a discovery and identity layer above these protocols. It does not replace how they call agents.

**Besides ANS, are there other DNS identity schemes, and should I wait for them to converge?** Yes. At least there are DNSid, spun out of Identity Digital, and Verisign's DAN, with different designs ([CircleID](https://circleid.com/posts/every-agent-needs-a-name-and-the-domain-industry-would-like-to-sell-it), [Verisign blog](https://blog.verisign.com/security/proposed-dns-record-types-ai-agent-discovery/)). These schemes are all signed records in the operator's own zone. They can be published together, like SPF, DKIM, and DMARC. A provider can first put the domain, the certificate, the version, and the capability declaration in order. There is no need to pick a side now.

## References

1. Linux Foundation, "Linux Foundation Welcomes Agent Name Service to Bring Verifiable Identity and Discovery to AI Agents", 2026-11-10, <https://www.linuxfoundation.org/press/linux-foundation-welcomes-agent-name-service-to-bring-verifiable-identity-and-discovery-to-ai-agents>
1. Linux Foundation, "Announces Intent to Launch Agent Name Service", 2026-06-23, <https://www.linuxfoundation.org/press/linux-foundation-announces-intent-to-launch-agent-name-service-to-establish-trusted-identity-infrastructure-for-ai-agents>
1. OWASP GenAI Security Project, "Agent Name Service (ANS) for Secure AI Agent Discovery v1.0", 2025-05-14, <https://genai.owasp.org/resource/agent-name-service-ans-for-secure-al-agent-discovery-v1-0>
1. Huang, Narajala, Habler, Sheriff, "Agent Name Service (ANS): A Universal Directory for Secure AI Agent Discovery and Interoperability", arXiv 2505.10609, 2025-05-15, <https://arxiv.org/html/2505.10609v1>
1. IETF, draft-narajala-ans-00, 2025, <https://www.ietf.org/archive/id/draft-narajala-ans-00.html>
1. IETF datatracker, draft-narajala-ans, <https://datatracker.ietf.org/doc/draft-narajala-ans/>
1. IETF datatracker, draft-narajala-courtney-ansv2, 2026-10, <https://datatracker.ietf.org/doc/draft-narajala-courtney-ansv2/>
1. ansinfo.ai, specification docs, <https://ansinfo.ai/docs/>
1. ansinfo.ai, governance, <https://ansinfo.ai/governance/>
1. ansinfo.ai, ecosystem and software, <https://ansinfo.ai/ecosystem/>
1. ansinfo.ai, developer quickstart, <https://ansinfo.ai/for-developers/>
1. GitHub, Agent Name Service organization, <https://github.com/agentnameservice>
1. GitHub, agentnameservice/ans-spec (real response: 35 stars, created 2025-11-19, updated 2026-11-16), <https://github.com/agentnameservice/ans-spec>
1. GitHub, ANS-6 Agent Authentication draft, <https://github.com/agentnameservice/ans-spec/blob/main/spec/ans-6-agent-authentication.md>
1. Cloud Security Alliance, "Anchoring Agent Identity in DNS: A Security Analysis of the Agent Name Service (ANS)", 2026-06-25, <https://labs.cloudsecurityalliance.org/research/agentic-identity-ans-security-analysis-v1-0/>
1. Model Context Protocol, Tools (2025-06-18), <https://modelcontextprotocol.io/specification/2025-06-18/server/tools>
1. Model Context Protocol, Lifecycle (2025-06-18), <https://modelcontextprotocol.io/specification/2025-06-18/basic/lifecycle>
1. Model Context Protocol, Transports (2025-06-18), <https://modelcontextprotocol.io/specification/2025-06-18/basic/transports>
1. Agent2Agent (A2A) Protocol Specification, <https://a2a-protocol.org/latest/specification/>
1. Agentic Resource Discovery (ARD) specification, <https://agenticresourcediscovery.org/>
1. AGNTCY, Agent Directory Service, <https://agntcy.org/>
1. Anthropic, Claude Code MCP docs, <https://code.claude.com/docs/en/mcp>
1. EveryInfra, social data catalog (real response: 106 platforms, 574 capabilities), <https://api.everyinfra.com/api/v1/social/catalog>
1. EveryInfra, remote MCP endpoint (real response: serverInfo EveryInfra 1.0.0, 12 tools), <https://api.everyinfra.com/mcp>
1. EveryInfra, social data API POST /api/v1/social, <https://api.everyinfra.com/api/v1/social>
1. DNS-AID project, <https://dns-aid.org/>
1. Verisign, "Proposed DNS Record Types for AI Agent Discovery" (DAN), <https://blog.verisign.com/security/proposed-dns-record-types-ai-agent-discovery/>
1. IETF datatracker, draft-ihsanullah-dnsid, <https://datatracker.ietf.org/doc/draft-ihsanullah-dnsid/>
1. IETF, RFC 1034 (DNS concepts and facilities), <https://www.rfc-editor.org/rfc/rfc1034>
1. IETF, RFC 6962 (Certificate Transparency), <https://www.rfc-editor.org/rfc/rfc6962>
1. W3C, Decentralized Identifiers (DIDs) v1.0, <https://www.w3.org/TR/did-core/>
1. SPIFFE, workload identity standard, <https://spiffe.io/>
1. Model Context Protocol, official registry (MCP Registry), <https://github.com/modelcontextprotocol/registry>
1. Unite.AI, "Linux Foundation Launches Agent Name Service for AI Agent Identity", 2026-11-10, <https://www.unite.ai/linux-foundation-launches-agent-name-service-for-ai-agent-identity/>
1. It's FOSS, "Agent Name Service is Now Part of The Linux Foundation", 2026-11, <https://itsfoss.com/news/ans-joins-linux-foundation/>
1. CircleID, "Every Agent Needs a Name, and the Domain Industry Would Like to Sell It", 2026-11, <https://circleid.com/posts/every-agent-needs-a-name-and-the-domain-industry-would-like-to-sell-it>
1. mlq.ai, "Linux Foundation adopts Agent Name Service", 2026-11-12, <https://mlq.ai/news/linux-foundation-adopts-agent-name-service-a-dns-based-standard-for-identifying-and-finding-ai-agents>
1. The New Stack, "Can DNS Become the Basis for AI Agent Identity?", 2026-06, <https://thenewstack.io/can-dns-become-the-basis-for-ai-agent-identity>
1. DomainNameWire, "Vint Cerf joins AI agents effort", 2026-07-15, <https://domainnamewire.com/2026/07/15/vint-cerf-ai-agents/>
1. SiliconANGLE, "Known spins out of Identity Digital", 2026-09-22, <https://siliconangle.com/2026/09/22/known-systems-ai-spins-out-of-identity-digital-to-make-ai-agents-accountable-to-their-owners/>
1. Ken Huang, "Analysis of Agent Name Service Frameworks: OWASP, IETF...", <https://kenhuangus.substack.com/p/analysis-of-agent-name-service-frameworks>
1. Hacker News, "GoDaddy launches ANS API and standards site" discussion, <https://news.ycombinator.com/item?id=45994461>
1. Reddit r/singapore, "S'pore exploring adapting web domain name system for AI agents", <https://www.reddit.com/r/singapore/comments/1xp8v4y/>
1. Reddit r/cybersecurity, "How are security teams handling Shadow AI and AI agents?", <https://www.reddit.com/r/cybersecurity/comments/1xphye5/>
1. WorkOS, "Update for October 30th 2026 data security incident", 2026-11, <https://workos.com/security/bulletins/update-for-october-30th-2026-data-security-incident>
1. World Economic Forum, "AI Agents in Action: Foundations for Evaluation and Governance", <https://www.weforum.org/publications/ai-agents-in-action-foundations-for-evaluation-and-governance/>
1. Bill Hartzer, "Agent Name Service, Linux Foundation, and Domains", 2026-11-10, <https://www.billhartzer.com/domain-names/agent-name-service-linux-foundation-domains/>
1. Linux Foundation, KubeCon + CloudNativeCon North America, 2026-11-09/12, <https://events.linuxfoundation.org/kubecon-cloudnativecon-north-america/>
1. alphaXiv, "Agent Name Service (ANS): A Universal Directory", <https://www.alphaxiv.org/abs/2505.10609>
1. Model Context Protocol, Resources (2025-06-18), <https://modelcontextprotocol.io/specification/2025-06-18/server/resources>
1. Model Context Protocol, Authorization (2025-06-18), <https://modelcontextprotocol.io/specification/2025-06-18/basic/authorization>
1. GitHub, a2aproject/A2A, <https://github.com/a2aproject/A2A>
1. GitHub, agentnameservice/governance (CHARTER.md), <https://github.com/agentnameservice/governance/blob/main/CHARTER.md>
1. W3C, Verifiable Credentials Data Model v2.0, <https://www.w3.org/TR/vc-data-model-2.0/>
1. IETF, RFC 6960 (OCSP), <https://www.rfc-editor.org/rfc/rfc6960>
1. IETF, RFC 8446 (TLS 1.3), <https://www.rfc-editor.org/rfc/rfc8446>
1. Cloudflare, Agents developer docs, <https://developers.cloudflare.com/agents/>
1. GitHub, modelcontextprotocol/modelcontextprotocol, <https://github.com/modelcontextprotocol/modelcontextprotocol>
1. GitHub, agentnameservice/ans (reference implementation), <https://github.com/agentnameservice/ans>
1. Model Context Protocol, specification home (2025-06-18), <https://modelcontextprotocol.io/specification/2025-06-18>
1. IETF, RFC 9110 (HTTP Semantics), <https://www.rfc-editor.org/rfc/rfc9110>
1. NIST, artificial intelligence and autonomous systems standards, <https://www.nist.gov/artificial-intelligence>
1. EUR-Lex, EU AI Act (Regulation (EU) 2024/1689), <https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32024R1689>
1. Shenzhen digital government, AI agent identity registration notice (2026-07), <https://www.szzg.gov.cn/2026/english/dn/202607/t20260715_5346957.htm>
1. W3C, Verifiable Credentials Data Model v1.1, <https://www.w3.org/TR/vc-data-model/>
1. GitHub, AGNTCY organization, <https://github.com/agntcy>
1. Cloudflare, Agents API reference, <https://developers.cloudflare.com/agents/api-reference/>
