GPT-6.2 Astra y Sol no son dos tamaños de la misma compra. Astra es el modelo de OpenAI para los proyectos más difíciles; Sol es su modelo para el trabajo cotidiano y para agentes de alto volumen. Con las tarifas de lista estándar de contexto corto, Astra cuesta cuatro veces más por token de entrada y de salida. La pregunta práctica, por tanto, no es qué modelo suena más potente, sino cuál supera tu listón de aceptación al costo por tarea utilizable más bajo, y cuándo vale la pena pagar un sobreprecio por una salida mejor.
Alcance y evidencia. OpenAI publicó el lanzamiento de GPT-6.2 Astra y Sol el 17 de noviembre de 2026. Las especificaciones y los precios de lista a continuación provienen del anuncio de lanzamiento de OpenAI y de las páginas oficiales de modelo, comprobados el 18 de noviembre de 2026. Esta es una guía de planificación, no un informe de benchmark: no ejecutamos ninguno de los modelos, no medimos latencia ni puntuamos salidas. El ejemplo de costo es aritmética a partir de las tarifas oficiales más los supuestos indicados. El catálogo internacional de ToAPIs lista Astra y Sol; usa el catálogo en vivo para las variantes, tarifas y enrutamiento disponibles en tu cuenta. Este artículo no afirma tarifas, rutas de endpoint ni cobertura regional específicas de la plataforma.
1. Los hechos oficiales que anclan la decisión
El anuncio de lanzamiento de OpenAI posiciona Astra para trabajo profesional complejo — presentaciones, hojas de cálculo, documentos, programación, uso del ordenador y razonamiento visual — y Sol para tareas técnicas y no técnicas del día a día, incluidos flujos agénticos de varios pasos. Ambos aceptan texto e imágenes y devuelven texto. Las páginas oficiales de modelo listan los mismos límites de contexto y de salida para cada uno:
| Especificación | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| ID de modelo de API | gpt-6.2-astra | gpt-6.2-sol |
| Posicionamiento de OpenAI | Los proyectos más difíciles, de principio a fin | Trabajo cotidiano y agentes a escala |
| Modalidades de entrada | Texto, imagen | Texto, imagen |
| Salida | Texto | Texto |
| Ventana de contexto | 1,050,000 tokens | 1,050,000 tokens |
| Entrada máxima | 922,000 tokens | 922,000 tokens |
| Salida máxima | 128,000 tokens | 128,000 tokens |
| Corte de conocimiento | 18 de mayo de 2026 | 1 de junio de 2026 |
| Ajuste de razonamiento | Máximo; se rechaza none | Máximo; se rechaza none |
| Ajuste fino | No admitido | No admitido |
La diferencia económica principal es el precio, no un límite de contexto distinto:
| Tarifa oficial estándar de contexto corto | Astra | Sol | Astra / Sol |
|---|---|---|---|
| Entrada, por 1M de tokens | $8.00 | $2.00 | 4x |
| Entrada en caché, por 1M de tokens | $0.40 | $0.10 | 4x |
| Salida, por 1M de tokens | $40.00 | $10.00 | 4x |
| Escritura de caché de 30 minutos, por 1M de tokens | $10.00 | $2.50 | 4x |
Fuente: página de precios de la API de OpenAI y páginas de modelo, comprobadas el 18 de noviembre de 2026. Las tarifas están en USD por millón de tokens, antes de impuestos y de cualquier cargo de la plataforma. Son precios de lista de referencia, no una cotización de ToAPIs.
OpenAI también hace afirmaciones de rendimiento reportadas por el proveedor. Dice que Sol queda a 0.5 puntos de Astra en el FrontierCode 2.0 de Cognition con cerca de un quinto del costo (ambos con razonamiento máximo), e informa a Astra con 1,318 Elo frente a los 1,259 de Sol en la evaluación de preferencia humana AA-3D de Artificial Analysis. Son resultados reportados por el proveedor en configuraciones que no auditamos. Úsalos como hipótesis; tus prompts, herramientas y reglas de aceptación pueden producir un orden distinto.
2. La brecha de precio de 4x: qué tiene que cumplirse para Astra
Con las tarifas de lista estándar de contexto corto, Astra y Sol tienen la misma relación 4:1 en entrada, salida y entrada en caché. Si ambos modelos consumen la misma cantidad de tokens facturables y necesitan el mismo número de intentos, Astra no puede tener un costo por tarea aceptada más bajo salvo que su tasa de aceptación sea más de cuatro veces la de Sol. Como la aceptación está limitada al 100%, eso se vuelve imposible cuando la tasa de aceptación de Sol supera el 25%.
Esa afirmación tiene un alcance estrecho: mismo volumen de tokens, mismos intentos, mismas unidades facturables. Aun así es un punto de partida útil, porque muestra cuánto tiene que ser mayor la brecha de calidad antes de que Astra gane solo por costo. La sensibilidad del punto de equilibrio es así:
| Tasa de aceptación de Sol | Aceptación de Astra necesaria para igualar el costo por tarea aceptada de Sol |
|---|---|
| 10% | 40% |
| 15% | 60% |
| 20% | 80% |
| 25% | 100% |
| 30% | 120% (no alcanzable) |
| 50% | 200% (no alcanzable) |
Supone conteos de tokens e intentos idénticos por tarea, y que cada intento se factura. Un perfil de tokens distinto cambia el punto de equilibrio.
El marco de punto de equilibrio no es un argumento de que Astra está sobrevalorado. Es un argumento en contra de tratar la etiqueta "mejor modelo" como política de enrutamiento. Astra puede ser racional cuando la salida de Sol es inutilizable, cuando una respuesta incorrecta es costosa o cuando la reparación humana cuesta más que el sobreprecio de tokens. Rara vez es la opción predeterminada para clasificación, extracción o respuestas breves de soporte rutinarias.
Tres matices importan:
- La eficiencia de tokens puede mover el ratio. Si Astra alcanza la aceptación con materialmente menos tokens de salida o menos intentos, su sobreprecio efectivo queda por debajo de 4x. No tenemos mediciones emparejadas, así que no afirmamos una cifra.
- El ratio no es la factura. Por encima de 272,000 tokens de entrada, las tarifas de entrada y caché se duplican y la salida cuesta 1.5x sobre toda la solicitud. La relación 4:1 de tarifas de lista se mantiene, pero los costos absolutos suben; no reutilices ejemplos de contexto corto para trabajo de contexto largo.
- Otras unidades facturables pueden romper el ratio. Las llamadas a herramientas, los contenedores, la búsqueda de archivos, los modos batch o Fast, Ultrafast, las ventanas en segundo plano, los incrementos regionales, los impuestos y las comisiones de plataforma quedan fuera de esta aritmética. Comprueba la página de precios oficial y la tarifa de tu cuenta.
3. Mapa de escenarios: dónde cada modelo se gana su lugar
La decisión se aclara cuando nombras la carga de trabajo, el costo del fallo y el volumen. La tabla siguiente es una política de partida, no una afirmación sobre calidad medida.
| Carga de trabajo | Empieza con | Escala a Astra cuando | Principal impulsor de costo |
|---|---|---|---|
| Soporte, clasificación y extracción de alto volumen | Sol | Los casos ambiguos o de alto valor fallan la rúbrica, o una respuesta incorrecta desencadena una revisión manual costosa | Intentos por tarea y tasa de aceptación |
| Tareas de código acotadas, generación de tests, revisión de PR | Sol | El cambio abarca varios archivos, exige criterio de diseño, o una regresión es cara de detectar después | Costo por tarea aceptada más tiempo de revisión |
| Presentaciones, hojas de cálculo, memorandos, entregables para clientes | Sol para borradores | La fidelidad a la plantilla, la síntesis factual y la usabilidad en la primera pasada determinan si el entregable sirve | Retrabajo y tiempo de revisión |
| Agentes de horizonte largo y flujos con herramientas | Sol para la ejecución | La planificación o los pasos ambiguos fallan repetidamente, o el agente necesita criterio visual o de uso del ordenador más fuerte | Tokens acumulados y reintentos |
| Frontends visuales, 3D, CAD e interactivos | Sol para páginas simples | La precisión espacial, la calidad visual o un uso detallado del ordenador determinan el resultado para el usuario | Reintentos y revisión humana |
| Procesamiento batch sin conexión | Sol | Un filtro de calidad rechaza demasiadas salidas de Sol, o la tarea es intrínsecamente de frontera | Descuentos batch y tasa de rechazo |
Soporte y extracción de alto volumen: Sol es la opción económica predeterminada
Un pipeline de triaje de soporte o de extracción de facturas puede procesar miles de solicitudes cortas al día, con unos pocos miles de tokens de entrada y una etiqueta breve o una salida JSON. La tarifa de $2/$10 de Sol es una ventaja grande, y su contexto de 1.05M iguala el de Astra, así que la capacidad de contexto no es razón para subir de nivel. Escala solo fallos concretos: un fallo de esquema en una cuenta de alto valor, documentos de origen contradictorios, o un error que desencadena una revisión de reembolso o de cumplimiento. Mide esa cohorte; no muevas toda la cola porque una demostración se veía mejor.
Cambios de código en todo el repositorio: la calidad aparece como tiempo de revisión
Para un arreglo de una línea, Sol es el primer intento sensato. Para una refactorización de varios archivos con diseño poco claro, el costo real incluye la lectura de ingenieros sénior, la búsqueda de puntos de llamada omitidos y la reparación de tests. Si Sol necesita varias rondas mientras Astra produce un cambio integrable en una o dos, Astra puede salir más barato por cambio aceptado pese al precio de tokens 4x. La aceptación tiene que ser ejecución: aplica el parche y ejecuta los tests en un entorno desechable; un diff plausible no basta.
Entregables profesionales: el sobreprecio de Astra es más fácil de justificar
Las presentaciones, los libros de valoración, los resúmenes legales y los memorandos para clientes tienen costos de retrabajo altos. Una presentación que ignora la plantilla o un memorando que omite una cláusula obligatoria pueden consumir más tiempo humano que la tarifa del modelo. OpenAI posiciona Astra para convenciones profesionales y fidelidad a plantillas. Aun así, haz una revisión a ciegas con la plantilla real: si el borrador de Sol sirve, paga Sol; si necesita reestructurarse, compara el tiempo de revisión con el sobreprecio de Astra.
Agentes y flujos visuales: separa el planificador del ejecutor
Los flujos agénticos acumulan contexto, así que la brecha de precio se compone. Un patrón habitual es Sol para llamadas de herramientas rutinarias, extracción y respuestas cortas, con Astra reservado para planificación, decisiones ambiguas o pasos visuales o de uso del ordenador que determinan la trayectoria. Define presupuestos de tokens e intentos por tarea. Registra la traza completa y evalúa la tarea completada, no el mejor mensaje intermedio.
4. Un ejemplo de costo sencillo
Toma una tarea que usa 10,000 tokens de entrada y 2,000 de salida por llamada, con las tarifas de lista estándar de contexto corto de OpenAI. Cada llamada es un intento, y cada llamada se factura:
- Sol: $0.02 de entrada más $0.02 de salida = $0.04 por llamada.
- Astra: $0.08 de entrada más $0.08 de salida = $0.16 por llamada.
Si Sol acierta en su segundo intento, la tarea cuesta $0.08. Si Astra acierta en su primer intento, cuesta $0.16. Si Sol necesita cinco intentos, cuesta $0.20, más que la única llamada exitosa de Astra. El sobreprecio, por tanto, vale la pena solo cuando Astra evita suficientes reintentos o edición como para cerrar esa brecha. Los conteos de intentos son supuestos para ilustrar, no mediciones; usa tus propios registros.
Esa es la versión práctica del costo por tarea aceptada: cuenta cada llamada facturada y luego pondera el total en dólares contra el tiempo que pasas haciendo utilizable el resultado.
Estas cifras son una estimación de planificación a partir de los precios estándar de contexto corto publicados por OpenAI, suponiendo entrada por debajo de 272,000 tokens por solicitud. Excluyen aciertos y escrituras de caché, cargos de herramientas, precios batch, Fast, Ultrafast o de ventana en segundo plano (incluidos descuentos), incrementos regionales, impuestos, comisiones de plataforma y tiempo de revisión o edición humana. No son una cotización de ToAPIs; comprueba el catálogo de modelos y la página de precios para las tarifas en vivo de tu cuenta.
5. Cómo elegir en tres pasos
- Empieza con Sol. Ejecuta la tarea real, o una muestra pequeña de ella, con Sol usando tu prompt de producción y tus reglas de salida. Registra si cada resultado pasa, cuántas llamadas tomó y cuánto tiempo pasaste arreglándolo.
- Prueba Astra en los fallos concretos. Si Sol falla por una razón que un modelo más potente podría arreglar — instrucciones ambiguas, criterio de diseño débil, un paso visual difícil — ejecuta las mismas entradas con Astra. No muevas toda la carga de trabajo porque una demostración se veía mejor.
- Compara el costo total de llamadas y el tiempo de edición. Suma cada llamada facturada a la tarifa por llamada de cada modelo y luego pon al lado el tiempo que pasas revisando o reparando la salida. Elige Astra solo cuando su costo extra de llamadas queda cubierto por menos reintentos, menos edición o un menor costo de error.
Para la integración de API, usa el catálogo de modelos, la página de precios y la documentación de la API. Para los ID de modelo y una primera solicitud, consulta la guía de la API de GPT-6.2 que acompaña este artículo. Comprueba el catálogo en vivo para las variantes, tarifas y regiones disponibles en tu cuenta; este artículo no afirma tarifas, rutas de endpoint ni cobertura regional específicas de la plataforma.
6. Preguntas frecuentes
¿Astra vale 4x el precio?
Solo cuando la calidad incremental cambia el resultado lo suficiente como para justificar el sobreprecio. Para trabajo rutinario y bien especificado, Sol es difícil de superar. Para entregables de alto valor, cambios de código costosos o fallos repetidos de Sol, Astra puede salir más barato por tarea realmente utilizable pese a la tarifa de tokens más alta.
¿El precio más bajo de Sol significa menor calidad en programación?
OpenAI informa que Sol queda a 0.5 puntos de Astra en FrontierCode 2.0 con cerca de un quinto del costo (ambos al máximo). Esa es una afirmación del proveedor, no un resultado para tu repositorio. Prueba la aplicabilidad de los parches, la tasa de tests que pasan, el esfuerzo de revisión y el riesgo de regresión.
¿Cómo debería contabilizar la entrada en caché?
La entrada en caché cuesta $0.40 por millón en Astra frente a $8.00 sin caché; Sol cuesta $0.10 frente a $2.00. Las escrituras de caché son aparte. Si reutilizas prompts o documentos largos, mide la tasa de aciertos de caché en lugar de suponer precios sin caché. El ejemplo supone que no hay beneficio de caché.
¿Y los prompts largos por encima de 272K tokens?
Calcúlalos aparte. Por encima de 272,000 tokens de entrada, las tarifas de entrada y caché se duplican y la salida cuesta 1.5x la tarifa de contexto corto sobre toda la solicitud. La relación 4:1 de tarifas de lista se mantiene, pero los costos absolutos suben; mantén el trabajo de contexto largo fuera de las estimaciones de contexto corto.
¿Puedo usar ToAPIs para ejecutar esta comparación?
El catálogo internacional de ToAPIs lista Astra y Sol, pero este artículo no afirma tarifas, endpoints ni cobertura regional específicos de la plataforma. Comprueba el catálogo en vivo y la página de precios. El arnés de comparación del apéndice para desarrolladores apunta por defecto a la API oficial de OpenAI; si usas otro endpoint compatible con OpenAI, confirma los ID de modelo, los campos y las unidades de facturación.
7. Fuentes y método
- OpenAI: Introducing GPT-6.2 Astra and Sol, publicado el 17 de noviembre de 2026 — posicionamiento de lanzamiento, disponibilidad y resultados reportados por el proveedor.
- Página de modelo de OpenAI: GPT-6.2 Astra — ID de modelo, límites de contexto, modalidades, herramientas y precios, comprobados el 18 de noviembre de 2026.
- Página de modelo de OpenAI: GPT-6.2 Sol — ID de modelo, límites de contexto, modalidades, herramientas y precios, comprobados el 18 de noviembre de 2026.
- Precios de la API de OpenAI — términos de standard, caché, contexto largo, batch, Fast y Ultrafast, comprobados el 18 de noviembre de 2026.
- ToAPIs: guía de la API de GPT-6.2 — configuración y precios específicos de la plataforma; artículo complementario.
Nota sobre el método. Las cifras en dólares son aritmética determinista a partir de las tarifas de lista publicadas y de los supuestos de tokens e intentos del ejemplo. No son facturas, cotizaciones ni resultados medidos. No se realizó ninguna inferencia de modelo, medición de latencia, puntuación de calidad ni revisión a ciegas para este artículo, y el arnés de comparación del apéndice para desarrolladores no se ejecutó. Sustituye las tarifas, los conteos de tokens y los conteos de intentos por tus propios datos de prueba piloto antes de tomar una decisión de producción.
Apéndice para desarrolladores: ejecuta tu propia comparación
El protocolo siguiente está diseñado para producir evidencia para tu propia carga de trabajo. Deliberadamente no es una tabla de clasificación. La comparación no se ejecutó para este artículo, y aquí no se reportan salidas de modelo ni cifras de latencia.
Diseño de la prueba
- Congela el conjunto de tareas. Usa entre 20 y 50 casos representativos, incluidos casos fáciles que protegen el comportamiento existente y casos difíciles que distinguen los modelos. Elimina los datos confidenciales o reemplázalos por equivalentes sintéticos.
- Congela la solicitud. Usa el mismo prompt de sistema, entrada de usuario, herramientas, esquema de salida y presupuesto de tokens para ambos modelos siempre que los contratos lo permitan. Registra las diferencias inevitables.
- Repite las tareas no deterministas. Conserva la distribución y los fallos, no solo la mejor salida.
- Puntúa a ciegas. Elimina la etiqueta del modelo antes de la revisión. Una tarea pasa solo cuando supera todas las comprobaciones obligatorias; una respuesta pulida que omite un campo, inventa un identificador o falla un test es un fallo.
- Cuenta los intentos facturados y separa la latencia. Los intentos fallidos pertenecen al numerador del costo cuando se facturan. Informa por separado el tiempo hasta el primer token, el tiempo de finalización y el tiempo hasta un resultado aceptado, y declara qué incluye el cronómetro.
Un conjunto mínimo de casos puede verse así:
| Caso | Tarea | Comprobaciones de aceptación |
|---|---|---|
extract-01 | Extraer artículo y cantidad de un mensaje de pedido corto | JSON válido; claves exactas; la cantidad es un entero; sin valores inventados |
code-01 | Implementar una función con condiciones límite | El parche aplica; los tests pasan; la entrada inválida se rechaza; sin cambios no relacionados |
clarify-01 | Responder a una solicitud de estado de pedido sin ID de pedido | Pide el ID; no lo inventa; ninguna acción de escritura |
memo-01 | Convertir un paquete de fuentes dado en un memorando de una página | Todas las secciones obligatorias presentes; cifras rastreables a la fuente; ninguna afirmación no respaldada |
El arnés llama al endpoint oficial de Chat Completions de OpenAI con ambos ID de modelo, registra el uso, la latencia, los identificadores de modelo solicitados y devueltos y las marcas de tiempo, y deja accepted para un revisor humano. Requiere una clave de API y solo hace llamadas facturables con --execute. estimate_cost ignora los aciertos de caché, los descuentos por modo de facturación y las comisiones de plataforma, así que concílialo con el uso facturado. No uses datos de producción; no supongas que un agregador conserva los ID de modelo o las tarifas.
#!/usr/bin/env python3
"""Reusable GPT-6.2 Astra vs Sol comparison harness.
The comparison was not executed for the accompanying article. Requires OPENAI_API_KEY and
explicit --execute consent because calls are billable. Acceptance is manual.
"""
from __future__ import annotations
import argparse
import json
import os
import time
import urllib.request
from datetime import datetime, timezone
from pathlib import Path
API_URL = os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1").rstrip("/") + "/chat/completions"
MODELS = ("gpt-6.2-astra", "gpt-6.2-sol")
RATES = {
"gpt-6.2-astra": {"input": 8.00, "output": 40.00},
"gpt-6.2-sol": {"input": 2.00, "output": 10.00},
}
CASES = [
{
"id": "extract-01",
"system": "Return only valid JSON with exactly the keys item and quantity.",
"user": "Please order 3 blue mugs.",
"rubric": ["valid JSON", "item is blue mugs", "quantity is the integer 3"],
},
{
"id": "code-01",
"system": "Return a unified diff only. Do not include commentary.",
"user": (
"Implement merge_intervals(intervals) so overlapping or adjacent "
"intervals are merged. Reject invalid ranges. Include tests."
),
"rubric": ["patch applies", "tests pass", "invalid ranges rejected"],
},
{
"id": "clarify-01",
"system": "You are an order-support agent. Never invent identifiers.",
"user": "Where is my order?",
"rubric": ["asks for order ID", "does not invent an ID", "no write action"],
},
]
def estimate_cost(model: str, prompt_tokens: int, completion_tokens: int) -> float:
rate = RATES[model]
return (
prompt_tokens * rate["input"] + completion_tokens * rate["output"]
) / 1_000_000
def call_model(model: str, case: dict) -> dict:
body = json.dumps(
{
"model": model,
"messages": [
{"role": "system", "content": case["system"]},
{"role": "user", "content": case["user"]},
],
"max_completion_tokens": 8000, # fixed cap for this comparison
}
).encode("utf-8")
request = urllib.request.Request(
API_URL,
data=body,
headers={
"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}",
"Content-Type": "application/json",
},
)
started = time.perf_counter()
with urllib.request.urlopen(request, timeout=180) as response:
payload = json.load(response)
elapsed = time.perf_counter() - started
usage = payload.get("usage", {})
prompt_tokens = usage.get("prompt_tokens", 0)
completion_tokens = usage.get("completion_tokens", 0)
return {
"requested_model": model,
"returned_model": payload.get("model"),
"api_url": API_URL,
"timestamp_utc": datetime.now(timezone.utc).isoformat(),
"case_id": case["id"],
"run": None,
"latency_seconds": round(elapsed, 3),
"prompt_tokens": prompt_tokens,
"completion_tokens": completion_tokens,
"cost_usd": round(estimate_cost(model, prompt_tokens, completion_tokens), 6),
"output": payload["choices"][0]["message"]["content"],
"rubric": case["rubric"],
"accepted": None,
"reviewer": None,
"review_notes": None,
}
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--execute", action="store_true", help="make billable API calls")
parser.add_argument("--repeats", type=int, default=1)
parser.add_argument("--out", default="gpt-6-2-runs.jsonl")
args = parser.parse_args()
if not args.execute:
print("Dry plan only. Re-run with --execute after checking access, budget and data rules.")
for case in CASES:
print(json.dumps({"case": case["id"], "models": MODELS, "repeats": args.repeats}))
return
if not os.environ.get("OPENAI_API_KEY"):
raise SystemExit("Set OPENAI_API_KEY first.")
output = Path(args.out)
with output.open("a", encoding="utf-8") as handle:
for case in CASES:
for model in MODELS:
for run in range(args.repeats):
record = call_model(model, case)
record["run"] = run + 1
handle.write(json.dumps(record, ensure_ascii=False) + "\n")
print(json.dumps({
"case_id": record["case_id"],
"model": record["requested_model"],
"latency_seconds": record["latency_seconds"],
"cost_usd": record["cost_usd"],
}))
print(f"Wrote {output}. Fill 'accepted' manually against each rubric before comparing costs.")
if __name__ == "__main__":
main()
Tras la revisión, calcula el número central para la decisión de enrutamiento:
import json
from pathlib import Path
rows = [json.loads(line) for line in Path("gpt-6-2-runs.jsonl").read_text().splitlines()]
if not rows or any(type(row["accepted"]) is not bool for row in rows):
raise SystemExit("Review every row before comparing costs.")
for model in sorted({row["requested_model"] for row in rows}):
model_rows = [row for row in rows if row["requested_model"] == model]
accepted = sum(row["accepted"] is True for row in model_rows)
estimated = sum(row["cost_usd"] for row in model_rows)
per_accepted = estimated / accepted if accepted else None
print(model, {"accepted": accepted, "estimated_usd": round(estimated, 4),
"cost_per_accepted": round(per_accepted, 4) if per_accepted is not None else None})
El arnés no prueba la ejecución de herramientas, porque ejecutar código o comandos de shell generados por el modelo introduce problemas de seguridad y reproducibilidad. Si tu flujo de trabajo usa herramientas, evalúa la traza de herramientas por separado: argumentos válidos, autorización, efectos secundarios, reintentos y si una pregunta de aclaración era la acción correcta. Un modelo que escribe una respuesta perfecta pero llama mal a una herramienta destructiva no ha superado la tarea.







