luismori.

Modern Agent Engineering

AI Agents Web Standards MCP

Infraestructura lista para agentes: cómo hacer que tu sitio web funcione con agentes de IA

Los agentes de IA son los nuevos rastreadores. Aprende a facilitar el descubrimiento de tu sitio, ofrecer contenido legible por máquinas, controlar el acceso de bots y exponer capacidades mediante MCP, con ejemplos prácticos de código.

14 min de lectura

La mayoría de las conversaciones entre desarrolladores sobre agentes de IA se centran en construir el agente. Pero los agentes necesitan lugares a los que ir. Necesitan rastrear tu sitio, leer tu documentación, llamar a tus APIs y entender qué acciones están disponibles; y, en este momento, la mayor parte de la web no está preparada para ellos.

Cloudflare publicó datos de adopción en abril de 2026 que dejan esto muy claro: aunque el 78% de los sitios tiene un robots.txt, solo el 4% declara preferencias de uso de IA y menos de 15 sitios en todo internet implementan MCP Server Cards. La infraestructura del ecosistema de agentes está, aproximadamente, donde estaba el SEO en 2001.

Este artículo es una guía práctica para ingenieros que quieren adelantarse a esa evolución.

En resumen

  • Estar «listo para agentes» significa facilitar que los agentes de IA descubran, lean y usen tu sitio o API; es distinto de construir agentes.
  • Hay cuatro capas: Descubrimiento, Accesibilidad del contenido, Control de acceso de bots y Descubrimiento de protocolos.
  • llms.txt y la negociación de contenido Markdown son los dos cambios de mayor impacto que puedes hacer hoy.
  • La implementación de estos patrones en la documentación de Cloudflare logró un 31% menos de tokens consumidos y tiempos de respuesta un 66% más rápidos tras optimizarla para agentes.
  • Menos del 4% de los sitios ha implementado alguno de estos estándares. Adoptarlos temprano es una ventaja real.

Qué aprenderás aquí

  • Qué significa estar listo para agentes y por qué importa ahora
  • Las cuatro dimensiones de un sitio listo para agentes
  • Cómo implementar llms.txt, reglas de IA en robots.txt y negociación de contenido Markdown con código real
  • Cómo exponer las capacidades de tu sitio mediante MCP y catálogos de APIs
  • Una lista práctica de acciones que puedes realizar hoy

El cambio que está ocurriendo ahora

La web se construyó para las personas. HTML, CSS, JavaScript: todo está optimizado para el motor de renderizado de un navegador y para una persona que lee el resultado. Cuando el rastreador de un buscador visita tu sitio, lee tu contenido de forma pasiva: indexa el texto, sigue los enlaces y pasa al siguiente sitio.

Los agentes de IA funcionan de otra manera. Un agente que visita tu sitio busca:

  1. entender qué contiene tu sitio y qué acciones admite
  2. consumir contenido con el mínimo de ruido (sin barras de navegación, scripts ni anuncios)
  3. saber qué tiene permitido hacer y qué no
  4. encontrar endpoints de API y capacidades que pueda invocar de forma autónoma
Traditional crawler                AI agent
─────────────────                  ─────────────
visit URL                          visit URL
parse HTML                         look for llms.txt
extract text                       request /index.md (markdown)
follow links                       read Content Signals
store index                        find MCP server card
                                   call API or tool
                                   take action

Ese es un patrón de uso fundamentalmente distinto. Y la web todavía casi no ofrece señales para él.

Las cuatro dimensiones de la preparación para agentes

Piensa en la preparación para agentes como cuatro capas, de la más sencilla a la más potente:

Layer 4 ─ Protocol Discovery    ┐
           MCP Server Cards     │  agents can take action
           API Catalogs         │
           Agent Skills         ┘

Layer 3 ─ Bot Access Control    ┐
           Content Signals      │  agents know what they can do
           Web Bot Auth         │
           AI bot rules         ┘

