¿Qué es Structured Output? Por qué GPT, Gemini y Claude fuerzan JSON

De entrada: Structured Output no es el prompt «devuelve JSON». Es la API bloqueando tokens ilegales en tiempo de decodificación con un JSON Schema, para que un programa pueda parsear la respuesta final. GPT, Gemini y Claude lo convirtieron en una capacidad de primera clase no porque la frase quede bien en una diapositiva, sino porque los agentes, la extracción y el relleno de formularios tienen que conectar el modelo a un pipeline. La prosa falla en JSON.parse. Contra el schema posterior falla todavía más.

Este artículo está fechado el 8 de septiembre de 2026. Los tres ya pueden restringir el JSON final hacia el usuario o el siguiente servicio: OpenAI con response_format.json_schema (strict), Gemini con responseMimeType + responseJsonSchema, Claude con el GA output_config.format (el output_format beta antiguo sigue funcionando en la transición). Cómo rellenar los campos, y en qué se diferencian los subconjuntos, ya lo desglosamos en agosto. Este texto responde dos preguntas: qué es, y por qué los tres tuvieron que sacarlo. Para el cómo, consulta Del prompt al Structured Output. Para OpenAI vs Gemini, consulta la comparación de APIs de Structured Output.

Qué es Structured Output

Structured Output significa: tú entregas un JSON Schema, y la respuesta final del modelo tiene que ser JSON que coincida con él. La garantía ocurre mientras se genera cada token, no después de que el modelo «intente parecer JSON». Los nombres cambian: OpenAI dice Structured Outputs, Google dice Structured Output, Anthropic escribe structured outputs / JSON outputs. La s de más es marca. El trabajo es el mismo.

