El mejor LLM para programar en 2026: 9 modelos destacados

En febrero de 2025, Claude 3.7 Sonnet marcó un 62,3% en SWE-bench Verified, o un 70,3% con un andamiaje personalizado, mientras que el mejor modelo de pesos abiertos del momento, DeepSeek-R1, reportó 49,2% en su paper.

Había una brecha de 13 a 21 puntos, según cuánta ayuda con andamiaje concedieras.

Para septiembre de 2026, el panel independiente de Vals AI para SWE-bench Verified sitúa a Claude Opus 5 en 97,0% y al modelo de pesos abiertos DeepSeek V4 Pro 0813 en 96,4%, y Vals archivó el benchmark porque se saturó.

La frontera se movió hacia evaluaciones agentivas más duras como SWE-bench Pro y Terminal-Bench 4.0; los pesos abiertos alcanzaron a los antiguos, y la pregunta "mejor LLM para programar" pasó a ser "mejor para qué, en qué hardware y a qué precio".

Voy a responder a esa pregunta para los 9 modelos que hoy sí tendría en cuenta, y la versión corta es que Claude Opus 5.5 es el que la mayoría de equipos deberían usar de partida.

Una nota antes del ranking: este artículo va de los modelos en sí, no de las herramientas que los envuelven. Si quieres la comparación entre Cursor, Copilot y Windsurf, nuestro resumen de los mejores asistentes de IA para programar en 2026 lo cubre.

En resumen: los mejores LLM para programar en septiembre de 2026

Claude Opus 5.5 es ahora tanto el modelo de programación más fuerte en la mayoría de benchmarks como el que la mayoría de desarrolladores deberían usar por defecto; Claude Fable 5.1 es al que escalar para trabajos de horizonte más largo, y Qwen3.8-27B es el modelo de pesos abiertos para ejecutar con una sola GPU. Estas son las mejores elecciones según el propósito:

• Mejor en general para programación agentiva: Claude Opus 5.5 (Anthropic), 89,9% en SWE-bench Pro y 66,4% en Terminal-Bench 4.0, a 4 $ de entrada y 20 $ de salida por millón de tokens.
• Mejor para trabajos de horizonte más largo: Claude Fable 5.1 (Anthropic), 81,2% en SWE-bench Pro y la mejor puntuación en Terminal-Bench 2.1 en Artificial Analysis (91,4%), a 10 $ de entrada y 50 $ de salida por millón de tokens.
• Mejor modelo de OpenAI para programar: GPT-6 Astra (OpenAI), primero en el ranking de agentes de Terminal-Bench 4.0 de tbench.ai con 58,2%, y empatado con Opus 5.5 en 59,6% en la corrida de Artificial Analysis.
• Mejor relación calidad-precio de un laboratorio de frontera: Gemini 3.8 Flash (Google), 89,4% en Terminal-Bench 2.1 por 0,75 $ de entrada y 3,75 $ de salida por millón de tokens hasta el 31 de diciembre de 2026.
• Mejores pesos abiertos vía API: DeepSeek V4.1 Flash, licencia MIT, 90,6% en Terminal-Bench 2.1, 0,60 $ por millón de tokens de salida en horas valle.
• Mejores pesos abiertos que no puedes ejecutar en casa: Kimi K3 (Moonshot AI), 2,8 billones de parámetros, 88,3% en Terminal-Bench 2.1.
• Mejor modelo local en una GPU de 24 GB: Qwen3.8-27B (Alibaba), Apache 2.0, 73,0% en Terminal-Bench 2.1, 16,5 GB en UD-Q4_K_M.
• Mejor modelo local para una estación de trabajo de 128 GB: Laguna S 2.1 (Poolside), 118B parámetros con solo 8B activos, contexto de 1M.
• Mejor modelo local rápido para hardware antiguo: Qwen3-Coder-Next, 80B totales pero 3B activos, 70,6% en SWE-bench Verified.

Todas las puntuaciones anteriores son publicadas por los proveedores salvo que se indique lo contrario. El resto del artículo explica cómo llegué a esas elecciones y dónde flojea cada una.

¿Por qué esta lista va de modelos y no de asistentes de programación?

Un LLM de programación es el modelo que lee tu prompt y escribe tokens, mientras que un asistente de programación es el arnés que le pasa archivos, ejecuta comandos y te muestra los diffs.

Claude Code, Codex, Cursor, GitHub Copilot y Windsurf son arneses. Claude Opus 5.5, GPT-6 Astra y Qwen3.8-27B son modelos, y el arnés cambia la puntuación más de lo que la mayoría espera.

El propio post de lanzamiento de Claude Opus 4.8 de Anthropic lo deja claro en una nota al pie.

Publica la puntuación de cada modelo en Terminal-Bench 2.1 sobre el arnés público Terminus-2, y luego señala que el número de GPT-5.5 sube a 83,4% dentro del CLI de Codex de OpenAI. Mismos pesos, fontanería distinta, resultado distinto.

Por eso los rankings de abajo van con el arnés indicado siempre que pude encontrarlo. Si eres nuevo en cómo funcionan estos modelos por dentro, nuestra guía sobre qué es un large language model (LLM) se lee en 15 minutos y te facilitará el resto del artículo.

