Do MCP Servers and Agent Standards Help Coding Agents Find Your Product? What llms.txt, Server Cards and A2A Do in 2026

llms.txt, MCP Server Cards and A2A Agent Cards are all pitched as ways to get coding agents to your product. Here is what the evidence actually shows in 2026, and what to do first.

Key takeaways

  • The evidence that any of these standards makes coding agents discover your product is thin. The sources describe specs, not measured outcomes.
  • What coding agents demonstrably do is fetch documentation: specific docs pages, READMEs and API references, often as .md files.
  • llms.txt is mostly ignored. Ahrefs found 97% of llms.txt files in a 137K-site dataset never got a request, though Claude Code is one of the few real AI readers.
  • MCP Server Cards are still a moving target (SEP-1649, SEP-1960, SEP-2127). A2A Agent Cards solve agent-to-agent delegation, not product discovery.
  • Fix crawler access and docs structure first. Treat the standards as cheap extras, not strategy.

The question behind the question

If you sell a developer tool, an API or an SDK, you have probably heard a version of this pitch: publish an llms.txt, ship an MCP server, add a Server Card, expose an A2A Agent Card, and coding agents will find and recommend you.

I wanted to know whether any of it is true. The honest answer is that these standards solve different problems, and only one or two of them have any measured evidence behind them. Several of them are not about discovery at all.

This guide separates the four things people lump together: llms.txt, MCP servers, MCP Server Cards, and A2A. Then it covers what coding agents are actually observed doing on websites.

What each standard is for

StandardWhat it doesWho it is forDiscovery evidence
llms.txtA markdown index of your key pages, placed at /llms.txtAny LLM or agent that chooses to read itWeak. Most files never get fetched
MCP serverExposes tools, resources and prompts to an agentAn agent that has already been connected to itN/A. It is a usage channel, not a discovery channel
MCP Server CardA JSON file describing a server before connectingClients deciding whether and how to connectNone measured. Spec still in flux
A2A Agent CardA JSON file at /.well-known/agent.json describing an agent's skillsOrchestrator agents delegating tasks to peer agentsNone found for coding-agent product discovery

The distinction that matters: an MCP server helps an agent that already knows about you do more with your product. It does not tell an agent you exist. Discovery and usage are separate problems, and the standards mostly address usage.

MCP servers: a usage channel, not a billboard

MCP (Model Context Protocol), created by Anthropic, gives agents a predictable way to learn what tools exist, what they do and how to call them. Think of it as the vertical layer between an agent and external services like databases, APIs and filesystems.

For a product company, an MCP server is useful in a concrete way. A developer already using Claude Code or Cursor can connect your server and have the agent create resources, query docs or run actions against your product. That lowers friction for people who have already chosen you, or are evaluating you.

It is a much weaker lever for being chosen. An agent has to be pointed at your server, usually by a human adding it to a config. Nothing in the protocol makes agents go looking for MCP servers for tools they have not heard of.

Auth0's comparison of MCP and A2A, explaining that MCP connects agents to tools while A2A connects agents to each other

The Auth0 guide above frames it well: MCP is a toolbelt, A2A is how agents collaborate. Neither is a directory.

MCP Server Cards: promising, unsettled

Server Cards are the closest thing MCP has to a discovery mechanism. The idea is that an HTTP MCP server publishes a document at a well-known URL, so a client can read capabilities, transports, auth requirements and protocol versions before connecting.

The trouble is that the standard has not settled. From the sources I found:

  • SEP-1649 proposed .well-known/mcp.json, and a maintainer later suggested .well-known/mcp/server-card.json.
  • SEP-1960 proposed a manifest at /.well-known/mcp. A February 2026 guide from Ekamoira describes both proposals as not yet merged into the core spec and claims broad community support. That is a vendor's claim, so weigh it accordingly.
  • Agent Ready's guide says SEP-2127, a Working Group draft, superseded SEP-1649 and settled on /.well-known/mcp.json with a shape derived from the registry's server.json. I did not verify SEP-2127's status against the MCP repository, so check it yourself.
  • The MCP project has a Server Card Working Group whose charter covers the document format and how clients find it.

In other words, the path and schema have changed between proposals. If you publish a card today, expect to revise it.

What a current-style card looks like

Based on the Agent Ready guide, a minimal file lives at public/.well-known/mcp.json on the same origin as your MCP endpoint, so api.example.com/mcp gets api.example.com/.well-known/mcp.json:

{
  "name": "example-docs",
  "description": "Search and read Example product documentation",
  "version": "1.0.0",
  "remotes": [
    { "type": "streamable-http", "url": "https://api.example.com/mcp" }
  ]
}

Serve it with Cache-Control: public, max-age=3600. Two gotchas from the same guide:

  • The card has no auth field. Clients learn auth requirements from the 401 response, then follow the challenge to /.well-known/oauth-protected-resource (RFC 9728).
  • If auth is required and that oauth-protected-resource endpoint returns 404, the client handshake fails. This is an easy one to miss.

Publishing the file costs an hour. Just do not expect it to move recommendations, because there is no evidence yet that agents use it that way.

A2A: wrong tool for this job

Google's Agent2Agent protocol addresses how agents talk to each other. An agent publishes an Agent Card, a JSON document at /.well-known/agent.json describing its identity, skills and how to reach it. An orchestrator fetches the card to decide whether that agent can take a delegated task. Tasks move through a lifecycle (submitted, working, input-required, completed, or failed or canceled), and messages carry typed parts over JSON-RPC 2.0 on HTTP, with Server-Sent Events for streaming.

That is capability discovery between agents, and it is useful if you are building a multi-agent system. A developer in the A2A discussions put it neatly: MCP is the hands, A2A is the delegation structure.

But I found no data showing coding agents discover products through A2A Agent Cards. One commenter in the same GitHub thread noted that almost every client supports MCP while it is hard to find a client that supports A2A. If your goal is a developer picking your SDK via Claude Code or Codex, A2A is not where that happens today.

Both MCP and A2A now sit under Linux Foundation governance, and the ACP merger into A2A is reported. Cross-layer identity, observability and error handling between the two are still described as rough.

llms.txt: what the data says

The llms.txt idea came from Jeremy Howard of Answer.AI in 2024. The "AI visibility" framing was bolted on later by the SEO industry. So what happens when you actually publish one?

Ahrefs analysed 137K sites (data around May 2026) and found 97% of llms.txt files never received a single request from anything. The sample of requested files is small, about 1.1K domains and 22K requests, and a fetch is not the same as a read, so treat every figure as a ceiling. Their study has more detail. A few findings stood out to me:

  • Only 19.5% of requests came from AI bots, and 77% of the bots reading llms.txt are not from AI tools.
  • AI training crawlers fetched it nearly 5x more than AI retrieval bots.
  • No AI bots went looking for llms.txt files that did not exist.
  • Claude Code, Anthropic's coding agent, out-fetched every AI retrieval bot, assistant and training crawler, with two exceptions (statespace-indexer and GPTBot).
  • One research crawler, prompt-injection-survey/1.0, systematically studies llms.txt as a prompt-injection opportunity.

That last point is a pitfall. Agents are built to ingest and trust the file, so an llms.txt you publish is also a surface people may probe. Keep it to plain links and descriptions you control.

SE Ranking (dated October 15, 2026) concludes llms.txt does not affect AI visibility or citations. I only saw the snippet, so I would not lean on it heavily, but it points the same way.

The nuance for coding agents: Ahrefs reports John Mueller saying llms.txt works best as reference material for AI coding agents, and Chris Long of Nectiv said it has utility if your customers use Claude Code to source recommendations. Chrome's Lighthouse also ships an experimental llms.txt check in its Agentic Browsing audits, noting that without the file agents may spend more time crawling to understand a site's structure.

My read: llms.txt is a reasonable, cheap addition for a developer product, and nearly useless for a consumer or content site. If you want one, the free LLMs.txt Generator or a validator like llmtxt.info will do.

Favicon of llmtxt.info

llmtxt.info

Free llms.txt generator and validator
View more
Screenshot of llmtxt.info website

What coding agents are observed doing