Piénsalo como compilador y comprobador de tipos. Un prompt es un comentario — el modelo puede hacer caso. Un Schema es el sistema de tipos — un nombre de campo incorrecto, un required que falta, un string donde corresponde un number, nunca se emiten. Lo que recibe tu programa es un objeto, no prosa envuelta en una valla ```json.

Un Schema que los tres pueden leer suele ser plano: raíz object, properties / required explícitos, additionalProperties: false. En el strict de OpenAI, «opcional» suele ser nullable en lugar de sacarse de required. Los subconjuntos no son idénticos; toma primero la intersección.

{
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "task": { "type": "string", "enum": ["extract", "classify", "summarize"] },
    "ok": { "type": "boolean" },
    "fields": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "orderId": { "type": "string" },
        "total": { "type": "number" },
        "note": { "type": ["string", "null"] }
      },
      "required": ["orderId", "total", "note"]
    }
  },
  "required": ["task", "ok", "fields"]
}

No es JSON Mode, ni Tool Calling

Tres nombres se reducen a uno. No están en la misma capa:

JSON Mode solo garantiza que las llaves cierren y que JSON.parse tenga éxito. El modelo aún puede inventar order_id cuando pediste orderId, o emitir el importe como string. En producción, «parsea» no es «se puede insertar».

Tool Calling / Function Calling restringe la mano que busca una herramienta, no la última frase al usuario. Las consultas de inventario, las escrituras de archivos y el tools/call de MCP van en el Schema de herramientas. Extraer correo, clasificar un ticket, emitir JSON para una API posterior van en Structured Output. Un agente completo suele activar las dos — argumentos en tools, la respuesta final en un Schema de salida. Para las capas consulta Qué es MCP y el flujo de datos JSON del Agent.

Por qué los tres empezaron a soportarlo

En 2023 aún podías apostar a un prompt. En 2026 un agente mete el modelo en un bucle: la salida llega a una base de datos, a la siguiente herramienta o al modelo de otro proveedor. Los tres laboratorios no se coordinaron un ciclo de prensa. Chocaron con la misma presión de producto y el mismo contrato: JSON Schema.

1. Quien consume después es un programa, no un lector. El chat puede ser prosa. Un pipeline necesita objetos. Una coma que falta, un campo renombrado, y la cola nocturna de reintentos se llena. Los proveedores prefieren cortar las rutas ilegales en el decodificador antes que ver a cada cliente escribir un reparador.
2. Los agentes convirtieron la forma estable en un requisito. En un bucle de varios pasos, el JSON del turno anterior es la entrada de este. Una deriva y todo lo que sigue está mal. Tool Calling responde «cómo extender la mano». Structured Output responde «cómo devolver la conclusión». Los dos necesitan un Schema — consulta si JSON Schema se está convirtiendo en el contrato del Agent.
3. Los prompts demostraron que no bastaban. «Solo JSON, sin markdown» se ve bien en un banco de pruebas, y luego omite campos, añade vallas y parafrasea enums cuando el contexto es largo, las herramientas se reinyectan o se mezclan idiomas. La decodificación restringida convierte el «a veces» en un 400 de la API o en un error de Schema reintentable.
4. JSON Schema ya era el mínimo común denominador. OpenAPI, el inputSchema de MCP, las exportaciones de Pydantic / Zod: todo eso. Un IDL privado del lado del modelo obligaría al Host a traducir dos veces. Enganchar la respuesta final al mismo Schema es lo que abarata el cambio de proveedor.
5. La carrera pasó a ser «¿esto puede ir a producción?», no «¿sabe chatear?». En cuanto un proveedor sacó una restricción dura, los gateways, los frameworks de agentes y las listas de adquisición lo escribieron como obligatorio. Los otros dos o siguen o no se enchufan al mismo grafo. En septiembre de 2026, una API insignia sin Structured Output es difícil de vender a quien inserta filas.

Por eso las fechas se agrupan: OpenAI hizo GA Structured Outputs en agosto de 2024; Gemini metió MIME + Schema en la configuración de generación; Claude aún iba con un encabezado beta a finales de 2025 y ahora envía output_config.format como campo estable. Los nombres nunca coincidieron. La presión, sí.

Cómo lo activan GPT, Gemini y Claude

Alinea el concepto. No pegues campos de un proveedor a otro. La tabla es lo que puedes poner en un documento el 8 de septiembre de 2026 — no un tutorial completo del SDK.

Los envoltorios difieren. El cuerpo del Schema debería ser el mismo archivo. Cambiar de modelo cambia el sobre, no orderId ni required. Un bosquejo de Claude (campos de la spec; sustituye por tu Schema de negocio):

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "messages": [
    {"role": "user", "content": "Extract orderId and total from the order text"}
  ],
  "output_config": {
    "format": {
      "type": "json_schema",
      "schema": {
        "type": "object",
        "additionalProperties": false,
        "properties": {
          "orderId": { "type": "string" },
          "total": { "type": "number" }
        },
        "required": ["orderId", "total"]
      }
    }
  }
}

OpenAI pone el mismo schema en response_format.json_schema y activa strict. Gemini lo pone en responseJsonSchema y declara el MIME de JSON. El Python lado a lado sigue en OpenAI vs Gemini. Las superficies de producto (ChatGPT / claude.ai / la app web de Gemini) no siempre exponen la misma restricción dura. Escribe el SLA contra la API que realmente llamas.

Qué bloquea realmente la decodificación restringida

Sin Structured Output el modelo muestrea todo el vocabulario y espera que el prompt lo haga parecer JSON. Con Structured Output el decodificador mantiene un prefijo legal a partir del Schema: el siguiente token solo puede ser algo que siga siendo válido — una ", orderId, true o }. Las rutas ilegales quedan con probabilidad cero.

Bloquea la forma: comas finales, vallas markdown, campos required que faltan, deriva de tipos, keys de más cuando additionalProperties es false. No bloquea la invención: total es un number y el número puede estar inventado; un valor legal de enum puede seguir siendo el equivocado. En producción se vuelve a pasar el mismo Schema por un validador; si falla, reintentas, degradas o vas a una persona. La decodificación restringida recorta incidentes de parseo, no alucinaciones.

Una ventana más grande no cambia eso. 1M tokens solo ensanchan lo visible; no restringen la forma de la salida. Si metes un dump, igual necesitas un Schema — consulta ventanas de contexto de 1M tokens.

Qué hacer ahora

1. Escribe el Schema antes de elegir el modelo. Los nombres de campo, las listas required y los enums son el contrato de producto. GPT / Gemini / Claude son backends intercambiables. El contrato vive en el repositorio, no en el prompt.
2. Extracción, clasificación, relleno de formularios → Structured Output. Efectos secundarios → Tool Calling. No pretendas que Structured Output ya llamó a la API de inventario. La reutilización entre procesos es cuando añades MCP.
3. Toma la intersección del Schema entre proveedores: objects planos, additionalProperties: false, $ref poco profundos, sin anyOf en la raíz. El strict de OpenAI convierte «opcional» en nullable. No mantengas tres tablas de campos que se desvían.
4. Que la API pase no es la última comprobación. Guarda el Schema y dos o tres fixtures buenos / malos como JSON; valida y haz Diff en este sitio. No se sube nada. Esa es la segunda puerta después de la decodificación restringida.
5. Devuelve los fallos como estructura: si falla el parseo o el segundo validador, devuelve un objeto (qué campo, tipo esperado). No viertas un stack en crudo en el siguiente turno.

FAQ

Conclusiones

Structured Output es el enchufe de las APIs insignia de 2026: la respuesta final se decodifica contra un JSON Schema, y los programas dejan de apostar a las llaves de un prompt. GPT, Gemini y Claude lo sacaron porque los agentes y la extracción escribieron «forma estable» en las pruebas de aceptación, y JSON Schema era el contrato que los tres ya hablaban. No es JSON Mode. No sustituye Tool Calling ni MCP.

Cambia el modelo, cambia solo los campos del envoltorio. Deja los nombres de campo y required en el repositorio, y valida muestras en local contra el mismo Schema antes de salir a producción. Cómo configurar cada API, y cómo se separa de la capa de herramientas, este sitio ya lo cubre. Este artículo solo deja inequívocos el «qué» y el «por qué».