¿Qué benchmarks importan realmente para los LLM de programación?

Los benchmarks que importan en 2026 son SWE-bench Pro, Terminal-Bench (versiones 2.1 y 4.0) y, para los modelos de pesos abiertos que aún lo reportan, LiveCodeBench v6. SWE-bench Verified fue el estándar durante 2 años y ahora está demasiado saturado para separar a los mejores modelos.

Antes de clasificar nada, aquí tienes qué significa cada número en las fichas de modelo.

SWE-bench Verified está saturado

SWE-bench Verified es un conjunto de 500 issues de GitHub validados por humanos de repositorios populares de Python; el modelo recibe el repositorio y el texto del issue y debe producir un parche que pase los tests ocultos.

OpenAI introdujo el subconjunto Verified en 2024 porque el SWE-bench original contenía tareas con issues poco especificadas o tests rotos. Sigue siendo el número más citado en programación, y justo ahí está el problema.

El ranking de Vals AI, que ejecuta cada modelo con el mismo agente mínimo solo-bash, colocó a Claude Opus 5 en 97,0%, DeepSeek V4 Pro 0813 en 96,4% y GPT-5.6 Sol en 96,2% en su actualización del 1 de septiembre de 2026, y luego marcó el benchmark como archivado.

Cuando 3 modelos de 3 laboratorios están a menos de un punto entre sí y a 4 puntos del techo, la métrica deja de discriminar. Lo sigo citando para modelos más antiguos y pequeños porque es el número que figura en sus fichas, pero no lo uso para clasificar.

SWE-bench Pro es el sustituto más exigente

SWE-bench Pro, mantenido por Scale AI, contiene 1.865 tareas en 41 repositorios profesionales, con una partición pública de 731 tareas y conjuntos privados reservados. El 22 de septiembre de 2026, Scale publicó SWE-Bench Pro V2, que reduce el conjunto público a 642 tareas tras eliminar 89 que consideró no válidas, así que comprueba en qué versión se obtuvo cada puntuación.

La corrección media toca 107,4 líneas en 4,1 archivos, y los repositorios abarcan varios lenguajes, no solo Python. Cuando el paper de SWE-bench Pro salió en septiembre de 2025, los mejores modelos rondaban el 23%.

Un año después, la system card de Fable 5.1 reporta 81,2% para Fable 5.1 y 79,2% para Opus 5, y la tabla de lanzamiento de GPT-5.6 indica 64,6% para GPT-5.6 Sol. Tres semanas después de la card de Fable, la system card de Opus 5.5 elevó la mejor marca al 89,9%.

Son corridas del proveedor, promediadas en 5 ensayos a máximo esfuerzo en el caso de Anthropic. El ranking público de Scale va con meses de retraso respecto a las cifras de los proveedores, así que tomo la cifra del proveedor como techo y la del ranking como suelo.

Terminal-Bench 2.1 y 4.0

Terminal-Bench pone a un modelo en una shell real dentro de un contenedor y una tarea tipo "entrena este modelo", "arregla este build" o "recupera este archivo corrupto", y luego evalúa los artefactos que produce.

La versión 2.1 son 89 tareas curadas de ingeniería de software, administración de sistemas, procesamiento de datos y seguridad, y Artificial Analysis la puntúa con el arnés Terminus 2 como pass@1 promediado en 3 ejecuciones. Es la cifra que más peso tiene para cualquiera que construya o use agentes de programación.

Terminal-Bench 4.0, alojado por Stanford, Harbor y el Laude Institute en tbench.ai, es el nuevo conjunto de frontera.

La system card de Opus 5.5 de Anthropic lo describe como 66 tareas sesgadas hacia biología computacional, simulación física, CAD, demostraciones formales y trabajo de rendimiento en GPU, con timeouts más largos para que el arnés importe menos.

En el ranking de agentes de tbench.ai, GPT-6 Astra sigue primero con 58,2% y Claude Fable 5.1 con 57,9%, pero Claude Opus 5.5 aún no tiene entrada de agente allí. En corridas a nivel de modelo, Artificial Analysis tiene a Opus 5.5 y Astra empatados en 59,6%, y Vals AI sitúa a Opus 5.5 primero con 61,6%, aunque Vals señala que esa cifra baja a 53,5% si cuentas como fallos las tareas que sus salvaguardas derivaron a un modelo de respaldo. Aquí es donde la frontera se separa del pelotón.

LiveCodeBench v6 detecta la memorización

LiveCodeBench, introducido en el paper de 2024 de Jain y colaboradores, recopila continuamente problemas de LeetCode, AtCoder y Codeforces y los fecha para que puedas evaluar un modelo solo con problemas publicados después de su corte de entrenamiento.

La versión 6 es la ventana actual en el ranking público. Mide razonamiento algorítmico, no ingeniería a escala de repositorio, por lo que sigue siendo útil para entrevistas y estructuras de datos.