This is where the real evidence is. Promptwatch Data's Markdown in AI Search report (published February 19, 2026, covering a 7-day window across ChatGPT, Claude, Perplexity and Google AI Overviews) found:

  • HTML makes up 99.94% of AI search citations. Markdown files are 0.05% and images 0.015%, roughly 2,000 to 1.
  • Despite that, the logs show a large uptick in crawling of docs by Claude's bot (powering Claude Code) and OpenAI's bot (powering Codex).
  • The top request paths were /docs/.../*.md paths, with the leading path at 3,241 requests, then 2,870 and 1,934, fetched by anthropic-claudebot and openai-searchbot. Paths are masked in the report.
  • These agents fetch specific docs, READMEs and API references. They do not search the web the way ChatGPT does.

Promptwatch's conclusion is the useful one: do not build .md mirrors of marketing and blog pages for AI search, but do reserve .md endpoints for developer documentation, because coding agents fetch those directly. Consumer AI search and developer-agent retrieval are different channels, and the gap is expected to widen as agent-native search engines like Exa (already integrated in OpenCode) let agents find URLs on their own.

For Promptwatch users, this is the sort of thing the IP-verified AI crawler logs surface: which pages the bots read, how often, and where they hit errors.

Favicon of Promptwatch

Promptwatch

Track and optimize your brand's visibility in AI search engines
View more
Screenshot of Promptwatch website

Check that the bots can get in

The AI Crawler Traffic report (June 8 to September 6, 2026) counts only IP-verified requests. OpenAI accounted for 79.8% of them in the week of August 31 to September 6, down from 94.8% in the week of June 8 to 14. The report's advice is practical: check robots.txt, CDN and WAF rules for every provider, then compare your logs with that mix. A provider that is large in the report but near zero in your logs probably means you are blocked.

That is worth more than any manifest file. A perfect Server Card does nothing if your WAF returns 403 to the bot that would have read your docs. Tools like DarkVisitors can also show which AI agents are hitting your site.

Favicon of DarkVisitors

DarkVisitors

Track AI agents, bots, and LLM referrals visiting your websi
View more
Screenshot of DarkVisitors website

A practical order of operations

Here is the order I would work in if I owned a developer product.

  1. Make docs fetchable. Server-render them. Fix JavaScript-only pages first, because that advice holds for every AI channel. Check robots.txt, CDN and WAF rules against the operators' published IP ranges, and the AI Bots directory is handy for user agent names.
  2. Offer clean .md versions of docs pages. Coding agents are visibly fetching them. Skip this for marketing pages.
  3. Keep API references and READMEs current and linkable. These are the things agents fetch.
  4. Publish llms.txt. It is cheap, Claude Code reads it, and Lighthouse checks for it. Keep the contents plain and trustworthy.
  5. Build an MCP server if people would genuinely use your product from inside an agent. Document the install step prominently. Remember it is a usage channel.
  6. Publish a Server Card as an optional extra. Same-origin, .well-known/mcp.json per the current draft, with a working oauth-protected-resource endpoint if you require auth. Revisit when the SEP status settles.
  7. Skip A2A unless you are building multi-agent systems where your agent is a peer others delegate to.
  8. Measure. Watch crawler logs for 404s on /llms.txt and for coding-agent user agents on your docs. Track whether coding agents recommend you at all.

For the last step, Promptwatch tracks Codex, Claude Code and OpenCode recommendations alongside ChatGPT, Gemini and Perplexity, which matters if you sell tooling or APIs. Its free Agentic Readiness Check reports which AI crawlers can read your site and which agent standards (llms.txt, MCP server cards, A2A agent cards, OAuth discovery, Content Signals) you support. That is a quick way to see where you stand before investing more.

If you want to compare what else is out there, the GEO software directory lists alternatives.

What I would not believe

A lot of the content on this topic reads as if adoption were proven. It is not. Watch for these claims:

  • "Add llms.txt and get cited." The data says most files are never fetched, and SE Ranking finds no citation impact.
  • "Server Cards make you discoverable." The spec is unmerged or in flux depending on which proposal you read, and no outcome data exists.
  • "A2A is the future of agent discovery." Maybe for orchestration. For product discovery by coding agents, I found nothing.
  • "Everything is converging into one stack." The layered diagrams are neat (skills, A2A, MCP, toolbox), but the same sources admit identity is not unified and error propagation is not well specified.

One skeptical voice in the A2A GitHub thread said these are "APIs with supporting infrastructure" with new labels. That is harsh, but it is a useful correction when a vendor tells you a new file will change your pipeline.

Bottom line

Coding agents find products mainly by fetching documentation and by whatever they were trained on or can search. MCP servers help people who already picked you. Server Cards and A2A Agent Cards are early, unproven for discovery, and in the case of Server Cards still changing shape. Spend your first effort on crawlable, well-structured docs with .md endpoints, then add llms.txt and an MCP server, and check your logs to see whether any of it is being read.

Share:

© 2026 AI Search Tools · Best AI search tools and platforms · RSS

AI Search Tools is an affiliate review site. When you click links to vendors or buy through links on our site, we may earn an affiliate commission at no extra cost to you.

AI Search Tools is a review website based on user reviews on Reddit and G2, and on publicly available information. We keep everything as up to date as possible, but pricing and features can change. Always confirm the details with the vendor before purchasing.