GPT-6.1 Sol vs GPT-6 Astra: cuándo compensa el flagship
DominicodeEl domingo publiqué un post sobre GPT-6 Sol y Luna. Hoy, martes 29 de septiembre, en el DevDay 2026, OpenAI ha sacado GPT-6.1 Sol. Siete días después de GPT-6 Sol.
En el hilo de Hacker News del lanzamiento (más de 350 puntos y cerca de 300 comentarios el día del lanzamiento) el usuario glimshe lo dijo sin rodeos: notó "una degradación clara de calidad en algunos refactors simples" de 6-Sol frente a 5.6-Sol, y sospecha que la 6.1 es el arreglo.
Puede ser. Pero a mí me interesa otra cosa. El lema del anuncio oficial es "Near-Astra intelligence for a fifth of the price". Si eso es verdad, cualquier agente que hoy corre sobre Astra por defecto está pagando cinco veces de más.
Y si no lo es del todo, necesitas saber exactamente dónde no lo es.
En corto: GPT-6.1 Sol cuesta $2/$10 por millón de tokens (input/output), 1/5 que GPT-6 Astra ($10/$50), y $0.10 en input cacheado, 1/10 que Astra. En los benchmarks preliminares de OpenAI empata con Astra en coding (DeepSWE) y queda a 2,1 puntos en computer use. Mi criterio: Sol 6.1 es el modelo por defecto de un agente, y Astra pasa a ser el escalado para tareas científicas largas, computer use con efectos irreversibles y lo que Sol no supere en tu verificación.
¿Qué es GPT-6.1 Sol?
GPT-6.1 Sol es la revisión de septiembre de 2026 del modelo intermedio de OpenAI: mantiene las tarifas de GPT-6 Sol, baja a la mitad el precio del input cacheado y, según OpenAI, se acerca al rendimiento de GPT-6 Astra en coding y agentes.
La ficha oficial da 1.050.000 tokens de contexto, 128.000 de output máximo y conocimiento hasta el 30 de abril de 2026. Según TechCrunch, la tasa de error factual baja del 11,4% al 7,7% en reasoning bajo.
Dos detalles que importan si ya tienes algo en producción. GPT-6 Sol no se ha deprecado, así que no hay prisa forzada. Y no existe GPT-6.1 Astra: TechCrunch cuenta que OpenAI no la lanza por problemas de seguridad. El flagship sigue siendo el de antes.
Precio de GPT-6.1 Sol frente a Astra, GPT-6 Sol y Claude
| GPT-6.1 Sol | GPT-6 Astra | GPT-6 Sol | Claude Sonnet 5.5 | Claude Opus 5.5 | |
|---|---|---|---|---|---|
| Input (por M) | $2 | $10 | $2 | $2 | $4 |
| Input cacheado (por M) | $0.10 | $1 | $0.20 | $0.20 | $0.20 |
| Output (por M) | $10 | $50 | $10 | $10 | $20 |
| Limitación / riesgo | Benchmarks aún preliminares; en pruebas internas de OpenAI rodea salvaguardas y usa tools sin autorización más que Astra; por encima de 272K tokens de input, el mismo recargo que Astra | 5× el precio por token; por encima de 272K tokens de input, 2× en input y caché y 1,5× en output en toda la petición | 6,4 puntos por debajo de 6.1 en DeepSWE con la misma tarifa | Más caro por tarea: $1.14 frente a $0.30 de Sol 6.1 en AutomationBench (según Vellum) | $23.21 por tarea en Terminal-Bench Science, cuatro veces Sol 6.1 |
Fuentes: fichas de GPT-6.1 Sol y GPT-6 Astra; precios de Claude según la página oficial de Anthropic.
Las cuentas cuadran: $2 frente a $10 en input y $10 frente a $50 en output es 1/5. En input cacheado, $0.10 frente a $1, 1/10. Y frente a GPT-6 Sol, la 6.1 cobra lo mismo salvo la caché, que pasa de $0.20 a $0.10: un 95% de descuento sobre el input sin cachear ($0.10 frente a $2).
Benchmarks de GPT-6.1 Sol: qué dicen y quién los firma
GPT-6.1 Sol empata con GPT-6 Astra en coding (DeepSWE v1.1), queda 2,1 puntos por debajo en computer use (OSWorld 2.0) y cuesta entre 4 y 5 veces menos por tarea.
Antes de la tabla, el aviso: todas estas cifras son de OpenAI, y OpenAI las llama preliminares. Nadie independiente las ha reproducido todavía. Por qué eso importa lo expliqué en qué miden de verdad los benchmarks de IA para programar.
| Benchmark | GPT-6.1 Sol | GPT-6 Astra | Coste por tarea |
|---|---|---|---|
| DeepSWE v1.1 (coding) | Empata con Astra; +6,4 sobre GPT-6 Sol | Empate | ~$1.50 Sol 6.1 vs ~$7.70 Astra (Vellum) |
| OSWorld 2.0 (computer use) | 2,1 puntos por debajo | Gana | — |
| Terminal-Bench Science | Más del doble que GPT-6 Sol | Lidera con 68,1% | $5.47 Sol 6.1 vs $23.21 Opus 5.5 vs $23.80 Astra (The Decoder) |
| AutomationBench | 36,0%, 2,2 puntos sobre Opus 5.5 | — | $0.30 Sol 6.1 vs $1.14 Sonnet 5.5 (44,7%) (Vellum) |
Datos de The Decoder; los costes marcados, del análisis de Vellum.
Ojo con la última fila. En AutomationBench, Sonnet 5.5 acierta más: 44,7% contra 36,0%. Sol 6.1 gana en coste, no en acierto. Si tu tarea de automatización falla caro, esa diferencia de 8,7 puntos vale más que los 84 centavos.
Coste de GPT-6.1 Sol vs Astra en el mismo agente
Uso los mismos supuestos que en el post de caché y routing de Sol y Luna, para que compares. Cada llamada lleva 50.000 tokens de input: 45.000 salen de la caché y 5.000 son nuevos y se escriben en caché. Devuelve 1.000 tokens. 30.000 llamadas al mes.
| Escenario | GPT-6.1 Sol | GPT-6 Sol | GPT-6 Astra |
|---|---|---|---|
| Sin caché, por llamada | $0.110 | $0.110 | $0.550 |
| 90% cacheado, por llamada | $0.027 | $0.0315 | $0.1575 |
| 90% cacheado, 30.000 llamadas/mes | $810 | $945 | $4725 |
La escritura en caché se cobra a 1,25× el input: $2.50/M en las dos versiones de Sol y $12.50/M en Astra.
Sol 6.1 con caché: 45.000 × $0.10/M = $0.0045, más 5.000 × $2.50/M = $0.0125, más 1.000 × $10/M = $0.010. Total, $0.027.
Astra con caché: 45.000 × $1/M = $0.045, más 5.000 × $12.50/M = $0.0625, más 1.000 × $50/M = $0.050. Total, $0.1575.
Sin caché la diferencia es exactamente 5×. Con caché, 5,8× ($0.1575 / $0.027). Cuanto mejor cacheas, más te castiga quedarte en Astra. Y el salto de GPT-6 Sol a 6.1 te ahorra un 14% solo por el cambio de caché, sin tocar nada más.
Cuándo el routing GPT-6.1 Sol → Astra sale más caro
El precio por token es la mitad de la historia, como conté con el coste por tarea de GPT-6 Astra. La cuenta que decide el routing es otra. Si mandas cada tarea primero a Sol 6.1 y escalas a Astra solo cuando falla, pagas el intento de Sol más, a veces, el de Astra.
Con los costes de DeepSWE de Vellum: $1.50 + p × $7.70 frente a $7.70 de ir directo a Astra. Sol primero compensa mientras la tasa de escalado p quede por debajo del 80,5%. Ese margen es enorme.
La trampa no está ahí. Está en el fallo que no detectas. Si Sol entrega algo roto y nadie lo verifica, no escalas: lo mergeas. El routing Sol→Astra solo funciona si tienes un verificador (tests, un schema, un linter) que decide cuándo algo ha fallado. Sin eso, lo que tienes es un modelo más barato y más fallos silenciosos.
Es la misma tesis de el coste real de los sistemas agénticos está en la verificación.
Tabla de decisión: GPT-6.1 Sol vs Astra
| Criterio | Default: GPT-6.1 Sol | Escala a GPT-6 Astra |
|---|---|---|
| Coding con tests que verifican | Sí: empata en DeepSWE a 1/5 del coste | Solo si Sol falla los tests |
| Automatización de flujos (APIs, SaaS) | Sí, si el coste manda | Valora Sonnet 5.5 si el acierto manda |
| Computer use sin efectos irreversibles | Sí | Si Sol se atasca |
| Computer use con efectos irreversibles (pagos, borrados, envíos) | No por defecto | Sí: mejor en OSWorld y en las métricas de seguridad |
| Tareas científicas largas en terminal | No por defecto: Sol 6.1 cuesta $5.47 por tarea, pero Astra acierta más | Sí: lidera Terminal-Bench Science con 68,1% |
| Tarea sin verificador automático | Con revisión humana | Si un fallo cuesta más que la diferencia |
Routing Sol→Astra en TypeScript
Decide tu código, no el modelo. Sol primero, verificación, y escalado a Astra en un hilo nuevo: cambiar de model invalida la caché, así que no alternes dentro de la misma conversación.
type Model = 'gpt-6.1-sol' | 'gpt-6-astra';
interface Task {
id: string;
irreversibleEffects: boolean; // pagos, borrados, envíos
scientificTerminal: boolean;
run: (model: Model) => Promise<string>;
verify: (output: string) => Promise<boolean>; // tests, schema, linter
}
interface Result {
output: string;
model: Model;
escalated: boolean;
}
function firstModel(task: Task): Model {
if (task.irreversibleEffects || task.scientificTerminal) return 'gpt-6-astra';
return 'gpt-6.1-sol';
}
export async function runWithEscalation(task: Task): Promise<Result> {
const model = firstModel(task);
const output = await task.run(model);
const ok = await task.verify(output);
if (model === 'gpt-6-astra') {
if (!ok) throw new Error(`Task ${task.id} failed verification on gpt-6-astra`);
return { output, model, escalated: false };
}
if (ok) return { output, model, escalated: false };
// Hilo nuevo: no se reutiliza el historial de Sol, se pierde la caché igualmente
const retry = await task.run('gpt-6-astra');
if (!(await task.verify(retry))) {
throw new Error(`Task ${task.id} failed verification on both models`);
}
return { output: retry, model: 'gpt-6-astra', escalated: true };
}
Registra escalated en cada tarea. Esa tasa es tu p. En dinero, el corte está en el 80,5%. Yo no esperaría tanto: cada escalado suma la latencia de dos intentos. Si pasa del 30-40% en un tipo de tarea, deja de mandarla a Sol primero. Estás esperando el doble para acabar en Astra igualmente.
Este patrón de fallback es primo del que conté en Opus 5.5, rechazos y fallback en producción. Y montar el agente entero con este criterio, de la idea al producto, es lo que hacemos en el curso Construye con IA.
Cuándo NO pasar a GPT-6.1 Sol
Cuando le das tools con efectos y no tienes guardarraíles. En las pruebas internas de OpenAI que recoge The Decoder, Sol 6.1 rodea salvaguardas en el 23,5% de los casos frente al 17,4% de Astra. Y usa tools sin autorización con resultado no deseado en el 4,3% frente al 2,9%. Es más barato, pero se porta peor. Si migras, añade confirmación humana o allowlists en las tools que borran, pagan o envían.
Cuando no tienes verificador. Todo el ahorro depende de detectar cuándo Sol falla. Sin tests ni schema, el 1/5 del precio se convierte en revisiones manuales o en bugs en producción.
Cuando los benchmarks no se parecen a tu carga. Son cifras preliminares de OpenAI. Antes de migrar, pasa 50 tareas reales tuyas por los dos modelos y compara coste por tarea aceptada. Un día de pruebas vale más que cualquier tabla, incluida la mía.
Cuando necesitas fast mode con residencia de datos en la UE. La ficha indica que no está disponible en esa combinación. Tampoco acepta audio ni vídeo.
Lo que puedes hacer hoy
Coge el tipo de tarea que más te cuesta en Astra y que ya tenga tests. Solo ese. Pásalo a gpt-6.1-sol con el escalado del código de arriba y mide una semana la tasa de escalado.
Si queda por debajo del 30%, ya sabes dónde ahorras. Con los costes de DeepSWE, un 30% de escalado te deja la tarea en $3.81 frente a $7.70: la mitad. Con un 10%, en $2.27, más de tres veces menos. Si no, Astra se ha ganado su precio en esa tarea y lo sabes con datos.
La pieza que hace que esto funcione es la verificación, no el modelo. Cómo escribir ese contrato para revisar lo que genera un agente lo cuento en El Developer Agéntico, el ebook gratuito de Dominicode. Y si quieres que la especificación haga de verificador desde el principio, está en el libro de Spec-Driven Development.
Queda la pregunta que dejó gradus_ad en el hilo de HN: le parece ominoso para la industria y los inversores que el precio por token se esté convirtiendo en el principal campo de batalla. Para quien paga la factura, es la mejor noticia de la semana. Siempre que midas lo que compras.
Preguntas frecuentes
¿Cuánto cuesta GPT-6.1 Sol?
$2 por millón de tokens de input, $0.10 de input cacheado, $2.50 de escritura de caché y $10 de output. Son las mismas tarifas que GPT-6 Sol salvo el input cacheado, que baja de $0.20 a $0.10.
¿GPT-6.1 Sol es tan bueno como GPT-6 Astra?
En coding, según los benchmarks preliminares de OpenAI, sí: empata en DeepSWE v1.1. En computer use queda 2,1 puntos por debajo en OSWorld 2.0, y en Terminal-Bench Science Astra lidera. En las métricas internas de seguridad, Astra se porta mejor.
¿Cuánto más barato es GPT-6.1 Sol que Astra?
1/5 en input y output ($2 vs $10 y $10 vs $50) y 1/10 en input cacheado ($0.10 vs $1). En un agente con el 90% del input cacheado, la llamada sale 5,8 veces más barata. Por tarea, Vellum estima ~$1.50 frente a ~$7.70 en DeepSWE.
¿Tengo que migrar ya desde GPT-6 Sol?
No hay prisa: GPT-6 Sol no se ha deprecado. Pero la 6.1 cuesta lo mismo, cachea a mitad de precio y puntúa 6,4 puntos más en DeepSWE, así que no hay motivo para quedarse salvo que tus evals digan lo contrario.
¿Existe GPT-6.1 Astra?
No. Según TechCrunch, OpenAI no la lanza por problemas de seguridad. El flagship sigue siendo GPT-6 Astra.
¿Dónde está disponible GPT-6.1 Sol?
En la API, en ChatGPT Work y en Codex para los planes Plus, Pro, Business, Enterprise y Edu. Según TechCrunch, en el chat estándar de ChatGPT todavía no.
Por Bezael Pérez — Developer senior con más de 15 años de experiencia y fundador de Dominicode.
¿Te resultó útil este artículo?
Compártelo con tu comunidad y ayuda a otros desarrolladores.