Los laboratorios de frontera dejaron en su mayoría de reportarlo en 2026, así que los números que tengo son de modelos de pesos abiertos: el preview de abril de DeepSeek V4 Pro con 93,5%, Qwen3.8-27B con 90,3%, y Kimi K2.6 con 89,6%. Gemini 3.1 Pro publica una métrica relacionada, un Elo en LiveCodeBench Pro de 2.887.

Cómo leo una tabla de benchmarks del proveedor

Una tabla del proveedor es el mejor caso: su arnés, su nivel de esfuerzo, su número de ensayos. Busco una replicación independiente en Artificial Analysis, Vals AI o el ranking de tbench.ai antes de creerme una diferencia menor de 3 puntos.

Nuestro básico sobre benchmarks de LLM y cómo comparar modelos recorre los principales rankings, y nuestro artículo sobre qué mide MMLU es un buen recordatorio de que un benchmark de conocimiento dice poco sobre si un modelo puede arreglar un test inestable.

Para construir tu propio arnés de evaluación, nuestra guía de métricas y metodologías de evaluación de LLM es la que primero recomiendo a las personas junior.

Con esos benchmarks definidos, así puntúan los 9 modelos en ellos, empezando por la frontera en la nube.

¿Cuáles son los mejores modelos cloud de frontera para programar?

Los mejores modelos cloud de frontera para programar en septiembre de 2026 son Claude Opus 5.5, Claude Fable 5.1, GPT-6 Astra y Gemini 3.8 Flash, y los 4 ofrecen una ventana de contexto de alrededor de 1M de tokens.

Las diferencias están en precio, niveles de esfuerzo y a qué benchmark optimizó cada laboratorio.

Los listo en el orden en que se los recomendaría a un equipo que puede permitirse cualquiera.

1. Claude Opus 5.5 (Anthropic)

Claude Opus 5.5 es el nuevo buque insignia de la gama Opus de Anthropic, lanzado el 22 de septiembre de 2026, y ahora es el modelo de programación que recomendaría a casi todo el mundo. No esperaba escribir eso 2 meses después de Opus 5. El post de lanzamiento dice que rinde al nivel de Fable 5.1 en la mayoría de trabajos mientras cuesta un 40% menos que Opus 5, y la visión general de modelos ya indica a los desarrolladores empezar con Opus 5.5 y escalar a Fable 5.1 en trabajos exigentes de largo horizonte o cuando las evals con Opus 5.5 se queden cortas.

La system card de Opus 5.5 reporta 89,9% en SWE-bench Pro, 74,2% en DeepSWE v1.1 y 66,4% en Terminal-Bench 4.0 a esfuerzo xhigh, por delante de Fable 5.1 en todas las filas de programación que publicó Anthropic. Las cifras independientes están más cerca: Artificial Analysis lo tiene empatado con GPT-6 Astra en 59,6% en Terminal-Bench 4.0, y Vals AI lo sitúa primero con 61,6% en Terminal-Bench 4.0 y 87,6% en Terminal-Bench 2.1. Ambas cifras de Vals incluyen derivaciones por salvaguardas; contarlas como fallos las baja a 53,5% y 79,8%.

Funciones clave:

• 4 $ por millón de tokens de entrada y 20 $ por millón de salida, un 20% menos que Opus 5, con lecturas de caché un 60% más baratas a 0,20 $ por millón
• Contexto de 1M de tokens, salida de 128K, pensamiento adaptativo que no se puede desactivar y esfuerzo por defecto en medio en lugar de alto
• 57,8% en CursorBench 4.0 a esfuerzo máximo, la mejor puntuación del ranking de Cursor; a medio marca 52,5%, aún por encima de Fable 5.1 a máximo
• Disponible en la API de Claude como claude-opus-5-5, además de Amazon Bedrock, Google Cloud y Microsoft Foundry

Ideal para: programación diaria, migraciones a escala de código y revisión de código. Sustituye a Opus 5 directamente a menor precio, y Claude Code ya lo usa como modelo Opus por defecto. Nuestra guía de Claude Opus 5.5 cubre el lanzamiento, y nuestra comparativa GPT-6 Sol vs Claude Opus 5.5 incluye una prueba práctica.

Contrapunto: el ahorro del 40% aplica al esfuerzo por defecto. A esfuerzo máximo, Artificial Analysis vio que usaba muchos más tokens que Opus 5, así que su coste por tarea del Intelligence Index (5,98 $) quedó casi a la par con el de Opus 5 (5,86 $). También viene con salvaguardas al estilo Fable que desvían la mayoría de tareas de ciberseguridad a Opus 4.8, y las migraciones de código requieren cuidado, porque ahora las peticiones con pensamiento desactivado o uso de herramientas forzado devuelven errores.

2. Claude Fable 5.1 (Anthropic)

Claude Fable 5.1 es la versión pública del modelo de clase Mythos de Anthropic, lanzado el 1 de septiembre de 2026, y es el modelo al que escalo cuando Opus 5.5 ya no da más de sí. La página de lanzamiento indica que Fable 5.1 y Claude Mythos 5.1 son el mismo modelo con distintas salvaguardas.

