¿Qué es una ventana de 1M tokens? Usos del contexto largo y GPT vs Claude vs Gemini

De entrada: en septiembre de 2026, GPT-5.5, Claude Opus 4.8 / Sonnet 4.6 y Gemini 3.7 Flash anuncian una ventana de alrededor de un millón de tokens. «1M tokens» no es «un millón de caracteres chinos», y llenar la ventana no es lo mismo que usarla. Los límites anunciados son parecidos. La recuperación efectiva, la salida máxima y los escalones de precio, no. Si trabajas con JSON, lo correcto es recortar, validar y luego decidir cuánto meter — no pegar el dump entero.

Este artículo está escrito a fecha de 5 de septiembre de 2026. Las cifras siguen la documentación pública: la API de gpt-5.5 de OpenAI, con unos 1,050,000 tokens en total y 128K de salida; Opus 4.8 / Sonnet 4.6 de Anthropic, con 1M por defecto y 128K de salida, sin recargo por contexto largo; gemini-3.7-flash de Google, con 1,048,576 de entrada / 65,536 de salida. Las interfaces de producto (ChatGPT, Codex, claude.ai) suelen ser más estrechas. No tomes una página de marketing como el límite de la API.

Qué significa 1M tokens

Un token es el fragmento más pequeño que un modelo cuenta y factura — no es un carácter ni una palabra. En inglés, 1 token ≈ 0.75 palabras, o unos 4 caracteres. En chino, un token suele cubrir 1–2 caracteres, según el tokenizador y la puntuación. El JSON es más caro: llaves, comillas, keys repetidas y la indentación consumen presupuesto.

1M tokens = una ventana de contexto de alrededor de un millón de tokens. Conversión aproximada: ~750,000 palabras en inglés, o ~500,000–800,000 caracteres chinos, o de un libro grueso a unos cuantos medianos, o un repositorio de tamaño medio más la documentación. No es «una novela de un millón de caracteres» ni «un millón de líneas de código». El mismo 1M alberga cantidades de señal muy distintas en prosa, tablas y JSON minificado.

La ventana de contexto es el presupuesto compartido de una sola petición: prompt de sistema + historial + definiciones de herramientas + resultados de herramientas + la salida de este turno. Los modelos de la clase GPT-5 también cuentan los tokens de razonamiento. Una entrada de 900K tokens más un esfuerzo de razonamiento alto chocará con context_length_exceeded antes de que el modelo «termine de leer». El presupuesto se ha acabado.

En 2023 lo habitual era 4K–32K. En 2024 Gemini 1.5 convirtió 1M en titular. En 2025, 200K era el valor por defecto de gama media. En septiembre de 2026, las APIs insignia han alineado el número publicitario en 1M. La carrera ya no es «quién es más largo», sino quién sigue encontrando agujas más allá de 200K, y cuya caché es lo bastante barata para usarla a diario.

Para qué sirve una ventana de contexto larga

Una ventana larga resuelve ver muchos materiales en una sola inferencia. No sustituye a una base de datos y no es memoria infinita gratuita. Los trabajos de abajo suelen exigir troceado o RAG a 128K. Con 1M a veces puedes convertir «recuperar y luego preguntar» en «cargar y luego preguntar» — si lo que cargas ya estaba filtrado.

• Codificación de repo completo / multiarchivo: mantén módulos relacionados, tests y definiciones de interfaz en un solo turno para que el modelo tenga menos probabilidad de no ver un archivo. El cuello de botella de la codificación con agentes sigue estando en los bucles de herramientas y el feedback de tests, no en el anuncio de la ventana — lo cubrimos en Gemini 3.8 Flash y AI coding.
• Revisión de documentos largos: contratos, presentaciones, especificaciones, varios PDF en paralelo. Sirve para «encuentra el conflicto entre el §47 y el Apéndice B». No sirve para «pega un año de correo y pide un resumen».
• Entrada multimodal larga: Gemini cuenta vídeo, audio, imágenes y texto en la misma ventana. Una hora de vídeo quema tokens rápido. 1M es una cuota, no una invitación a subir sin comprimir.
• Agentes de varios pasos: el JSON de herramientas, las pilas de error y el último parche pueden quedarse un rato en el hilo. Una ventana más grande no es motivo para reinyectar stacks en crudo — ver el flujo de datos JSON del Agent.
• Alineación de JSON grande: OpenAPI / JSON Schema, payloads de ejemplo y logs de error de producción en un solo turno. Este es el uso de 1M que más debería importar a los lectores de este sitio, y la forma más fácil de disparar la factura.
• Saltar una capa de RAG: cuando el corpus es estable, acotado y necesitas citas literales cada vez, meterlo puede ser más simple que un almacén vectorial. Cuando el corpus cambia a diario o las consultas se repiten, la recuperación sigue siendo más barata y más actual.

