Modelos locales para programar frente a Claude: qué rinden y cuánto cuestan de verdad

El mejor modelo de código que puedes ejecutar en casa con una sola GPU de 24 GB, Qwen3.6-27B, resuelve el 77,2 % de SWE-bench Verified según Qwen. Es casi lo que marcaba Claude Opus 4.5 (80,9 %), pero Opus 4.5 ya no es el último de Anthropic, y ningún Claude se puede ejecutar en local. Para autocompletar, scripts y código que no puede salir de tu equipo, un modelo local compensa. Para agentes que trabajan solos durante una hora y tocan muchos ficheros, Claude sigue siendo otra cosa. En dinero, la cuenta solo sale a favor de lo local si ya tienes el hardware o programas muchas horas al día.

Esto es lo que encontramos al cruzar los datos publicados a 17 de octubre de 2026, con las cuentas hechas en euros. Lo que pudimos ejecutar nosotros fueron modelos pequeños, y el resultado también es parte de la respuesta.

Los modelos de código que de verdad caben en un equipo#

Dejamos fuera a los modelos abiertos grandes que se acercan a la frontera, como DeepSeek V4-Flash (284.000 millones de parámetros), GLM-5.2 (753.000 millones) o Kimi K3: son abiertos, pero necesitan un servidor con varias GPU. Estos son los que caben en un PC con una GPU o en un Mac:

Cifras de SWE-bench declaradas por cada fabricante en su ficha o anuncio; la de Claude Opus 4.5 aparece en la tabla comparativa de la ficha de Qwen3.6-27B. Las memorias de gpt-oss son las medidas por llama.cpp con todo cargado.

Tres advertencias antes de sacar conclusiones:

• Anthropic ya no publica SWE-bench Verified para sus modelos actuales (Opus 5.5 y Sonnet 5.5). Usa SWE-bench Pro, más difícil. Por eso comparamos con Opus 4.5, el último con dato en Verified: el punto de referencia es un modelo de Anthropic de hace un año, no el de hoy.
• Cada fabricante mide con su propio entorno (el «arnés»: las herramientas, el número de intentos, el límite de pasos). Dos cifras de fabricantes distintos se parecen a una comparación, pero no lo son del todo.
• El modelo más nuevo de Qwen, Qwen3.8-27B (agosto de 2026, Apache 2.0), no da cifra en Verified, sino en SWE-bench Pro: 61,7. Pinta a mejor que el 3.6, pero no podemos ponerlo en la misma columna.

Desliza para ver la figura completa

Qué significa en el día a día#

SWE-bench Verified mide si el modelo arregla un fallo real de un repositorio de Python: lee la incidencia, encuentra los ficheros, cambia el código y pasa los tests. Un 77 % es mucho. Pero la experiencia de quien ha probado estos modelos a diario, como el análisis de Failing Fast que citamos en las fuentes, coincide en el reparto:

Dónde un modelo local de 24-30B rinde bien:

• Autocompletar en el editor, donde importa más la latencia que la inteligencia.
• Funciones y scripts autocontenidos: «convierte este CSV», «añade un test a esta función».
• Explicar código y escribir documentación.
• Código bajo contrato de confidencialidad o datos que no pueden salir de tu red.

Dónde se nota la distancia con Claude:

• Cambios que tocan muchos ficheros a la vez y exigen entender la arquitectura.
• Sesiones largas de agente: decenas de llamadas a herramientas seguidas sin perder el hilo.
• Fallos sutiles (concurrencia, estado compartido, casos límite).
• Contexto largo de verdad. Los modelos locales anuncian 128.000 o 262.000 tokens, pero cada token de contexto ocupa memoria en la caché KV. Con una GPU de 24 GB y un modelo de 18 GB, lo que queda libre para contexto se acaba antes de lo que esperas.

Y por debajo de ese tamaño, la caída es brusca. Lo comprobamos en nuestra VPS sin GPU: pedimos a Qwen3.5 2B y Qwen3.5 0.8B una función de Python que sumara el tamaño de los ficheros por extensión. El de 2B olvidó el import os y sobrescribía en lugar de sumar, las dos veces que lo probamos. El de 0,8B devolvió una función que ni siquiera recibía una lista. El de 4B se acercó mucho (importaba os y sumaba bien), pero desempaquetaba tres valores de una función que devuelve dos, así que fallaba con el primer fichero que existiera. Solo Gemma 4 E2B la escribió bien a la primera: uno de los cinco modelos a los que se la pedimos. Los detalles están en nuestra prueba de IA local en una VPS sin GPU.

Qué velocidad esperar#

Programar con un modelo lento desespera. La generación depende sobre todo del ancho de banda de la memoria y de cuántos parámetros se leen por token, por eso los MoE (que solo activan una parte) van mucho más rápidos que los densos del mismo tamaño. Algunas mediciones publicadas con llama.cpp:

Para un modelo denso como Qwen3.6-27B no encontramos una medición publicada que podamos verificar. Lo que sí podemos calcular es el techo: una RTX 3090 tiene 936 GB/s de ancho de banda y el modelo ocupa unos 18 GB, así que no puede pasar de unos 50 tokens por segundo (936 ÷ 18), y en la práctica se queda por debajo. Sigue siendo rápido para leer, pero un agente que genera miles de tokens por tarea lo notará.

Cómo conectarlo a tu editor o a Claude Code#