Las cifras de la system card de Fable 5.1 son 81,2% en SWE-bench Pro y 55,8% en Terminal-Bench 4.0. Artificial Analysis midió de forma independiente 91,4% en Terminal-Bench 2.1 a esfuerzo máximo, aún la mejor marca en ese tablero.

Funciones clave:

• Ventana de contexto de 1M de tokens y 128K de salida
• Pensamiento adaptativo siempre activo
• Lecturas de caché de prompt un 75% más baratas a 0,25 $ por millón de tokens con 5.1, que Anthropic estima reduce cargas agentivas hasta un 45%
• Planificación fuerte entre varios archivos y pensamiento más amplio con mejor uso de herramientas

Ideal para: pipelines agentivos en producción, refactors de varios días y cualquier tarea donde una respuesta incorrecta cueste más que los tokens, cuando tus evals muestren que Opus 5.5 se queda corto. Nuestra guía de Claude Fable 5.1 cubre este lanzamiento y nuestra visión general de Claude Fable 5 cubre el original de junio.

Contrapunto: 10 $ por millón de tokens de entrada y 50 $ por millón de salida es 2,5 veces la tarifa de Opus 5.5, y en la propia tabla de Anthropic Fable 5.1 queda por detrás de Opus 5.5 en SWE-bench Pro, Terminal-Bench 4.0 y CursorBench 4.0. Anthropic dice que la brecha en uso real es menor de lo que sugieren esas cifras, pero la carga de la prueba se ha invertido. En el CursorBench 3.2.0 más antiguo, Fable 5.1 a esfuerzo medio marcó 68,0% por 3,53 $ por tarea.

3. GPT-6 Astra (OpenAI)

GPT-6 Astra es el modelo de frontera de OpenAI, lanzado el 3 de septiembre de 2026, y sigue primero en el ranking de agentes de Terminal-Bench 4.0 de tbench.ai con 58,2% usando el arnés Codex a esfuerzo máximo, aunque Opus 5.5 aún no tiene entrada de agente allí.

La página del modelo lista una ventana de contexto de 1.050.000 tokens, 128.000 de salida, un corte de conocimiento a 30 de abril de 2026 y niveles de esfuerzo de none a max. El precio es 10 $ por millón de tokens de entrada, 1 $ para entrada en caché, y 50 $ por millón de salida.

El material de lanzamiento de OpenAI se apoya en sus propias evaluaciones y su system card más que en los benchmarks cruzados entre laboratorios. Sus evaluaciones son sólidas, pero no diría que Astra sea un ganador claro frente a Opus 5.5 o Fable 5.1. Cubrimos los números de lanzamiento en nuestra visión general de GPT-6 Astra.

Funciones clave:

• La Responses API expone hosted_shell, apply_patch, computer_use y tool_search, el conjunto de herramientas sobre el que corre el propio Codex.
• Entrada en caché a 1 $ por millón de tokens, una décima parte del precio base, importante para bucles agentivos que releen el mismo repositorio.
• Astra es el primer modelo de OpenAI en alcanzar el nivel superior de ciberseguridad de su Preparedness Framework, así que algunos prompts cercanos a seguridad están restringidos.

Ideal para: equipos ya en Codex, GitHub Copilot o el stack de Microsoft, tareas con mucha ciencia e ingeniería, y quien necesite mejor soporte de herramientas de terceros. Si quieres gran parte de la capacidad por menos, GPT-6 Sol, lanzado el 22 de septiembre a 2 $ de entrada y 10 $ de salida por millón de tokens, sucede a GPT-5.6 Sol, y sin GPT-6 Terra ahora ocupa el hueco de precio que tenía Terra. En las propias tablas de OpenAI marca 68,8% en DeepSWE 1.1 y 49,3% en FrontierCode, aunque GPT-5.6 Sol a esfuerzo máximo sigue más alto en DeepSWE.

Contrapunto: precio de nivel Fable, y Opus 5.5 ahora iguala a Astra en Terminal-Bench 4.0 por aproximadamente el 40% del coste por tarea según Anthropic, con Artificial Analysis marcando empate. Las ventajas más claras de Astra están en trabajo científico: 64,6% en Terminal-Bench-Science y 65,5% en FrontierSWE v2, ambos por delante de Opus 5.5.

4. Gemini 3.8 Flash (Google)

Gemini 3.8 Flash es el modelo de batalla de Google, lanzado el 2 de septiembre de 2026, y una de las formas más baratas de conseguir una puntuación agentiva de programación de un laboratorio de frontera (GPT-6 Luna es más barato por token, pero consigue puntuaciones agentivas más bajas). El informe de evaluación de Google muestra 89,4% en Terminal-Bench 2.1 y 73,7% en DeepSWE v1.1, un conjunto de 113 tareas de largo horizonte donde Fable 5.1 marcó 67,4%. La misma tabla deja a Opus 5 ligeramente por delante con 74,0%, Anthropic reporta 74,2% para Opus 5.5, y la guía para desarrolladores de Google añade 61,6% en SWE-bench Pro.

Los precios en la página de precios de la API de Gemini son 0,75 $ por millón de tokens de entrada y 3,75 $ por millón de salida hasta el 31 de diciembre de 2026, y luego 1,50 $ y 7,50 $ desde el 1 de enero de 2027. Incluso a precio de 2027, es algo más de un tercio de la tarifa de salida de Opus 5.5. La ventana de contexto es de 1M de tokens de entrada con 64K de salida.