Al contrario: chat, clasificación de una sola etiqueta, extracción corta de JSON. Una ventana de 1M es un desperdicio. La latencia, los prefills y la facturación por token te penalizan. Los trabajos cortos llevan un modelo corto o un presupuesto corto.

GPT vs Claude vs Gemini

La tabla de abajo es lo que puedes poner en un documento el 5 de septiembre de 2026. Los precios son las tarifas oficiales de lista por millón de tokens; los techos de las interfaces de producto van aparte. Gemini 3.8 Flash aún no es GA a fecha de este artículo — mantén la producción en 3.7.

Cómo leerla: las tres APIs insignia pueden admitir alrededor de 1M. Las diferencias son el margen de salida, si el razonamiento se come la ventana, si los tokens por encima de 200K cuestan más, y si la caché merece la pena.

• Necesitas un resultado estructurado largo de un solo golpe (JSON grande, un parche largo, un diff multiarchivo): GPT-5.5 y Claude 4.6/4.8 con 128K de salida son unas 2× los ~64K de Gemini. Gemini es mejor en «leer mucho, escribir una tabla».
• El mismo prompt de sistema + schema de herramientas en cada llamada: el prompt cache de Claude, el Context Caching de Gemini y el cached input de OpenAI superan a pagar la entrada completa cada vez. El JSON de tools del Agent debe ir en caché — ver Tool Calling y JSON Schema.
• Presupuesto ajustado, mucho material, salida corta: el precio introductorio de Gemini 3.7 Flash sigue siendo el tramo 1M más barato de los tres. Más allá de 200K, mide la multi-aguja con tus propios datos; no confíes solo en el número de la ventana.
• Producto ≠ API: GPT-5.5 en ChatGPT / Codex puede ser 400K; algunos marketplaces cloud siguen sirviendo Claude a 200K. Abre la model card de la interfaz en la que publicas antes de redactar un SLA.

Ventana anunciada vs ventana útil

En 2026 el consenso es difícil de ignorar: anunciar 1M y usar 1M son trabajos distintos. En la recuperación multi-aguja (estilo MRCR v2: encontrar varios hechos dispersos en un texto enorme), la precisión suele empezar a caer después de 128K, se bifurca entre 200K y 512K, y cerca de 1M solo unos pocos modelos siguen comportándose como si hubieran leído el archivo entero.

Las evaluaciones públicas y las compilaciones de terceros (los montajes no son idénticos — trátalas como tendencia, no como prueba de aceptación) se parecen más o menos a esto:

• GPT-5.5: un salto respecto a los GPT-5.x anteriores en el razonamiento multi-aguja en la banda 512K–1M, y una de las APIs que más se nombra cuando la gente realmente llena la ventana. La aguja única «encuentra esta frase» les va bien a los tres dentro de 128K.
• Claude Opus 4.6: la multi-aguja a 1M se ha reportado en torno al 76%, con una curva más plana. 4.7 / 4.8 apuestan más por la calibración — rechazan o marcan incertidumbre en lugar de inventar una ubicación. La revisión de cumplimiento de documentos largos suele preferir lo segundo.
• Gemini 3.x: sigue fuerte en recuperación y comprensión de documentos largos dentro de 128K; la multi-aguja cae de forma más pronunciada más allá de 200K. Bien para «leer una pila gruesa, emitir un JSON corto». Mal para «garantizar la 8.ª aguja en 900K tokens de logs».

En producción, usa tres bandas — no la hoja de precios:

El «lost in the middle» no desapareció cuando las ventanas llegaron a 1M. Pon las restricciones duras al inicio del prompt de sistema y al final del mensaje del usuario; coloca los apéndices en el medio. Los modelos recuerdan «devuelve JSON que cumpla el schema» más a menudo que un enum enterrado en el token 400,000.

JSON: meter no es validar