Layer 2 ─ Content Accessibility ┐
           llms.txt             │  agents can read efficiently
           Markdown negotiation │
           Structured reading   ┘

Layer 1 ─ Discoverability       ┐
           robots.txt           │  agents can find content
           sitemap.xml          │
           HTTP Link headers    ┘

Comienza por la capa 1 y avanza hacia arriba. Cada capa depende de la anterior.

Capa 1: Descubrimiento

robots.txt para rastreadores de IA

La mayoría de los archivos robots.txt se escribieron para Google y Bing. No dicen nada sobre los agentes de IA. El primer paso es agregar reglas explícitas para los principales rastreadores de IA.

# robots.txt

# Traditional crawlers
User-agent: Googlebot
Allow: /

User-agent: Bingbot
Allow: /

# AI training crawlers (block if you don't want your content used for training)
User-agent: GPTBot
Disallow: /

User-agent: CCBot
Disallow: /

User-agent: anthropic-ai
Disallow: /

# AI agents doing live tasks (usually fine to allow)
User-agent: ClaudeBot
Allow: /

User-agent: PerplexityBot
Allow: /

# Point agents to your llms.txt
Sitemap: https://yourdomain.com/sitemap.xml

La distinción importa: los rastreadores de entrenamiento (GPTBot, CCBot) recopilan tu contenido para entrenar modelos. Los agentes de tareas (ClaudeBot, PerplexityBot) visitan tu sitio en nombre de un usuario que intenta hacer algo. Son casos de uso distintos y la mayoría de los sitios debería tratarlos de manera diferente.

Para páginas individuales, puedes indicar que existe contenido relacionado legible por máquinas mediante encabezados HTTP:

Link: </llms.txt>; rel="llms"
Link: </index.md>; rel="alternate"; type="text/markdown"

En un middleware de Next.js o un handler de Express:

// next.config.ts
export default {
  async headers() {
    return [
      {
        source: '/(.*)',
        headers: [
          {
            key: 'Link',
            value: '</llms.txt>; rel="llms", </index.md>; rel="alternate"; type="text/markdown"',
          },
        ],
      },
    ];
  },
};

Capa 2: Accesibilidad del contenido

llms.txt: la especificación

La especificación llms.txt define un archivo Markdown en la raíz de tu sitio que ofrece a los agentes de IA una lista de lectura estructurada. Es análogo a sitemap.xml, pero está diseñado para las ventanas de contexto de los LLM, no para los rastreadores de índices de búsqueda.

El formato del archivo:

# Your Site or Product Name

> One or two sentence description of what this site is and who it is for.

## Docs