Funciones clave:

• Entrada multimodal nativa, así que puedes pasarle un diagrama de arquitectura o una captura de una UI fallando junto al código.
• Google lo posiciona como el modelo para trabajo agentivo de alto volumen y lo precio en consecuencia.
• Existe una variante Cyber para vulnerabilidades, con acceso restringido, que cubrimos en nuestra visión general de Gemini 3.8 Flash y Flash Cyber.

Ideal para: bucles agentivos de alto volumen, equipos sensibles a costes y clientes de Vertex AI. Gemini 3.1 Pro, lanzado el 19 de febrero de 2026, sigue siendo el modelo de nivel Pro de Google con 54,2% en SWE-bench Pro a 2 $ de entrada y 12 $ de salida por millón de tokens, pero para programación en concreto, hoy elegiría 3.8 Flash antes que 3.1 Pro.

Contrapunto: 19,1% en Terminal-Bench 4.0. Flash es fuerte en trabajo de terminal bien acotado y flojo en tareas científicas de frontera, así que guarda un modelo más potente para los tickets más duros.

Eso cubre los modelos en la nube. El resto son modelos que puedes descargar.

¿Cuáles son los mejores LLM de pesos abiertos en 2026?

Los mejores LLM de pesos abiertos en 2026 se dividen en 2 grupos: modelos de escala de centro de datos como DeepSeek V4.1 Flash y Kimi K3 que igualan puntuaciones de frontera pero requieren hardware serio de servidor, y modelos por debajo de 120B como Qwen3.8-27B y Laguna S 2.1 que puedes ejecutar en hardware propio.

"Pesos abiertos" aquí significa que los pesos son descargables. Las licencias van desde MIT y Apache 2.0 hasta términos personalizados.

5. DeepSeek V4.1 Flash (DeepSeek)

DeepSeek V4.1 Flash es el lanzamiento del 10 de septiembre de 2026 de DeepSeek, y pese al nombre Flash ahora es el modelo de DeepSeek que primero elegiría. DeepSeek dice que supera a su propio buque insignia V4 Pro 0813 en rendimiento, coste, velocidad y tiempo de finalización de tareas. El índice independiente de Vals AI apunta en la misma dirección, colocándolo como el mejor modelo de pesos abiertos con 57,9%, frente al 52,4% que Vals registró para V4 Pro 0813 en agosto.

Es un modelo MoE de 552B parámetros con unos 8B activos por token en entrada y 16B en salida, contexto de 1M de tokens, entrada de imagen nativa y pesos con licencia MIT. DeepSeek reporta 90,6% en Terminal-Bench 2.1 y 74,2% en DeepSWE v1.1, las mejores marcas de pesos abiertos reportadas por proveedor en ambos. La propia corrida de Vals AI en Terminal-Bench 2.1 es menos generosa, con 74,5%, segundo entre los abiertos.

Cubrimos el lanzamiento en detalle en nuestra visión general de DeepSeek V4.1 Flash.

Funciones clave:

• Precios de API en la página de precios de DeepSeek de 0,15 $ por millón de tokens de entrada y 0,60 $ por millón de salida en horas valle, doblándose a 0,30 $ y 1,20 $ en horas punta de lunes a viernes (01:00–04:00 y 06:00–10:00 UTC). Los aciertos de caché cuestan 0,003 $ por millón en valle.
• Servido como deepseek-flash en una API compatible con OpenAI, así que el script ask_coding_model.py más abajo funciona cambiando la URL base.
• Una caché KV de aproximadamente un cuarto del tamaño de la de V4 Flash, que es como DeepSeek puede poner tan bajo el precio de contexto largo.

Ideal para: programación de terminal cercana a la frontera por céntimos, y trabajos por lotes que puedas planificar en horas valle.

Contrapunto: marca 31,2% en Terminal-Bench 4.0 en el propio informe de DeepSeek, así que el trabajo agentivo más duro de largo horizonte sigue perteneciendo a los laboratorios de frontera. El checkpoint ronda los 510 GB, así que "pesos abiertos" aquí significa un servidor multi-GPU. Si usas V4 Pro 0813, DeepSeek anunció que lo redirigiría a V4.1 Flash el 14 de septiembre, luego dio marcha atrás, y V4 Pro sigue servido a 0,66/1,98 $ en valle hasta nuevo aviso.

6. Kimi K3 (Moonshot AI)

Kimi K3 es el buque insignia de pesos abiertos de Moonshot AI con 2,8 billones de parámetros, lanzado en julio de 2026, y marca 88,3% en Terminal-Bench 2.1, segundo entre los modelos abiertos tras el 90,6% reportado por proveedor de DeepSeek V4.1 Flash.

La ficha en Hugging Face lista 104B parámetros activos entre 896 expertos (16 enrutados más 2 compartidos por token), contexto de 1.048.576 tokens y pesos MXFP4. Vals AI midió 93,4% en SWE-bench Verified.

Funciones clave:

• Contexto de 1M de tokens con visión nativa.
• Se distribuye bajo la licencia Kimi K3, personalizada y no MIT o Apache, así que léela antes de uso comercial.
• Pilas de inferencia recomendadas: vLLM, SGLang y TokenSpeed, y Moonshot calibró algunas tareas de evaluación en GPU para H20.

Ideal para: quien quiera el agente programador abierto más potente disponible.

Contrapunto: capacidad casi de frontera solo a escala de centro de datos. La brecha de 3 puntos frente a Fable 5.1 en Terminal-Bench 2.1 parece pequeña, pero no es homogénea: Moonshot midió 88,3% en su arnés Kimi Code, mientras que el 91,4% de Fable viene de corridas Terminus 2 de Artificial Analysis. En la práctica, lo alquilas en un proveedor o levantas tu propio clúster, más una licencia personalizada que tu equipo legal deberá revisar.

7. Qwen3.8-27B (Alibaba)

Qwen3.8-27B es un modelo denso de 27.000 millones de parámetros lanzado en agosto de 2026 bajo Apache 2.0, y es el mejor LLM de programación que puedes ejecutar en una sola GPU de 24 GB.

La ficha del modelo reporta 61,7% en SWE-bench Pro, 73,0% en Terminal-Bench 2.1, 90,3% en LiveCodeBench v6 y 42,2% en DeepSWE 1.1, con un contexto nativo de 262.144 tokens ampliable a 1M con YaRN. Esas cifras en SWE-bench Pro y Terminal-Bench superan a Laguna S 2.1, un modelo 4 veces mayor, y superan a Gemini 3.1 Pro en SWE-bench Pro. Eso sí, Qwen ejecutó SWE-bench Pro en su propio conjunto de tareas corregido, así que toma esas comparaciones cruzadas como orientativas.

Funciones clave:

• El GGUF UD-Q4_K_M de Unsloth es un único archivo de 16,5 GB, que deja margen para un contexto de 32K en una tarjeta de 24 GB. UD-Q4_K_XL son 17,6 GB.
• Arquitectura densa, así que es más lento por token que un MoE con 3B activos pero mucho más consistente en ediciones multiarchivo.
• Apache 2.0, sin restricciones de uso en productos comerciales.

Ideal para: desarrolladores que no pueden enviar código a una API externa, profesionales en solitario con una GPU tipo RTX y quien quiera comparar local vs Claude en su propio repo antes de pagar la nube.

Contrapunto: 73,0% frente a 91,4% en Terminal-Bench 2.1 sigue siendo una brecha de 18 puntos, que se traduce en más reintentos en tareas agentivas largas.

8. Laguna S 2.1 (Poolside)

Laguna S 2.1 es el modelo MoE de programación de Poolside con 118B parámetros y 8B activos, lanzado el 21 de julio de 2026, y es la elección de pesos abiertos para un Mac Studio, DGX Spark o estación multi-GPU.

El post de lanzamiento de Poolside reporta 59,4% en el conjunto público de SWE-bench Pro, 70,2% en Terminal-Bench 2.1 con pensamiento máximo (60,4% con pensamiento desactivado), 78,5% en SWE-bench Multilingual y 40,4% en DeepSWE.

El modelo se entrenó en 409.000 entornos, incluidos 83.000 tareas de terminal y 168.000 flujos de trabajo de ingeniería de software, en 4.096 H200 en menos de 9 semanas.

Funciones clave:

• Ventana de contexto de 1M de tokens, inusual a este tamaño.
• Licencia OpenMDW-1.1, permisiva pero para que tu equipo legal la lea.
• El modo de pensamiento está activado por defecto y aporta unos 10 puntos en Terminal-Bench 2.1; la longitud media de finalización osciló entre ~23K y ~249K tokens por tarea en las corridas de Poolside, así que presupuéstalo.

Ideal para: equipos que quieren un agente local estilo Claude Code en una máquina de 96 a 128 GB de memoria unificada, y repos suficientemente grandes como para necesitar la ventana de 1M en local.

Contrapunto: 118B parámetros a 4 bits son ~60 a 70 GB de pesos antes de reservar la caché KV, así que una GPU de 24 GB queda descartada. En puntuaciones brutas Qwen3.8-27B se le adelanta, pero los 8B activos de Laguna lo hacen mucho más rápido una vez que los pesos caben, que es el punto para un agente nocturno.

9. Qwen3-Coder-Next (Alibaba)

Qwen3-Coder-Next es un modelo MoE de 80B parámetros que activa solo 3B por token, lanzado el 3 de febrero de 2026 bajo Apache 2.0, y es el programador local más rápido con capacidad útil para hardware que no sostiene un denso de 27B a velocidad.

La ficha del modelo reporta 70,6% en SWE-bench Verified, 44,3% en SWE-bench Pro y 36,2% en Terminal-Bench 2.0, con 512 expertos (10 activos más 1 compartido) y un contexto de 262.144 tokens. Funciona solo en modo sin pensamiento.

Funciones clave:

• El GGUF Q4_K_M oficial ronda 48 GB, ideal para un Mac de 64 GB o configuración con descarga a CPU más que para una sola GPU de consumo.
• Atención híbrida (3 capas Gated DeltaNet por capa de atención estándar) mantiene bajo el uso de memoria en contexto largo.
• Soporte en vLLM, SGLang, Ollama, LM Studio, MLX-LM, llama.cpp y KTransformers, según la ficha.

Ideal para: tareas largas nocturnas donde los tokens por segundo importan más que la precisión pico, y portátiles con 64 GB de memoria unificada.

Contrapunto: 44,3% en SWE-bench Pro está 17 puntos por detrás de Qwen3.8-27B, así que para un bug difícil puntual optaría por el modelo denso.

Otros modelos de pesos abiertos a tener en cuenta

Cuatro modelos más casi entran en la lista, y 2 de ellos encajarán mejor a equipos concretos que mis elecciones:

• DeepSeek V4 Pro 0813 (DeepSeek): 1,6T totales, 49B activos, 1M de contexto, licencia MIT, 96,4% en el SWE-bench Verified archivado de Vals AI. Sigue servido a 0,66 $ de entrada y 1,98 $ de salida por millón de tokens en valle, pero Vals lo midió en 54,7% en Terminal-Bench 2.1 frente al 87,9% que reporta DeepSeek, y ahora DeepSeek dirige a V4.1 Flash. Nuestro explicador de DeepSeek V4 cubre la arquitectura.
• Kimi K2.6 (Moonshot): 1T total, 32B activos, 256K de contexto, licencia MIT modificada, 80,2% en SWE-bench Verified, 58,6% en SWE-bench Pro y 89,6% en LiveCodeBench v6. La licencia más limpia entre los modelos del billón tras el MIT puro de DeepSeek V4 Pro.
• MiniMax M3: 428B totales, 23B activos, 1M de contexto, entrada nativa de imagen y vídeo, 80,5% en SWE-bench Verified y 59% en SWE-bench Pro. La opción abierta si tus tareas mezclan código con capturas.
• Qwen3.8-Flash-Next: 125B totales con 6B activos, 62,5% en SWE-bench Pro y 58,7% en DeepSWE, bajo la licencia más restrictiva qwen-community-1.0. Más fuerte que Qwen3.8-27B en DeepSWE, pero la licencia lo dejó fuera de mi top 9.

Si alguna de estas opciones de pesos abiertos encaja con tu hardware, la siguiente sección te muestra cómo ponerla en marcha.

¿Cómo ejecutar un modelo de pesos abiertos en local?

Ejecutar un modelo de pesos abiertos en local requiere 3 pasos: descargar un checkpoint cuantizado, servirlo detrás de un endpoint compatible con OpenAI y apuntar tu cliente o asistente de programación a ese endpoint. Usaré Qwen3.8-27B en el ejemplo porque es el más fácil de encajar en hardware de consumo.

Primero, la descarga. La librería huggingface_hub gestiona transferencias reanudables y caché, lo que ayuda con estos archivos grandes:

"""Download a quantized coding model from Hugging Face.
 
Qwen3.8-27B at UD-Q4_K_M is a single 16.5 GB file, which leaves room for
a 32K context on a 24 GB GPU. Swap FILENAME for the UD-Q4_K_XL build if you
have the extra 1 GB to spare.
"""
 
from huggingface_hub import hf_hub_download
 
REPO_ID = "unsloth/Qwen3.8-27B-GGUF"
FILENAME = "Qwen3.8-27B-UD-Q4_K_M.gguf"
 
 
def fetch(repo_id: str = REPO_ID, filename: str = FILENAME) -> str:
    """Download one file from the Hub and return its local path."""
    path = hf_hub_download(repo_id=repo_id, filename=filename)
    print(f"Saved to {path}")
    return path
 
 
if __name__ == "__main__":
    fetch()

Guárdalo como download_gguf.py y ejecútalo con uv run --with huggingface_hub python download_gguf.py. En Windows verás un aviso sobre symlinks si no tienes activado el Modo Desarrollador.

Segundo, servirlo.

Cualquiera de llama-server de llama.cpp, LM Studio u Ollama expone un endpoint /v1 compatible con OpenAI. Con llama.cpp el comando es de una línea, y 2 flags hacen el trabajo: -ngl 99 descarga todas las capas a la GPU y -c 32768 fija un contexto de 32K.

llama-server -m Qwen3.8-27B-UD-Q4_K_M.gguf -c 32768 -ngl 99 --port 8080

Tercero, el cliente. Mantengo un script por modelo que evalúo, local u hospedado, y cambio de destino con 3 variables de entorno. El mismo archivo habla con el servidor local de arriba, con la API de DeepSeek o con la de OpenAI:

"""Send one coding prompt to any OpenAI-compatible endpoint.
 
The same script talks to a local llama.cpp or vLLM server, to DeepSeek's
API, or to OpenAI itself. Only three environment variables change:
 
    LLM_BASE_URL   e.g. http://localhost:8080/v1  or  https://api.deepseek.com
    LLM_MODEL      e.g. qwen3.8-27b  or  deepseek-flash
    LLM_API_KEY    anything non-empty for a local server
"""
 