Una ventana de 1M es la primera vez que «todo el OpenAPI, tres días de logs de error y un schema en borrador» caben en una sola petición. No convierte en legal un JSON ilegal, ni endurece un schema laxo. La ventana es visibilidad; el contrato es la forma. Ya usamos esa regla en Del prompt al Structured Output y OpenAI vs Gemini Structured Output: bloquea tokens ilegales en el decode con Schema y vuelve a validar después de la llamada.

Meter un dump de producción de 800K tokens suele fallar por razones distintas de «la ventana era demasiado pequeña»: las keys repetidas malgastan presupuesto, se pierden campos del medio, se cuentan mal las longitudes de los arrays, la salida se corta en el tope de 64K/128K y pagas la entrada completa. El orden es recortar → validar → luego alimentar.

{
  "name": "longContextPack",
  "description": "Paquete enviado a una ventana de 1M: solo JSON validado y recortado",
  "parameters": {
    "type": "object",
    "additionalProperties": false,
    "properties": {
      "task": { "type": "string", "enum": ["align_fields", "diff_versions", "extract_errors"] },
      "schemaId": { "type": "string", "description": "ID de schema estable — no pegues un schema gigante en línea" },
      "focusPaths": {
        "type": "array",
        "minItems": 1,
        "maxItems": 32,
        "items": { "type": "string", "description": "JSONPath, p. ej. $.paths./v2/orders.post" }
      },
      "payload": { "type": "object", "description": "Ya comprobado en sintaxis y recortado de tamaño — no una cadena de log en crudo" },
      "tokenBudget": { "type": "integer", "minimum": 1000, "maximum": 1000000 }
    },
    "required": ["task", "schemaId", "focusPaths", "payload", "tokenBudget"]
  }
}

Mete ese paquete en la caja de herramientas JSON para una comprobación local de sintaxis, extrae focusPaths con JSONPath y haz Diff de dos versiones del payload. El modelo debería ver un objeto recortado, no un archivo .json de 20MB. Cambia GPT / Claude / Gemini cambiando la cadena del modelo. Los nombres de campo del paquete no deberían cambiar.

Qué hacer ahora

1. Cuenta tokens antes de meter: estima sistema, tools, historial y adjuntos por separado. Reserva razonamiento en GPT-5.5; cuenta las páginas de vídeo / PDF en Gemini. Si te pasas de presupuesto, recorta — no apuestes a «debería caber todavía».
2. Pon en caché los prefijos repetidos: system + tools son casi iguales en cada llamada, así que van en prompt cache / Context Caching. La primera factura de una ventana de 1M es una factura de entrada; tras los aciertos de caché, la ventana larga se vuelve usable a diario.
3. Restringe la salida con Structured Output, no con «por favor, devuelve JSON»: response_format.json_schema de OpenAI, responseMimeType + responseJsonSchema de Gemini, tools o prefills de Claude. Una ventana más larga seguirá inventando un campo y omitiendo uno required si el prompt es laxo.
4. Más allá de la banda que mediste, recupera — no aprietes: si tu propia multi-aguja falló a 256K, no trates 700K de logs como comprensión de texto completo. JSONPath sobre códigos de error y timestamps es más barato que dejar que el modelo nade.
5. Parte las respuestas en el tope de salida: ~64K en Gemini, ~128K en GPT/Claude. Un informe JSON de 200K son fragmentos más un schema por fragmento, no una completion heroica.
6. Ejecuta fixtures locales antes de llamar a la API: el mismo payload por validación JSON y Diff en el navegador. No se sube nada. Es el mismo hábito que comprobar un contrato REST antes del lanzamiento.

Preguntas frecuentes

Conclusiones

1M tokens es el anuncio de API insignia de 2026 que GPT-5.5, Claude 4.6/4.8 y Gemini 3.7 pueden imprimir todos en una página de límites. Sirve cuando una inferencia debe ver un repo, un documento largo o un paquete JSON recortado. No es memoria gratuita, y llenarlo no es comprender. Las ventanas útiles suelen estar entre 128K y 500K; trata un 1M lleno como capacidad, no como comprensión. Los topes de salida, si el razonamiento consume la ventana y si los tokens por encima de 200K cuestan más son los verdaderos campos de selección.

El trabajo no es perseguir el siguiente rumor de «2M». Es empaquetar lo que envías para que sobreviva una comprobación de schema: JSONPath para recortar rutas, Diff para comparar versiones, validar y luego llamar a la API. Este sitio ya cubre Structured Output y Tool Calling; este artículo solo añade la lectura de la ventana de contexto.