Ollama, LM Studio y llama-server exponen una API compatible con la de Anthropic, así que Claude Code puede usar un modelo local:

ollama pull qwen3.6
ollama launch claude --model qwen3.6

La documentación de Ollama recomienda 64.000 tokens de contexto o más para trabajar con repositorios grandes. Es razonable: Claude Code envía muchas instrucciones y el contenido de los ficheros que lee. Ajusta el contexto de Ollama antes de quejarte del modelo. Si es tu primera vez con la herramienta, nuestra guía de Claude Code explica el flujo, y un buen CLAUDE.md ayuda todavía más a un modelo pequeño, que necesita que le den el contexto masticado.

Para autocompletar en VS Code, Continue y Cline se conectan a Ollama (puerto 11434) o LM Studio (puerto 1234). Aider funciona con aider --model ollama_chat/nombre-del-modelo.

Las cuentas: local frente a la API, en euros#

Lo que cuesta Claude#

• Suscripción: Claude Pro, 20 $ al mes, incluye Claude Code. Max 5x, 100 $; Max 20x, 200 $. Lo detallamos en cuánto cuesta Claude.
• API, por millón de tokens de entrada / salida: Opus 5.5, 4 $ / 20 $; Sonnet 5.5, 2 $ / 10 $; Haiku 5.5, 0,10 $ / 0,50 $ (con prompts de hasta 100.000 tokens).
• Modelos abiertos por API, para comparar: en OpenRouter, gpt-oss-120b desde 0,03 $ / 0,15 $ y Qwen3.6-27B desde 0,25 $ / 2 $.

Lo que cuesta lo local#

• Hardware. Una RTX 3090 de segunda mano (24 GB) rondaba los 1.200 $ en octubre de 2026 según los agregadores de precios, con un mercado muy inflado por la demanda de IA. Un Mac Studio con M5 Max empieza en 2.499 $ y llega hasta 128 GB de memoria unificada.
• Electricidad. Para un hogar español de consumo medio (de 2.500 a 4.999 kWh al año), el kWh costó 0,2509 € en el primer semestre de 2026, impuestos incluidos, según Eurostat.
• Tu tiempo para instalarlo, actualizarlo y elegir modelo. No es cero.

Un ejemplo de electricidad, con supuestos nuestros: un PC con una GPU que consume en total 400 W mientras genera, 4 horas al día de uso real y 22 días al mes, son 35,2 kWh: unos 8,80 € al mes. Si el equipo pasa el resto del día encendido sin hacer nada, súmale el consumo en reposo.

El punto de equilibrio#

Con esos números, una RTX 3090 de 1.200 $ tarda:

• Unos 5 años en pagarse frente a Claude Pro (20 $ al mes), sin contar la luz. Y no hace lo mismo que Claude Pro.
• Alrededor de un año frente a Max 5x (100 $ al mes), si de verdad sustituyera ese uso, que para trabajo de agente no lo hace.
• Nunca, o casi, frente a modelos abiertos baratos por API. Si generas 5 millones de tokens de salida al mes con Qwen3.6-27B en OpenRouter, pagas unos 10 $ de salida más la entrada. La luz del ejemplo anterior ya se come buena parte de eso.

Flavio Copes llega a una conclusión parecida en su análisis de agosto de 2026: una tarjeta de 1.800 $ se amortiza en unos 20 meses frente a la API más cara, en unos 44 frente a una de precio medio, y frente a la más barata no se amortiza nunca.

Hay una tercera vía: alquilar la GPU por horas. En RunPod, una RTX 3090 cuesta 0,22 $ la hora en la nube comunitaria y una RTX 4090, 0,34 $. Ocho horas al día durante 22 días con una 3090 son unos 39 $ al mes, sin compra ni ruido, y la apagas cuando no la usas.

Nuestra recomendación#

• Programas a diario y quieres el mejor resultado: Claude, con suscripción. Es lo que usamos nosotros en todo el trabajo de agente, y ningún modelo que quepa en casa lo iguala hoy.
• Ya tienes una GPU de 24 GB o un Mac con 32 GB o más: instala Qwen3.6-27B o Muse Glimmer-30B y úsalo para autocompletar, scripts y todo lo confidencial. Es gratis en el margen y te quita peticiones de la suscripción.
• Tu código no puede salir de la empresa: lo local deja de ser una cuestión de precio. Un Mac Studio o un PC con GPU de 24 GB y Qwen3.6-27B es hoy la opción con mejor relación entre calidad y hardware.
• Solo tienes un portátil normal o una VPS sin GPU: no intentes programar con IA local. Los modelos que caben ahí fallan en lo básico, como vimos.
• Quieres ahorrar sin comprar nada: prueba primero modelos abiertos por API o alquila una GPU por horas. Si después de un mes los usas tanto que la factura duele, entonces haz las cuentas de comprar.

Qué hacer ahora#

1. Apunta qué tareas de programación haces con IA en una semana normal: autocompletar, scripts, agentes largos. Eso decide más que cualquier benchmark.
2. Si tienes el hardware, instala Ollama, descarga Qwen3.6-27B y repite tres tareas reales que ya hiciste con Claude. Compara el resultado, no la sensación.
3. Revisa cuánto pagas hoy con la guía de precios de Claude y compáralo con las cuentas de arriba.
4. Para elegir herramienta, lee Ollama, llama.cpp o LM Studio, y para elegir modelo según tu equipo, los mejores modelos de IA local en 2026.