import os
 
from openai import OpenAI
 
PROMPT = (
    "Write a Python function top_n(df, col, n) that returns the n largest "
    "rows of a pandas DataFrame by column col, with a docstring and a "
    "ValueError if col is missing."
)
 
 
def ask(prompt: str = PROMPT) -> str:
    """Return the model's reply for a single-turn coding request."""
    client = OpenAI(
        base_url=os.environ["LLM_BASE_URL"],
        api_key=os.environ.get("LLM_API_KEY", "local"),
    )
    response = client.chat.completions.create(
        model=os.environ["LLM_MODEL"],
        messages=[{"role": "user", "content": prompt}],
        temperature=0.2,  # keep code generation close to deterministic
    )
    return response.choices[0].message.content
 
 
if __name__ == "__main__":
    print(ask())

Guárdalo como ask_coding_model.py y ejecútalo con LLM_BASE_URL=http://localhost:8080/v1 LLM_MODEL=qwen3.8-27b uv run --with openai python ask_coding_model.py.

Si luego conectas varios de estos endpoints en una aplicación con enrutado, reintentos y llamadas a herramientas, nuestro curso sobre desarrollo de aplicaciones con LLM usando LangChain cubre las abstracciones que evitan que esto se convierta en una pila de if.

¿Cómo elegir el mejor LLM para programar?

Elegir el mejor LLM para programar depende de 4 restricciones: si tu código puede salir de tu máquina, cuánta memoria tienes, cuánto pagarás por millón de tokens de salida y cuánta ventana de contexto necesita cada tarea. La tabla de abajo pone los 9 modelos lado a lado con los números en los que más confío, y la guía de decisión después los mapea a tu caso.

Guía de decisión

Así mapeo las 4 restricciones a las opciones del ranking:

• Pipelines agentivos donde prima la corrección sobre el coste: Claude Opus 5.5 a esfuerzo alto o xhigh, con Fable 5.1 preparado para tareas de largo horizonte donde tus evals muestren que Opus 5.5 flojea.
• Programación asistida a diario a un precio razonable: Claude Opus 5.5 primero a esfuerzo medio por defecto, GPT-6 Sol en segundo lugar si vives en Codex.
• Ciencia de frontera, simulación o trabajo de kernels de GPU: GPT-6 Astra o Claude Opus 5.5. Astra lidera en Terminal-Bench-Science; Opus 5.5 en Terminal-Bench 4.0.
• Codebase enorme, prompts de 1M de tokens, presupuesto ajustado: Gemini 3.8 Flash por precio; Opus 5.5 cuando las respuestas de Flash se desmadren.
• Pesos abiertos vía API: DeepSeek V4.1 Flash en horas valle.
• Local y privado en una sola GPU de 24 GB: Qwen3.8-27B en UD-Q4_K_M.
• Local y privado en una máquina de 96 a 128 GB: Laguna S 2.1, o Kimi K3 si "máquina" significa "clúster".
• Local y rápido en un portátil de 64 GB: Qwen3-Coder-Next.

Si quieres un marco más general para encajar modelo y aplicación, incluyendo opciones de hosting y licencias, nuestra guía sobre cómo seleccionar el mejor LLM para tu aplicación va más allá de la programación.

Y elijas el modelo que elijas, las habilidades para sacarle partido son las mismas: nuestro itinerario de aprendizaje de IA para ingeniería de software y nuestro curso de programación asistida por IA para desarrolladores enseñan el prompting, testing y revisión que convierten un 91% en benchmark en un pull request fusionado.

Conclusiones

Claude Opus 5.5 es el mejor LLM para programar en septiembre de 2026 y, de forma poco habitual, también el que poner en la factura de tu equipo. Claude Fable 5.1 es la vía de escalado para las tareas más largas, y Qwen3.8-27B es el modelo de pesos abiertos que convierte una GPU de 24 GB en un asistente privado de programación que supera a la frontera del año pasado en SWE-bench Pro. El resto depende de tus restricciones, y la guía de decisión anterior es cómo las resolvería.

El cambio de fondo es que el benchmark que definió esta categoría durante 2 años, SWE-bench Verified, dejó de importar en el mismo año en que los pesos abiertos lo alcanzaron.

No es casualidad.

Cuando Opus 5 y DeepSeek V4 Pro están a 0,6 puntos en un test saturado, y un modelo de 20 $ por millón ahora supera al propio de 50 $ de Anthropic en SWE-bench Pro, el valor se ha movido al diseño del arnés, los presupuestos de esfuerzo y la evaluación en tu propio repo, justo lo que una tabla del proveedor no puede hacer por ti.

Así que haz ese trabajo. Toma el script ask_coding_model.py, apúntalo a 2 o 3 de estos modelos, ejecútalo contra 20 tickets reales de tu backlog al nivel de esfuerzo que realmente vas a pagar, y deja que ese resultado anule cualquier cosa que haya escrito aquí. Si lo tuyo es más el "vibe coding" que los arneses de evaluación, nuestro artículo sobre qué es el vibe coding y dónde falla es una mirada honesta a los trade-offs, y se aplican los mismos rankings de modelos.