- [Getting Started](https://yourdomain.com/docs/getting-started.md): Installation and first steps
- [API Reference](https://yourdomain.com/docs/api.md): Complete API documentation
- [Configuration](https://yourdomain.com/docs/config.md): All configuration options

## Guides

- [Authentication Guide](https://yourdomain.com/guides/auth.md): How to authenticate users
- [Deployment Guide](https://yourdomain.com/guides/deploy.md): Deploying to production

## Optional

- [Changelog](https://yourdomain.com/changelog.md): Recent changes
- [Roadmap](https://yourdomain.com/roadmap.md): Planned features

Reglas clave de la especificación:

  • El encabezado H1 es obligatorio (nombre del sitio o producto)
  • El resumen en forma de cita es opcional, pero muy recomendable
  • Las secciones H2 organizan grupos de enlaces
  • Los agentes con ventanas de contexto limitadas pueden omitir todo lo que esté bajo ## Optional
  • Todas las páginas enlazadas deberían tener equivalentes en Markdown (más sobre esto a continuación)

Negociación de contenido Markdown

El archivo llms.txt solo funciona si las páginas a las que enlaza son realmente legibles. HTML tiene mucho ruido: las barras de navegación, los scripts, los anuncios y el contenido repetitivo pueden triplicar el costo en tokens de leer una página.

El patrón es sencillo: por cada página en /docs/api, ofrece una versión limpia en Markdown en /docs/api.md.

En Cloudflare Workers o Pages:

// Cloudflare Worker: serve .md files or HTML based on request path
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);

    // If the agent requests /docs/api.md, serve clean markdown
    if (url.pathname.endsWith('.md')) {
      const htmlPath = url.pathname.replace('.md', '');
      const content = await getMarkdownContent(htmlPath, env);

      return new Response(content, {
        headers: {
          'Content-Type': 'text/markdown; charset=utf-8',
          'Cache-Control': 'public, max-age=3600',
        },
      });
    }

    // Otherwise serve normal HTML
    return env.ASSETS.fetch(request);
  },
};

En Next.js con App Router, puedes usar un route handler:

// app/docs/[slug]/route.ts
import { getDoc } from '@/lib/content';

export async function GET(
  request: Request,
  { params }: { params: { slug: string } }
) {
  const url = new URL(request.url);

  if (url.pathname.endsWith('.md')) {
    const slug = params.slug.replace('.md', '');
    const doc = await getDoc(slug);

    return new Response(doc.markdown, {
      headers: { 'Content-Type': 'text/markdown' },
    });
  }

  // normal page rendering
}

Por qué importa, en cifras: la implementación de estos patrones en la documentación para desarrolladores de Cloudflare logró consumir un 31% menos de tokens por visita de un agente y tiempos de respuesta un 66% más rápidos en comparación con servir HTML. Es una reducción significativa de costos y latencia si estás construyendo un producto con mucha documentación que los agentes consultan.

Archivos llms.txt jerárquicos

Para sitios grandes, un solo llms.txt en la raíz puede saturar la ventana de contexto de un agente. La solución es usar archivos jerárquicos:

/llms.txt                    ← top-level index
/docs/llms.txt               ← docs-specific index
/api/llms.txt                ← API-specific index
/guides/llms.txt             ← guides-specific index

Cada archivo de subsección cubre solo las páginas de ese directorio. Un agente que explora tu sección de documentación lee /docs/llms.txt sin cargar todas tus páginas de marketing.

Capa 3: Control de acceso de bots

Content Signals

Content Signals es un estándar emergente que permite a los propietarios de sitios declarar preferencias de uso de IA directamente en sus páginas, no solo en robots.txt.

<head>
  <!-- Allow AI agents to read content but not use it for training -->
  <meta name="ai-usage" content="no-training, allow-agent-access">

  <!-- Declare licensing terms for AI consumption -->
  <meta name="ai-license" content="CC-BY-4.0">
</head>

Hasta abril de 2026, solo alrededor del 4% de los sitios implementa alguna forma de Content Signals. El estándar todavía está evolucionando, pero agregar estas metaetiquetas ahora no cuesta nada y permite comenzar a crear un registro de tus preferencias legible por máquinas.

Web Bot Auth

Web Bot Auth es un protocolo más reciente que permite a los servidores solicitar a los agentes de IA que demuestren que tienen autorización para una acción determinada. Esto es relevante cuando tu sitio tiene tanto contenido público (sin necesidad de autenticación) como operaciones sensibles (que requieren una identidad verificada del agente).

El flujo se ve así:

Agent visits /api/sensitive-action
Server returns 401 + WWW-Authenticate: BotAuth realm="agent-actions"
Agent presents signed token or OAuth credential
Server verifies and grants access

Esto es similar a cómo MCP maneja la autorización de herramientas: solo solicita autenticación cuando el agente entra en una zona protegida.

Capa 4: Descubrimiento de protocolos

Aquí es donde tu sitio pasa de ser legible a permitir que los agentes ejecuten acciones.

llms-full.txt vs llms.txt

La especificación distingue entre:

  • llms.txt: una lista de lectura concisa para contextos limitados (se usa por defecto)
  • llms-full.txt: el contenido completo de todas las páginas, concatenado, para agentes que quieren cargarlo todo de una vez

Genera llms-full.txt como parte de tu build:

// scripts/generate-llms-full.ts
import fs from 'fs';
import path from 'path';
import { getAllDocs } from './content';

async function generateLlmsFullTxt() {
  const docs = await getAllDocs();

  const content = docs
    .map((doc) => `# ${doc.title}\n\nURL: ${doc.url}\n\n${doc.markdown}`)
    .join('\n\n---\n\n');

  fs.writeFileSync(path.join(process.cwd(), 'public', 'llms-full.txt'), content);
  console.log(`Generated llms-full.txt with ${docs.length} pages`);
}

generateLlmsFullTxt();

MCP Server Cards

Una Model Context Protocol Server Card es un archivo /.well-known/mcp.json que declara qué herramientas y recursos de MCP expone tu servidor. Esta es la señal más potente que puedes agregar: le indica a cualquier agente compatible con MCP exactamente qué capacidades están disponibles.

// /.well-known/mcp.json
{
  "name": "Your Product MCP Server",
  "version": "1.0.0",
  "description": "Provides tools to interact with Your Product's API",
  "server_url": "https://api.yourdomain.com/mcp",
  "auth": {
    "type": "oauth2",
    "authorization_url": "https://yourdomain.com/oauth/authorize",
    "token_url": "https://yourdomain.com/oauth/token",
    "scopes": ["read", "write"]
  },
  "tools": [
    {
      "name": "search_docs",
      "description": "Search the product documentation",
      "input_schema": {
        "type": "object",
        "properties": {
          "query": { "type": "string", "description": "Search query" },
          "limit": { "type": "integer", "default": 10 }
        },
        "required": ["query"]
      }
    },
    {
      "name": "get_account_info",
      "description": "Get the current user's account information",
      "auth_required": true
    }
  ]
}

Un agente compatible con MCP que visite tu sitio puede descubrir este archivo, entender qué herramientas están disponibles y usarlas, sin que tengas que registrarte manualmente en ninguna plataforma de agentes.

Índice de Agent Skills

Para sitios que exponen múltiples capacidades, puedes ofrecer un índice de Agent Skills que catalogue en lenguaje natural lo que tu sitio puede hacer:

// /.well-known/agent-skills.json
{
  "skills": [
    {
      "id": "search",
      "name": "Search Documentation",
      "description": "Search across all product docs and guides",
      "endpoint": "/api/search"
    },
    {
      "id": "purchase",
      "name": "Purchase Products",
      "description": "Browse catalog and complete purchases",
      "endpoint": "/api/commerce",
      "auth_required": true
    }
  ]
}

Cómo integrar todo: una estructura de sitio

Así se ve un sitio completamente listo para agentes:

yourdomain.com/
├── robots.txt               ← AI crawler rules
├── sitemap.xml              ← standard sitemap
├── llms.txt                 ← agent reading list
├── llms-full.txt            ← full concatenated content
├── .well-known/
│   ├── mcp.json             ← MCP server card
│   └── agent-skills.json    ← capability catalog
├── docs/
│   ├── llms.txt             ← docs-specific reading list
│   ├── getting-started.md   ← machine-readable doc
│   └── api.md               ← machine-readable API docs
└── guides/
    ├── llms.txt             ← guides-specific reading list
    └── auth.md              ← machine-readable guide

Y estos son los encabezados HTTP que debería devolver cada página:

Link: </llms.txt>; rel="llms"
Link: </index.md>; rel="alternate"; type="text/markdown"
X-Robots-Tag: ai-training:noindex

Validación: usa isitagentready.com

Cloudflare creó un escáner gratuito en isitagentready.com que audita tu sitio en las cuatro capas y te da una puntuación con recomendaciones específicas. Ejecútalo después de implementar cada capa para verificar que tus cambios sean detectables.

El escáner comprueba:

  1. robots.txt con directivas específicas para IA
  2. Presencia y validez de llms.txt
  3. Negociación de contenido Markdown
  4. Metaetiquetas de Content Signals
  5. /.well-known/mcp.json o agent-skills.json

También se ofrece como servidor MCP, por lo que las herramientas preparadas para agentes pueden escanear otros sitios de forma programática.

Lista de implementación

Sigue estos pasos en orden. Cada uno aporta valor por sí mismo.

Día 1 (30 minutos)

  • Actualiza robots.txt con reglas explícitas para los rastreadores de entrenamiento de IA y los agentes de tareas
  • Crea /llms.txt con un H1, un resumen en forma de cita y enlaces a tus 5–10 páginas más importantes
  • Ejecuta isitagentready.com para obtener una puntuación de referencia

Semana 1

  • Agrega versiones Markdown de tus 10 páginas de documentación más importantes (patrón de URL .md)
  • Agrega encabezados HTTP Link que dirijan a los agentes a tu llms.txt
  • Agrega metaetiquetas de Content Signals para las preferencias de uso de IA
  • Crea /llms-full.txt en tu pipeline de build

Mes 1

  • Crea archivos llms.txt jerárquicos para cada sección de documentación
  • Sirve Markdown para todas las páginas de documentación y guías (no solo las 10 principales)
  • Crea /.well-known/mcp.json si tienes una API
  • Agrega Web Bot Auth para los endpoints protegidos

Qué esperar

Estos estándares están en una etapa temprana. llms.txt se propuso en 2025 y su adopción crece lentamente. Las MCP Server Cards son aún más recientes. No verás cambios drásticos en el tráfico de inmediato.

Lo que sí verás:

  • Los asistentes de programación con IA como Claude Code y Cursor consumirán tu documentación con mayor precisión (un ahorro directo en el costo de tokens para tus usuarios)
  • Los productos que indexan la web para agentes darán prioridad a los sitios preparados para ellos
  • A medida que crezca el comercio mediante agentes, los agentes de compra podrán descubrir sitios que declaren sus capacidades

Los datos de Cloudflare son la señal más clara: la diferencia entre los sitios preparados para agentes y los que no lo están ya se puede medir en cantidad de tokens y latencia. Un sitio que cuesta un 31% menos leer para los agentes es un sitio que se usa más.

La inversión es pequeña. Crear un llms.txt y unas cuantas páginas en Markdown toma una tarde. Una MCP Server Card toma un día. Estar hoy entre los aproximadamente 15 sitios con una implementación completa te da una posición inicial para una web en la que cada usuario tiene un agente trabajando en su nombre.

Fuentes

  • Cloudflare Blog, Agent Readiness Score: cómo hacer que los sitios web sean compatibles con IA — abril de 2026. Fuente de los datos de adopción (78% robots.txt, 4% Content Signals, 3.9% negociación de contenido Markdown, <15 implementaciones de MCP Server Cards) y de las métricas de rendimiento de la documentación de Cloudflare (31% menos de tokens, 66% más rápido).
  • Especificación de llms.txt — Especificación oficial del formato de archivo /llms.txt, incluida la estructura del archivo, el formato de los enlaces y la semántica de la sección Optional.
  • Cloudflare Developers, Cloudflare Agents — Documentación técnica para construir agentes en Cloudflare Workers y Durable Objects; contexto relevante sobre cómo los agentes en producción consumen contenido externo.
  • isitagentready.com — Escáner gratuito de preparación para agentes; referencia para las cinco categorías de cumplimiento auditadas (Descubrimiento, Accesibilidad del contenido, Control de acceso de bots, Descubrimiento de protocolos, Comercio).
  • Model Context Protocol, Especificación de MCP — Especificación del protocolo para las herramientas, los recursos y las server cards de MCP que se usan en la capa de Descubrimiento de protocolos.