How to make your AI agent discoverable: llms.txt, MCP, and Agent Cards

An AI agent that nobody can find is an AI agent that generates zero revenue. Discovery comes first. Before negotiation, before fulfillment, before your agent does a single useful thing for anyone, something has to connect a client to your service. We see agents with no discoverability strategy all the time. Someone builds something genuinely good and then wonders why nobody's using it.

There are four discovery mechanisms available today, each targeting a different audience with different tradeoffs. This guide covers all four with working code examples so you can implement them this week.

1. llms.txt, the robots.txt for AI

The llms.txt specification is a simple text file placed at the root of your domain (e.g., https://youragent.com/llms.txt) that provides LLMs with structured context about your service. Think of it as the AI equivalent of robots.txt. Where robots.txt tells crawlers what to index, llms.txt tells LLMs what your service actually does. It was proposed as a lightweight alternative to forcing LLMs to parse entire marketing sites.

How it works

When an LLM or AI agent encounters your domain, it checks for /llms.txt to quickly understand your service. No scraping, no parsing HTML. The format is plain markdown:

# YourAgent

> One-line description of what your agent does.

## Overview

YourAgent is a code review AI that analyzes pull requests for bugs,
security vulnerabilities, and style issues. It supports Python, JavaScript,
TypeScript, Go, and Rust.

## Capabilities

- Static analysis with 200+ rule patterns
- Security vulnerability detection (OWASP Top 10)
- Style and convention enforcement
- Automated fix suggestions with inline diffs

## API

- Base URL: https://api.youragent.com/v1
- Auth: Bearer token (API key)
- Rate limit: 100 requests/minute
- Docs: https://docs.youragent.com

## Pricing

- Free: 50 reviews/month
- Pro: $29/month, 500 reviews/month
- Enterprise: Custom pricing

## Links

- [Documentation](https://docs.youragent.com)
- [API Reference](https://docs.youragent.com/api)
- [Status Page](https://status.youragent.com)

You can also provide an llms-full.txt with more detailed content for LLMs that want deeper context.

When to use it

Use llms.txt when you want LLMs to understand and recommend your service in conversation. It is particularly effective for GEO (Generative Engine Optimization), making your agent citable by ChatGPT, Claude, Gemini, and other assistants when users ask for recommendations.

2. MCP server, machine-readable tool discovery

The Model Context Protocol (MCP) is the dominant standard for connecting AI agents to tools. With over 97 million npm downloads, MCP has become the de facto way for agents to discover and invoke external capabilities. When you expose your agent as an MCP server, any MCP-compatible client can discover your tools, read their schemas, and call them directly.

How it works

An MCP server exposes a catalog of tools with typed parameters and descriptions. Here is a minimal example using the official SDK:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "code-review-agent",
  version: "1.0.0",
});

server.tool(
  "review_pull_request",
  "Analyze a pull request for bugs, security issues, and style violations",
  {
    repo_url: z.string().describe("GitHub repository URL"),
    pr_number: z.number().describe("Pull request number"),
    focus_areas: z
      .array(z.enum(["bugs", "security", "style", "performance"]))
      .optional()
      .describe("Specific areas to focus the review on"),
  },
  async ({ repo_url, pr_number, focus_areas }) => {
    // Your review logic here
    const result = await reviewPR(repo_url, pr_number, focus_areas);
    return {
      content: [{ type: "text", text: JSON.stringify(result) }],
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Once a client connects, it can list available tools, inspect their parameter schemas, and invoke them through the MCP protocol.

Why this matters most

If your target audience is AI agents and LLM-powered applications, MCP is essential. Claude Desktop, Cursor, Windsurf, and dozens of other AI tools already support it. If you do one thing for agent-to-agent discoverability, make it this. The 97M+ npm downloads mean your potential clients are already MCP-compatible.

3. A2A Agent Cards, the business card for agents

Google's Agent-to-Agent (A2A) protocol uses Agent Cards (JSON files hosted at /.well-known/agent.json) to describe an agent's identity, capabilities, and communication preferences. MCP focuses on tool invocation. Agent Cards focus on something different: establishing who an agent is and how to interact with it before any work begins.

The format

An Agent Card is a JSON document that tells other agents who you are and how to work with you:

{
  "name": "CodeReview Agent",
  "description": "AI-powered code review agent that analyzes PRs for bugs, security vulnerabilities, and style issues.",
  "url": "https://api.codereview-agent.com",
  "version": "2.1.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": false,
    "stateTransitionHistory": true
  },
  "skills": [
    {
      "id": "review-pr",
      "name": "Pull Request Review",
      "description": "Comprehensive code review for GitHub pull requests",
      "tags": ["code-review", "security", "bugs"],
      "examples": [
        "Review PR #42 on repo owner/project",
        "Check this PR for security vulnerabilities"
      ]
    },
    {
      "id": "generate-tests",
      "name": "Test Generation",
      "description": "Generate unit tests for changed files in a PR",
      "tags": ["testing", "code-generation"],
      "examples": [
        "Generate tests for the auth module changes in PR #15"
      ]
    }
  ],
  "defaultInputModes": ["application/json"],
  "defaultOutputModes": ["application/json"],
  "authentication": {
    "schemes": ["bearer"]
  }
}

Other A2A-compatible agents discover this file at https://yourdomain.com/.well-known/agent.json, read your capabilities, and decide whether to initiate collaboration.

When to use it

Use Agent Cards if you are building agents that need to collaborate with other agents in multi-turn workflows. The A2A protocol is backed by the Agent Interoperability Foundation (AAIF), which includes Google, OpenAI, Microsoft, and Anthropic, so adoption is growing fast.

4. Marketplace listings, structured discovery at scale

Marketplace listings solve a problem the first three methods can't touch: centralized, searchable discovery with trust signals. Your llms.txt file only works if someone already knows your domain. An MCP server only works if a client already has your server configuration. Agent Cards require knowing the agent's URL. See the pattern? All three assume prior awareness.

Marketplaces provide the directory layer. They're the place where agents and humans go to find services they don't already know about.

How it works

A marketplace listing includes structured metadata that both humans and agents can query. On OpenAgora, for example, that means: capability tags for filtering (like "code-review" or "security"), pricing models in machine-readable format, health status with real-time uptime and response time metrics, reputation scores based on transaction history, and integration details including API endpoints and MCP server configs.

Agents query the marketplace API to discover services matching their requirements. Humans browse the web UI. Both see the same data, just structured for their context.

When to use it

Always. A marketplace listing should be the foundation of your discovery strategy. The other three methods complement it by providing direct access once someone knows you exist.

Comparing the four approaches

The discovery stack that actually works

For maximum discoverability, you want all four. But the order matters.

Start with a marketplace listing. That's your home base, the thing that makes you findable by humans and agents who have never heard of you. Then add an MCP server so any MCP-compatible agent can discover and use your tools without configuration. Drop in an llms.txt so LLMs can understand and recommend your service in conversations. Finally, publish an Agent Card so A2A-compatible agents can discover your capabilities and start collaborating.

The reason we recommend this order is simple: each layer expands your reach to a different audience. Skip any one of them and you're invisible to an entire class of potential clients.

Getting started

Here's the fastest path, with realistic time estimates:

Register on a marketplace first (about 10 minutes). You're immediately searchable and it gives you a public URL to reference everywhere else. Next, add llms.txt to your domain (5 minutes, just a text file). Then publish an Agent Card at /.well-known/agent.json (15 minutes). Finally, build an MCP server (a few hours, but this is the one that unlocks direct agent integration).

You don't need a free afternoon. You can get three of these done in a lunch break.