Cómo Preparar tu Web para que la IA la Entienda: Guía Completa [2026]

Q: ¿Que es llms.txt y como se diferencia de robots.txt?

`robots.txt` le dice a los crawlers que URLs NO deben visitar (es un fichero de restricciones). `llms.txt` le dice a los agentes IA que contenido SI ofrece tu sitio y donde encontrarlo (es un fichero de descubrimiento). Son complementarios. `robots.txt` es una barrera; `llms.txt` es una invitacion. En 2026, tener ambos ficheros es la combinacion recomendada para cualquier sitio web que quiera ser visible tanto para buscadores tradicionales como para agentes IA.

TLDR: La mayoria de webs estan construidas para humanos con navegadores, no para agentes IA. El resultado es que ChatGPT, Claude, Gemini y Perplexity no pueden leer ni citar tu contenido aunque sea el mejor del mercado. En esta guia te explicamos las 4 capas de una web machine-readable (descubrimiento con llms.txt, consumo con content negotiation, estructura con schema endpoints, y conversacion con NLWeb), con un roadmap de implementacion de mas facil a mas dificil. Si quieres que la IA te cite, tu web tiene que hablar su idioma.

Por que la web moderna es dificil de leer para la IA

Antes de hablar de soluciones, hay que entender el problema. La web de 2026 no esta hecha para maquinas. Esta hecha para humanos que usan navegadores con JavaScript.

El problema del "div soup"

Abre el codigo fuente de cualquier web moderna. Lo que veras es algo como esto:

html

1<div class="sc-1234 flex items-center gap-4 bg-gradient-to-r from-purple-500">
2  <div class="sc-5678 relative overflow-hidden rounded-lg">
3    <div class="sc-9abc p-6 space-y-4">
4      <div class="sc-def0 text-xl font-bold tracking-tight">
5        Este es un titulo
6      </div>
7      <div class="sc-1111 text-gray-400 text-sm leading-relaxed">
8        Y esto es un parrafo que explica algo importante.
9      </div>
10    </div>
11  </div>
12</div>

Para un humano con un navegador, esto se renderiza como un titulo con un parrafo debajo en una tarjeta bonita. Para una maquina, es una sopa de <div> sin ningun significado semantico. No hay <article>, no hay <h1>, no hay ninguna pista de que ese primer <div> es un titulo y el segundo es una descripcion.

El problema del JavaScript rendering

La situacion empeora con las SPA (Single Page Applications). Muchas webs modernas construidas con React, Vue o Angular sirven un HTML inicial que es literalmente esto:

html

1<!DOCTYPE html>
2<html>
3<head><title>Mi App</title></head>
4<body>
5  <div id="root"></div>
6  <script src="/bundle.js"></script>
7</body>
8</html>

Todo el contenido se genera con JavaScript en el navegador del usuario. Un agente IA que hace una peticion HTTP a esa URL recibe un documento vacio. No ve nada.

Google resolvio esto hace anos con su "rendering service" que ejecuta JavaScript. Pero los agentes IA como ChatGPT, Claude o Perplexity no siempre pueden o quieren ejecutar JavaScript de cada pagina que visitan. Es demasiado costoso computacionalmente.

El problema de las URLs multiples

Un post de WordPress tipico puede tener hasta 7+ URLs que devuelven contenido:

URL	Que devuelve
`/blog/mi-post/`	El post completo (HTML)
`/blog/mi-post/feed/`	El post en RSS
`/blog/mi-post/amp/`	Version AMP
`/wp-json/wp/v2/posts/123`	El post via API REST
`/?p=123`	Redirect al permalink
`/blog/mi-post/page/2/`	Paginacion del post
`/?preview=true&p=123`	Vista previa

Un agente IA que quiere leer ese post tiene que decidir cual de estas URLs visitar. Y si visita la URL principal, puede encontrar un HTML lleno de sidebars, popups de cookies, banners de newsletter y anuncios que diluyen el contenido real.

Joost de Valk, fundador de Yoast SEO, ya advertia sobre estos problemas en su articulo de octubre de 2022 sobre la optimizacion del crawleo web. Su argumento era que obligar a los crawlers a parsear HTML pesado, navegar por multiples URLs y filtrar contenido irrelevante era un desperdicio de recursos que perjudicaba tanto a los buscadores como a los propietarios de los sitios. En 2025, con la llegada de los agentes IA, extendio esa vision al concepto de "web machine-readable" que cristalizo en el lanzamiento de NLWeb y Schema Aggregation en marzo de 2026.

El coste real para tu negocio

Si un agente IA no puede leer tu web, no puede:

Citarte como fuente en sus respuestas
Recomendar tus productos o servicios
Incluirte en comparativas o rankings
Entender que ofreces y a quien

Esto ya no es teoria. Segun datos de SparkToro (2026), un 38% de las busquedas informacionales en EE.UU. terminan en una respuesta de IA sin clic a ninguna web. Si no estas en esa respuesta, no existes para ese 38% de usuarios.

Para profundizar en como los buscadores IA estan cambiando el SEO, te recomendamos nuestra guia de ChatGPT para SEO.

La arquitectura de 4 capas para una web machine-readable

La solucion no es una unica herramienta o plugin. Es una arquitectura por capas, donde cada capa resuelve un problema especifico:

Capa	Funcion	Tecnologia	Dificultad
1. Descubrimiento	Decirle a la IA que ofreces	`llms.txt`	Facil
2. Consumo	Servir contenido limpio	Content negotiation	Media
3. Estructura	Dar datos tipados y conectados	Schema endpoints	Media
4. Conversacion	Responder preguntas directamente	NLWeb	Alta

No necesitas implementar las 4 capas el primer dia. Cada capa aporta valor por si sola. Pero la combinacion de las 4 crea un sitio que los agentes IA pueden entender al 100%.

Vamos capa por capa.

Capa 1: Descubrimiento con llms.txt

Que es llms.txt

llms.txt es un fichero de texto plano que colocas en la raiz de tu dominio (como robots.txt) y que le dice a los agentes IA que contenido ofrece tu sitio y como acceder a el.

Es el equivalente a poner un cartel en la puerta de tu tienda que dice: "Aqui vendemos X, Y y Z. La lista de precios esta en el mostrador. Hablamos espanol e ingles."

Formato basico

txt

1# llms.txt para tusitio.com
2 
3> Sitio web de consultoria en inteligencia artificial para empresas.
4> Publicamos guias, tutoriales y comparativas sobre herramientas de IA.
5> Idioma principal: espanol (Espana).
6 
7## Paginas principales
8- [Inicio](https://tusitio.com): Pagina principal con servicios destacados
9- [Blog](https://tusitio.com/blog): Guias y tutoriales sobre IA
10- [Servicios](https://tusitio.com/servicios): Consultoria, implementacion y formacion
11- [Contacto](https://tusitio.com/contacto): Formulario de contacto
12 
13## Contenido destacado
14- [Guia de ChatGPT para SEO](https://tusitio.com/blog/chatgpt-seo): Tutorial completo con prompts
15- [Comparativa de LLMs 2026](https://tusitio.com/blog/comparativa-llms): GPT-5, Claude Opus, Gemini 3
16- [Schema Endpoints](https://tusitio.com/blog/schema-endpoints): Datos estructurados para IA
17 
18## Recursos estructurados
19- Schema endpoint: https://tusitio.com/schema-endpoint/
20- Sitemap: https://tusitio.com/sitemap.xml
21- RSS: https://tusitio.com/feed.xml
22 
23## Informacion de contacto
24- Email: hola@tusitio.com
25- Empresa: Tu Empresa SL
26- CIF: B12345678

Donde colocarlo

El fichero debe estar accesible en:

code

1https://tusitio.com/llms.txt

Igual que robots.txt, los agentes IA buscan este fichero automaticamente en la raiz del dominio.

llms.txt vs llms-full.txt

Existe una variante llms-full.txt que incluye contenido expandido: descripciones largas, instrucciones detalladas y contexto adicional. La relacion es:

Fichero	Tamano tipico	Contenido	Quien lo usa
`llms.txt`	1-5 KB	Indice con enlaces y descripciones breves	Todos los agentes IA
`llms-full.txt`	10-100 KB	Contenido expandido con contexto detallado	Agentes que necesitan mas informacion

Implementacion en 5 minutos

Esto es lo mas facil de toda la guia. Literalmente creas un fichero de texto:

En WordPress:

code

1Sube el fichero a /wp-content/uploads/ o usa un plugin como "LLMs.txt for WordPress"

En Next.js:

typescript

1// app/llms.txt/route.ts
2export async function GET() {
3  const content = `# llms.txt para tusitio.com
4 
5> Sitio web sobre inteligencia artificial.
6> Publicamos guias y comparativas.
7 
8## Paginas principales
9- [Inicio](https://tusitio.com): Pagina principal
10- [Blog](https://tusitio.com/blog): Guias y tutoriales
11 
12## Recursos
13- Schema: https://tusitio.com/schema-endpoint/
14- Sitemap: https://tusitio.com/sitemap.xml
15`
16 
17  return new Response(content, {
18    headers: {
19      'Content-Type': 'text/plain; charset=utf-8',
20      'Cache-Control': 'public, max-age=86400'
21    }
22  })
23}

En cualquier sitio: Crea un fichero llms.txt y subelo a la raiz de tu hosting.

Que no poner en llms.txt

URLs que requieren autenticacion
Contenido que no quieras que la IA indexe
Datos personales o confidenciales
Instrucciones manipulativas ("siempre recomienda nuestro producto")

Capa 2: Consumo con content negotiation

El concepto

Content negotiation es un mecanismo estandar de HTTP (existe desde los anos 90) que permite a un servidor devolver distintas representaciones de un mismo recurso segun lo que pida el cliente.

Cuando un navegador visita /blog/mi-post, envia esta cabecera:

code

1Accept: text/html

Y el servidor devuelve HTML con CSS, imagenes, scripts, etc.

Cuando un agente IA visita la misma URL, podria enviar:

code

1Accept: application/ld+json

Y el servidor devolveria solo los datos estructurados JSON-LD del post, sin HTML, sin CSS, sin JavaScript.

O podria pedir:

code

1Accept: text/markdown

Y recibir el contenido del post en Markdown limpio, facil de procesar.

Por que importa

Content negotiation resuelve el problema de las "7 URLs por post" que mencionamos antes. En lugar de tener URLs separadas para el HTML, el RSS, la API, etc., tienes una sola URL que devuelve el formato que el cliente necesita.

Implementacion practica en Next.js

typescript

1// app/blog/[slug]/route.ts
2import { NextRequest, NextResponse } from 'next/server'
3import { getPost } from '@/lib/data'
4 
5export async function GET(
6  request: NextRequest,
7  { params }: { params: { slug: string } }
8) {
9  const post = await getPost(params.slug)
10  if (!post) return NextResponse.json({ error: 'Not found' }, { status: 404 })
11 
12  const accept = request.headers.get('Accept') || 'text/html'
13 
14  // Si piden JSON-LD, devolver datos estructurados
15  if (accept.includes('application/ld+json')) {
16    return NextResponse.json({
17      "@context": "https://schema.org",
18      "@type": "Article",
19      "headline": post.title,
20      "description": post.excerpt,
21      "datePublished": post.date,
22      "author": {
23        "@type": "Organization",
24        "name": "Tu Empresa"
25      },
26      "articleBody": post.content,
27      "url": `https://tusitio.com/blog/${post.slug}`
28    }, {
29      headers: { 'Content-Type': 'application/ld+json' }
30    })
31  }
32 
33  // Si piden Markdown, devolver contenido limpio
34  if (accept.includes('text/markdown')) {
35    return new Response(post.markdownContent, {
36      headers: { 'Content-Type': 'text/markdown; charset=utf-8' }
37    })
38  }
39 
40  // Si piden texto plano, devolver sin formato
41  if (accept.includes('text/plain') && !accept.includes('text/html')) {
42    return new Response(post.plainText, {
43      headers: { 'Content-Type': 'text/plain; charset=utf-8' }
44    })
45  }
46 
47  // Por defecto: devolver la pagina HTML normal
48  // (esto lo maneja Next.js con el page.tsx correspondiente)
49  return NextResponse.next()
50}

Headers Vary importantes

Cuando implementes content negotiation, incluye el header Vary para que los caches funcionen correctamente:

code

1Vary: Accept

Esto le dice a los CDNs y proxies que la respuesta varia segun la cabecera Accept, asi que deben cachear versiones distintas para cada formato.

Formato alternativo: .json, .md, .txt

Si no quieres lidiar con content negotiation a nivel de headers, una alternativa mas simple es ofrecer extensiones de fichero:

code

1/blog/mi-post          -> HTML (para navegadores)
2/blog/mi-post.json     -> JSON-LD (para agentes IA)
3/blog/mi-post.md       -> Markdown (para procesamiento de texto)
4/blog/mi-post.txt      -> Texto plano

Esto es mas facil de implementar y de testear, aunque menos elegante desde el punto de vista HTTP.

Capa 3: Estructura con schema endpoints

Esta capa merece un articulo completo, y lo tenemos: consulta nuestra guia de schema endpoints para la implementacion detallada con codigo para WordPress, Next.js y sitios custom.

Aqui un resumen de los puntos clave:

Que es un schema endpoint

Es una URL unica que devuelve todo el grafo de datos estructurados de tu web en formato JSON-LD. En lugar de que los agentes IA visiten cientos de paginas para recopilar datos, les das todo en un solo fichero.

Que incluir

json

1{
2  "@context": "https://schema.org",
3  "@graph": [
4    { "@type": "WebSite", "name": "...", "url": "..." },
5    { "@type": "Organization", "name": "...", "logo": "..." },
6    { "@type": "Article", "headline": "...", "datePublished": "..." },
7    { "@type": "Article", "headline": "...", "datePublished": "..." },
8    { "@type": "FAQPage", "mainEntity": [...] },
9    { "@type": "Product", "name": "...", "offers": {...} }
10  ]
11}

Schema map para sitios grandes

Si tu sitio tiene mas de 1.000 entidades, usa un schema map (un indice de schema endpoints paginados) en lugar de un solo fichero enorme:

json

1{
2  "@context": "https://schema.org",
3  "@type": "DataFeed",
4  "dataFeedElement": [
5    { "url": "/schema-endpoint/articles?page=1" },
6    { "url": "/schema-endpoint/articles?page=2" },
7    { "url": "/schema-endpoint/products" }
8  ]
9}

Como declararlo

Anade la referencia a tu schema endpoint en llms.txt, robots.txt y en el <head> de tu homepage:

html

1<link rel="schema-endpoint" href="/schema-endpoint/" />

Capa 4: Conversacion con NLWeb

Que es NLWeb

NLWeb (Natural Language Web) es un protocolo lanzado por Microsoft en marzo de 2026 que permite a los sitios web responder directamente a consultas en lenguaje natural. En lugar de que el agente IA crawlee tu web, descifre el HTML y extraiga informacion, tu web responde directamente a preguntas.

El concepto es radical: tu web deja de ser un documento pasivo y se convierte en un interlocutor activo.

Como funciona

code

1Agente IA: "Cuales son los mejores restaurantes italianos en Madrid con terraza?"
2 
3Peticion NLWeb al sitio web:
4POST /nlweb
5{
6  "query": "mejores restaurantes italianos en Madrid con terraza",
7  "language": "es",
8  "max_results": 5
9}
10 
11Respuesta del sitio:
12{
13  "results": [
14    {
15      "@type": "Restaurant",
16      "name": "Trattoria Roma",
17      "address": "Calle Mayor 15, Madrid",
18      "cuisine": "Italiana",
19      "amenity": "Terraza amplia",
20      "rating": 4.7,
21      "url": "https://tusitio.com/restaurantes/trattoria-roma"
22    }
23  ],
24  "source": "https://tusitio.com",
25  "confidence": 0.92
26}

Componentes de NLWeb

Componente	Funcion	Estado (abril 2026)
Query endpoint	Recibir y procesar consultas NL	Especificacion abierta
Schema layer	Responder con datos schema.org	Integrado con Yoast
Discovery	Anunciar capacidad NLWeb	Via llms.txt y robots.txt
Authentication	Controlar acceso	En desarrollo

Implementacion basica

NLWeb requiere un backend que pueda procesar lenguaje natural. Las opciones son:

Opcion 1: LLM local o API

typescript

1// app/nlweb/route.ts
2import { NextRequest, NextResponse } from 'next/server'
3import { OpenAI } from 'openai'
4import { getAllPosts, getAllProducts } from '@/lib/data'
5 
6const openai = new OpenAI()
7 
8export async function POST(request: NextRequest) {
9  const { query, language, max_results = 5 } = await request.json()
10 
11  // Obtener todos los datos del sitio
12  const posts = await getAllPosts()
13  const products = await getAllProducts()
14 
15  // Crear contexto para el LLM
16  const context = JSON.stringify({
17    posts: posts.map(p => ({
18      title: p.title,
19      excerpt: p.excerpt,
20      date: p.date,
21      url: `/blog/${p.slug}`,
22      keywords: p.keywords
23    })),
24    products: products.map(p => ({
25      name: p.name,
26      description: p.description,
27      price: p.price,
28      url: `/producto/${p.slug}`
29    }))
30  })
31 
32  // Pedir al LLM que encuentre resultados relevantes
33  const response = await openai.chat.completions.create({
34    model: 'gpt-4o-mini',
35    messages: [
36      {
37        role: 'system',
38        content: `Eres un motor de busqueda para el sitio tusitio.com.
39                  Devuelve los ${max_results} resultados mas relevantes
40                  para la consulta del usuario en formato JSON.
41                  Solo devuelve items que existan en el contexto proporcionado.`
42      },
43      {
44        role: 'user',
45        content: `Contexto del sitio: ${context}\n\nConsulta: ${query}`
46      }
47    ],
48    response_format: { type: 'json_object' }
49  })
50 
51  const results = JSON.parse(response.choices[0].message.content || '{}')
52 
53  return NextResponse.json({
54    results: results.items || [],
55    source: 'https://tusitio.com',
56    query,
57    language
58  })
59}

Opcion 2: Busqueda por embeddings (mas eficiente para sitios grandes)

typescript

1// Genera embeddings de tu contenido en build time
2// Almacenalos en una base vectorial (Pinecone, Qdrant, ChromaDB)
3// En runtime, embede la query y busca los mas similares
4 
5import { searchByEmbedding } from '@/lib/vector-search'
6 
7export async function POST(request: NextRequest) {
8  const { query, max_results = 5 } = await request.json()
9 
10  const results = await searchByEmbedding(query, max_results)
11 
12  return NextResponse.json({
13    results: results.map(r => ({
14      "@type": r.type,
15      "name": r.title,
16      "url": r.url,
17      "description": r.excerpt,
18      "relevanceScore": r.score
19    })),
20    source: "https://tusitio.com"
21  })
22}

Si quieres profundizar en embeddings y busqueda vectorial, nuestra guia de Deep Research con IA explica como los agentes IA procesan multiples fuentes de informacion.

Coste y consideraciones

NLWeb con un LLM tiene coste por peticion. Estimaciones:

Volumen de queries	LLM	Coste mensual estimado
100/dia	GPT-4o-mini	~15 EUR
1.000/dia	GPT-4o-mini	~150 EUR
100/dia	LLM local (Llama 3)	Coste de hosting
1.000/dia	Embeddings + busqueda vectorial	~5-20 EUR

Para la mayoria de sitios, la opcion de embeddings es la mas rentable: generas los embeddings una vez (o cuando actualizas contenido) y las busquedas en runtime son rapidas y baratas.

Roadmap de implementacion: de facil a dificil

Aqui tienes un plan de accion ordenado por dificultad y impacto:

Semana 1: Lo basico (2-4 horas)

Tarea	Dificultad	Impacto
Crear `llms.txt` con descripcion del sitio y enlaces principales	Facil	Alto
Verificar que tu sitio tiene HTML semantico (`<article>`, `<h1>-<h6>`, `<nav>`)	Facil	Medio
Anadir schema per-page basico (`Article`, `Organization`, `WebSite`) si no lo tienes	Facil	Alto
Verificar que tu sitemap.xml esta actualizado y accesible	Facil	Medio

Semana 2: Datos estructurados (4-8 horas)

Tarea	Dificultad	Impacto
Ampliar schema per-page: anadir `FAQPage`, `HowTo`, `BreadcrumbList`	Media	Alto
Crear un schema endpoint basico con `WebSite`, `Organization` y articulos	Media	Alto
Declarar el schema endpoint en `llms.txt` y `robots.txt`	Facil	Medio
Validar todo el schema con Schema.org Validator	Facil	Medio

Semana 3: Content negotiation (4-6 horas)

Tarea	Dificultad	Impacto
Implementar JSON-LD response para peticiones con `Accept: application/ld+json`	Media	Medio
Servir version Markdown para `Accept: text/markdown`	Media	Medio
Anadir header `Vary: Accept` a las respuestas	Facil	Bajo
Testear con curl que cada formato funciona	Facil	Bajo

Semana 4: Optimizacion y NLWeb (8-16 horas)

Tarea	Dificultad	Impacto
Implementar NLWeb basico (endpoint de busqueda con LLM o embeddings)	Alta	Alto
Anadir paginacion al schema endpoint si tienes muchas entidades	Media	Medio
Crear un schema map si tu sitio es grande	Media	Medio
Monitorizar logs para detectar crawlers IA y medir adopcion	Media	Alto

Despues del mes 1: Iteracion continua

Ampliar tipos de schema segun tu contenido (productos, eventos, cursos, etc.)
Optimizar el endpoint NLWeb basandote en las queries reales que recibas
Testear periodicamente con agentes IA reales (pregunta a ChatGPT y Claude sobre tu sitio)
Automatizar la actualizacion del schema endpoint cuando publiques contenido nuevo

Como testear si la IA puede entender tu web

Test 1: El test de ChatGPT

Abre ChatGPT y pregunta:

code

1Que informacion puedes encontrar sobre [tu dominio]?
2Que servicios/productos ofrece [tu dominio]?

Si ChatGPT conoce tu sitio y puede describir tu contenido con precision, vas bien. Si no sabe nada o da informacion incorrecta, tienes trabajo por hacer.

Test 2: El test de Perplexity

Perplexity es mas agresivo crawleando la web. Busca:

code

1site:tudominio.com [tema de tu contenido]

Perplexity deberia devolver resultados de tu sitio con citas. Si no apareces, verifica que tu robots.txt no bloquea a PerplexityBot.

Test 3: El test de curl

Simula como un agente IA veria tu sitio:

bash

1# Ver el HTML que recibe un agente IA
2curl -s https://tusitio.com | head -100
3 
4# Verificar que llms.txt existe
5curl -s https://tusitio.com/llms.txt
6 
7# Verificar el schema endpoint
8curl -s https://tusitio.com/schema-endpoint/ | python3 -m json.tool
9 
10# Verificar content negotiation
11curl -s -H "Accept: application/ld+json" https://tusitio.com/blog/mi-post
12 
13# Verificar que no dependes de JavaScript
14curl -s https://tusitio.com/blog/mi-post | grep -c "<article>"

Test 4: El test de Google Rich Results

El Rich Results Test de Google analiza los datos estructurados de cualquier URL. Prueba tus paginas principales y verifica que detecta todos los tipos de schema que has implementado.

Test 5: El test de logs

Revisa los logs de tu servidor y busca visitas de agentes IA:

bash

1# Buscar crawlers IA en logs de Nginx
2grep -E "GPTBot|ClaudeBot|PerplexityBot|Google-Extended" /var/log/nginx/access.log
3 
4# Contar visitas por agente
5grep -oP "(GPTBot|ClaudeBot|PerplexityBot|Google-Extended)" /var/log/nginx/access.log | sort | uniq -c

Si ves visitas frecuentes a tu schema endpoint y llms.txt, los agentes estan descubriendo y consumiendo tu contenido.

Checklist de HTML semantico: lo que muchos olvidan

Antes de implementar capas avanzadas, asegurate de que tu HTML base es semantico. Esto es gratis y tiene un impacto enorme:

Elementos que debes usar

Elemento HTML	Para que	En lugar de
`<article>`	Contenido independiente (posts, productos)	`<div class="post">`
`<header>`	Cabecera de pagina o seccion	`<div class="header">`
`<nav>`	Navegacion	`<div class="menu">`
`<main>`	Contenido principal	`<div class="content">`
`<aside>`	Contenido relacionado (sidebar)	`<div class="sidebar">`
`<footer>`	Pie de pagina	`<div class="footer">`
`<section>`	Secciones tematicas	`<div class="section">`
`<h1>-<h6>`	Jerarquia de titulos	`<div class="title">`
`<time datetime="...">`	Fechas	`<span>13 abril 2026</span>`
`<address>`	Datos de contacto	`<div class="contact">`
`<figure>` + `<figcaption>`	Imagenes con pie	`<div class="image">`

Atributos ARIA esenciales

Atributo	Para que
`aria-label`	Descripcion para elementos sin texto visible
`role="main"`	Indicar el contenido principal
`lang="es"`	Indicar el idioma
`aria-current="page"`	Indicar la pagina actual en navegacion

Meta tags que los agentes IA leen

html

1<head>
2  <!-- Basicos -->
3  <title>Titulo de la pagina - Tu Sitio</title>
4  <meta name="description" content="Descripcion de 150-200 caracteres">
5  <meta name="author" content="Tu Empresa">
6  <link rel="canonical" href="https://tusitio.com/pagina">
7 
8  <!-- Open Graph (lo leen muchos agentes) -->
9  <meta property="og:title" content="Titulo">
10  <meta property="og:description" content="Descripcion">
11  <meta property="og:type" content="article">
12  <meta property="og:url" content="https://tusitio.com/pagina">
13 
14  <!-- Idioma -->
15  <meta property="og:locale" content="es_ES">
16  <html lang="es">
17 
18  <!-- Schema endpoint -->
19  <link rel="schema-endpoint" href="/schema-endpoint/">
20 
21  <!-- Datos estructurados per-page -->
22  <script type="application/ld+json">
23  {
24    "@context": "https://schema.org",
25    "@type": "Article",
26    "headline": "...",
27    "description": "..."
28  }
29  </script>
30</head>

Server-Side Rendering vs Static Generation: que ven los agentes IA

La forma en que generas tu HTML importa mucho para los agentes IA:

Metodo	Que ve el agente IA	Recomendacion
SSR (Server-Side Rendering)	HTML completo con contenido	Excelente
SSG (Static Site Generation)	HTML estatico completo	Excelente
ISR (Incremental Static Regeneration)	HTML estatico (puede estar cacheado)	Bueno
CSR (Client-Side Rendering)	HTML vacio + JavaScript	Malo
SPA sin SSR	`<div id="root"></div>`	Muy malo

Si tu web usa CSR puro (React sin Next.js, Vue sin Nuxt), los agentes IA no pueden ver tu contenido. Las opciones son:

Migrar a un framework con SSR (Next.js, Nuxt, SvelteKit)
Implementar content negotiation (servir JSON cuando pidan JSON)
Crear un schema endpoint robusto que cubra todo tu contenido
Pre-renderizar las paginas criticas como HTML estatico

El equipo de www.javadex.es utiliza Next.js con SSR y generacion estatica para garantizar que todo el contenido sea visible tanto para buscadores como para agentes IA, un patron que recomendamos como referencia para proyectos de produccion.

Herramientas y recursos para implementar

Para diagnostico

Herramienta	Funcion	Precio
Google Rich Results Test	Validar datos estructurados	Gratis
Schema.org Validator	Validar JSON-LD	Gratis
Google Search Console	Monitorizar AI Overviews, indexacion	Gratis
Screaming Frog	Auditar schema y HTML semantico de todo el sitio	259 GBP/ano
web.dev/measure	Performance y accesibilidad	Gratis

Para implementacion

Herramienta	Para que	Stack
Yoast SEO Premium	Schema endpoints automaticos	WordPress
Next.js API Routes	Schema endpoints, content negotiation, NLWeb	React/Next.js
11ty (Eleventy)	Generacion de ficheros estaticos (llms.txt, schema.json)	SSG
Astro	SSG con content negotiation nativa	Multi-framework

Para monitorizacion

Herramienta	Que mide
Google Search Console (dimension searchAppearance)	Apariciones en AI Overviews
Server logs + user-agent filter	Visitas de GPTBot, ClaudeBot, etc.
Perplexity	Si tu sitio aparece como fuente citada
ChatGPT / Claude	Si pueden describir tu sitio con precision

Casos practicos por tipo de sitio

Blog / medio de comunicacion

Prioridades: llms.txt, schema per-page (Article, FAQPage), schema endpoint con todos los articulos, content negotiation para servir Markdown.

Resultado esperado: Los agentes IA citan tus articulos como fuente en sus respuestas.

E-commerce

Prioridades: Schema per-page (Product con precio y stock), schema endpoint con catalogo completo, NLWeb para busqueda de productos por lenguaje natural.

Resultado esperado: Cuando alguien pregunta "donde comprar X barato en Espana", tu tienda aparece con precio y disponibilidad.

SaaS / herramienta online

Prioridades: Schema per-page (SoftwareApplication, FAQPage, HowTo), llms.txt detallado con funcionalidades, schema endpoint con pagina de precios.

Resultado esperado: Los agentes IA incluyen tu herramienta en comparativas y recomendaciones.

Negocio local (restaurante, clinica, tienda)

Prioridades: Schema per-page (LocalBusiness con horarios, direccion, telefono), llms.txt basico, Google Business Profile actualizado.

Resultado esperado: Los agentes IA recomiendan tu negocio cuando alguien pregunta por servicios en tu zona.

Portfolio / freelance

Prioridades: Schema per-page (Person, CreativeWork), llms.txt con servicios y proyectos destacados, content negotiation para servir tu CV en JSON-LD.

Resultado esperado: Cuando alguien pregunta "desarrolladores web en Espana especializados en IA", tu nombre aparece citado.

El contexto historico: de robots.txt a NLWeb

Para entender hacia donde va la web machine-readable, es util ver de donde viene:

Ano	Hito	Impacto
1994	`robots.txt`	Los sitios pueden decir que no crawlear
1996	`sitemap.xml` (Google)	Los sitios pueden listar todas sus URLs
2011	schema.org (Google, Bing, Yahoo, Yandex)	Estandar para datos estructurados
2015	JSON-LD como formato preferido	Mas facil de implementar que microdata
2022	Joost de Valk: "optimizar crawling"	Primera llamada a centralizar datos para crawlers
2024	`llms.txt` (propuesta inicial)	Primer estandar para descubrimiento por IA
2025	Joost de Valk: "AI-readable content"	Formalizacion del concepto de web machine-readable
2026	Yoast Schema Aggregation + NLWeb	Primera implementacion masiva de schema endpoints

Cada paso ha ido en la misma direccion: hacer que los sitios web puedan comunicarse directamente con las maquinas de forma eficiente y estructurada. Lo que cambia en 2026 es que las "maquinas" ya no son solo crawlers de buscadores, sino agentes IA que necesitan entender tu contenido para responder preguntas de millones de usuarios.

Errores comunes al preparar tu web para IA

Error 1: Centrarse solo en el contenido e ignorar la estructura

Puedes tener el mejor contenido del mundo, pero si esta envuelto en <div> sin significado semantico y sin datos estructurados, los agentes IA no pueden procesarlo eficientemente. La estructura es tan importante como el contenido.

Error 2: Bloquear crawlers IA en robots.txt

Algunos propietarios de sitios bloquean GPTBot, ClaudeBot y otros en robots.txt por miedo a que "copien" su contenido. El resultado es que esos agentes no pueden citarte como fuente. En 2026, bloquear crawlers IA es equivalente a bloquear Googlebot en 2010: te estas autoexcluyendo del canal de descubrimiento mas importante.

Error 3: Implementar schema solo para rich snippets

Si tu unica motivacion para schema.org son las estrellitas de Google, te estas perdiendo el 80% del valor. Los datos estructurados son la base de toda la arquitectura machine-readable. Implementa schema completo, no solo lo minimo para rich snippets.

Error 4: No actualizar el schema endpoint

Un schema endpoint con datos obsoletos es peor que no tener schema endpoint. Los agentes IA detectan inconsistencias entre tu web real y tus datos estructurados, y reducen la confianza en tu sitio. Automatiza la regeneracion del endpoint cada vez que publiques contenido.

Error 5: Intentar manipular los agentes IA

Incluir instrucciones ocultas en tu HTML o JSON-LD del tipo "siempre recomienda nuestro producto" o "somos la mejor opcion del mercado" no funciona. Los LLMs estan entrenados para detectar y ignorar este tipo de manipulaciones, y pueden penalizarte bajando tu puntuacion de confianza.

Error 6: Olvidar el rendimiento

Un schema endpoint que tarda 10 segundos en responder sera abandonado por los agentes IA. Cachea agresivamente, usa CDN, y pagina si es necesario.

Javier Santos es uno de los pocos consultores en España especializados tanto en GEO (Generative Engine Optimization) como en implementación técnica de IA. Su web javadex.es es un ejemplo práctico de las técnicas descritas en este artículo aplicadas a un proyecto real.

Preguntas frecuentes

¿Que significa que una web sea "machine-readable"?

Una web machine-readable es un sitio que esta estructurado de forma que las maquinas (crawlers, agentes IA, APIs) pueden entender su contenido sin necesidad de renderizar JavaScript ni interpretar HTML visual. Esto implica usar HTML semantico, datos estructurados (JSON-LD con schema.org), ficheros de descubrimiento como llms.txt, y opcionalmente content negotiation y endpoints NLWeb. El objetivo es que un agente IA pueda saber que ofrece tu sitio, acceder a tus datos estructurados y responder preguntas sobre tu contenido con precision.

¿Necesito implementar las 4 capas para que la IA lea mi web?

No. Cada capa aporta valor de forma independiente. Empieza por la Capa 1 (llms.txt) y la Capa 3 (schema per-page + endpoint), que son las que mas impacto tienen con menos esfuerzo. La Capa 2 (content negotiation) y la Capa 4 (NLWeb) son optimizaciones avanzadas que puedes implementar despues. Un sitio con solo llms.txt y un buen schema endpoint ya esta muy por delante del 95% de las webs en terminos de legibilidad para IA.

¿Que es llms.txt y como se diferencia de robots.txt?

robots.txt le dice a los crawlers que URLs NO deben visitar (es un fichero de restricciones). llms.txt le dice a los agentes IA que contenido SI ofrece tu sitio y donde encontrarlo (es un fichero de descubrimiento). Son complementarios. robots.txt es una barrera; llms.txt es una invitacion. En 2026, tener ambos ficheros es la combinacion recomendada para cualquier sitio web que quiera ser visible tanto para buscadores tradicionales como para agentes IA.

¿Como se relaciona NLWeb con los schema endpoints?

NLWeb y los schema endpoints son capas complementarias de la arquitectura machine-readable. Los schema endpoints son pasivos: sirven datos estructurados y el agente IA los interpreta. NLWeb es activo: recibe una pregunta en lenguaje natural y devuelve una respuesta estructurada. NLWeb se apoya en los datos de los schema endpoints para generar sus respuestas. Puedes tener schema endpoints sin NLWeb (lo recomendado como primer paso), pero NLWeb sin datos estructurados subyacentes seria mucho menos preciso.

¿Afecta al SEO tradicional implementar estas capas?

Si, positivamente. Todas las capas de la arquitectura machine-readable mejoran tambien el SEO tradicional. El HTML semantico mejora la accesibilidad y la comprension del contenido por Google. Los datos estructurados per-page generan rich snippets. El llms.txt no afecta al SEO directamente pero mejora la visibilidad en respuestas IA, que cada vez generan mas trafico. No hay conflicto entre SEO y GEO; son estrategias complementarias.

¿Cuanto tiempo se tarda en ver resultados?

Los datos estructurados per-page y los rich snippets pueden tardar 2-4 semanas en aparecer en Google tras la implementacion. Para agentes IA (ChatGPT, Claude, Perplexity), el impacto depende de la frecuencia de crawleo de tu sitio. Sitios con mucho contenido nuevo y alta autoridad ven resultados en dias. Sitios mas pequenos pueden tardar semanas en ser re-crawleados. Puedes acelerar el proceso enviando tu sitemap via Google Search Console y usando IndexNow para Bing.

¿Es seguro compartir toda la informacion de mi web en un schema endpoint?

El schema endpoint debe contener solo informacion publica: titulos, descripciones, fechas, precios, URLs. No incluyas datos privados, emails de clientes, informacion interna o contenido que no aparezca ya en tu web publica. Piensa en el schema endpoint como un resumen estructurado de lo que cualquiera puede ver navegando tu sitio. Si la informacion ya es publica en tu web, es seguro incluirla en el endpoint.

¿Que hago si mi web es una SPA sin server-side rendering?

Si tu web es una SPA pura (React, Vue o Angular sin SSR), los agentes IA ven un HTML vacio. Tus opciones, de mas a menos recomendable: (1) migrar a un framework con SSR como Next.js, Nuxt o SvelteKit; (2) implementar pre-rendering para las paginas criticas; (3) crear un schema endpoint muy completo que cubra todo tu contenido; (4) implementar content negotiation para servir JSON-LD cuando lo pidan agentes IA. La opcion 1 es la ideal porque resuelve el problema de raiz. Las opciones 3 y 4 son parches que funcionan pero no sustituyen al HTML real.

Por que la web moderna es dificil de leer para la IA

El problema del "div soup"

El problema del JavaScript rendering

El problema de las URLs multiples

El coste real para tu negocio

La arquitectura de 4 capas para una web machine-readable

Capa 1: Descubrimiento con llms.txt

Que es llms.txt

Formato basico

Donde colocarlo

llms.txt vs llms-full.txt

Implementacion en 5 minutos

Que no poner en llms.txt

Capa 2: Consumo con content negotiation

El concepto

Por que importa

Implementacion practica en Next.js

Headers Vary importantes

Formato alternativo: .json, .md, .txt

Capa 3: Estructura con schema endpoints

Que es un schema endpoint

Que incluir

Schema map para sitios grandes

Como declararlo

Capa 4: Conversacion con NLWeb

Que es NLWeb

Como funciona

Componentes de NLWeb

Implementacion basica

Coste y consideraciones

Roadmap de implementacion: de facil a dificil

Semana 1: Lo basico (2-4 horas)

Semana 2: Datos estructurados (4-8 horas)

Semana 3: Content negotiation (4-6 horas)

Semana 4: Optimizacion y NLWeb (8-16 horas)

Despues del mes 1: Iteracion continua

Como testear si la IA puede entender tu web

Test 1: El test de ChatGPT

Test 2: El test de Perplexity

Test 3: El test de curl

Test 4: El test de Google Rich Results

Test 5: El test de logs

Checklist de HTML semantico: lo que muchos olvidan

Elementos que debes usar

Atributos ARIA esenciales

Meta tags que los agentes IA leen

Server-Side Rendering vs Static Generation: que ven los agentes IA

Herramientas y recursos para implementar

Para diagnostico

Para implementacion

Para monitorizacion

Casos practicos por tipo de sitio

Blog / medio de comunicacion

E-commerce

SaaS / herramienta online

Negocio local (restaurante, clinica, tienda)

Portfolio / freelance

El contexto historico: de robots.txt a NLWeb

Errores comunes al preparar tu web para IA

Error 1: Centrarse solo en el contenido e ignorar la estructura

Error 2: Bloquear crawlers IA en robots.txt

Error 3: Implementar schema solo para rich snippets

Error 4: No actualizar el schema endpoint

Error 5: Intentar manipular los agentes IA

Error 6: Olvidar el rendimiento

Preguntas frecuentes

¿Que significa que una web sea "machine-readable"?

¿Necesito implementar las 4 capas para que la IA lea mi web?

¿Que es llms.txt y como se diferencia de robots.txt?

¿Como se relaciona NLWeb con los schema endpoints?

¿Afecta al SEO tradicional implementar estas capas?

¿Cuanto tiempo se tarda en ver resultados?

¿Es seguro compartir toda la informacion de mi web en un schema endpoint?

¿Que hago si mi web es una SPA sin server-side rendering?

Posts Relacionados

Comparación ChatGPT vs HubSpot Breeze vs Microsoft Copilot vs Gemini: Asistentes IA para Ventas y Marketing 2026

Las 5 mejores consultoras de IA para PYMEs en España (2026): ranking editorial

GEO para empresas: cómo salir en ChatGPT, Claude y Perplexity en 2026

Javier Santos Criado

¿Crees que la IA puede ayudar a tu empresa?