Mejores modelos de Ollama para agentes de programación: ranking de modelos locales

El mejor modelo de Ollama para un agente de programación no siempre es el más grande que puedas descargar. Los agentes funcionan en bucle: leen archivos, llaman a herramientas, revisan planes y generan parches. Un modelo que parece bueno en una sola petición puede volverse inutilizable si cada llamada a una herramienta exige otra pasada lenta de inferencia local.

Usa esta clasificación como punto de partida práctico: qué modelo descargar, qué hardware necesita y cuándo dejar de forzar la inferencia local y pasar a un respaldo en la nube.

Clasificación rápida

Puesto	Modelo	Comando de descarga	Ideal para	Hardware práctico
1	Qwen3 Coder 30B	ollama pull qwen3-coder:30b	Mejor opción local por defecto para agentes de programación	24 GB+ de VRAM o 32 GB+ de memoria unificada
2	Qwen3 30B	ollama pull qwen3:30b	Tareas generales de agente, razonamiento, revisión de código	24 GB+ de VRAM o 32 GB+ de memoria unificada
3	Gemma 4 26B MoE	ollama pull gemma4:26b	Ayuda rápida de programación local en estaciones de trabajo potentes	24 GB+ de VRAM o 32 GB+ de memoria unificada
4	Kimi K2.7 Code	ollama pull kimi-k2.7-code	Programación con linaje de vanguardia en hardware potente	48 GB+ de VRAM o 96 GB+ de memoria unificada
5	gpt-oss 20B	ollama pull gpt-oss:20b	Mejor opción para 16 GB, razonamiento ajustable	16 GB de VRAM o memoria unificada
6	Gemma 4 E4B	ollama pull gemma4:e4b	Uso ligero en portátil	16 GB de memoria unificada
7	Qwen3 8B	ollama pull qwen3:8b	Ediciones pequeñas y explicación de código	8–16 GB de memoria

Si solo vas a probar un modelo, prueba Qwen3 Coder 30B. Ollama lo incluye como modelo de programación y de agente con soporte para una ventana de contexto de 256K, y está pensado exactamente para el tipo de trabajo que hacen los agentes de programación: leer código, usar herramientas y mantener el estado a lo largo de tareas largas.

Qué elegir según tu equipo

8–16 GB de memoria

Usa gpt-oss 20B, Qwen3 8B o Gemma 4 E4B. gpt-oss 20B se ha convertido en la opción por defecto de la comunidad para equipos con 16 GB desde su lanzamiento: cabe en la memoria disponible y te permite ajustar el esfuerzo de razonamiento en cada tarea.

Esta gama es adecuada para:

• Explicar código desconocido
• Escribir funciones pequeñas
• Redactar tests
• Generar archivos de configuración
• Resumir logs

No esperes refactorizaciones fiables de varios archivos aquí. Los modelos más pequeños pueden escribir código útil, pero pierden el hilo en cuanto el agente empieza a abrir archivos, revisar parches y gestionar las salidas de las herramientas.

24–32 GB de memoria

Usa Qwen3 Coder 30B, Qwen3 30B o Gemma 4 26B MoE.

Este es el nivel útil para agentes locales. El modelo es lo bastante grande para seguir el contexto del repositorio, pero sigue siendo lo bastante pequeño para funcionar en una GPU de escritorio potente o en un Mac con más memoria. Para la mayoría de desarrolladores, este es el punto en el que Ollama deja de parecer una novedad y empieza a formar parte del flujo de trabajo.

64 GB+ de memoria

Prueba variantes más grandes de Qwen o DeepSeek solo si ya sabes por qué las necesitas.

La tentación es ir a por el modelo más grande de la biblioteca. Para agentes, ese instinto suele ser erróneo. Un modelo local enorme puede ser técnicamente impresionante y aun así hacer que el bucle de programación sea demasiado lento. Un modelo más grande es útil cuando la tarea realmente necesita más razonamiento o contexto. Es un sobrecoste cuando el agente solo lee archivos, escribe código repetitivo o redacta tests.

Mejor en general: Qwen3 Coder

Qwen3 Coder es el primer modelo que probaría en cualquier configuración de agente de programación local.

Descárgalo:

ollama pull qwen3-coder:30b

Haz una comprobación rápida:

ollama run qwen3-coder:30b "Explain this repo structure and suggest where tests should live."

Por qué ocupa el primer puesto:

• Está explícitamente optimizado para flujos de trabajo de programación y de agentes.
• La página de Ollama incluye soporte para ollama launch en Claude Code, Codex, OpenCode y OpenClaw.
• La variante de 30B es mucho más realista en local que la variante de 480B.
• El soporte de contexto largo lo hace más adecuado para trabajar con repositorios que los modelos locales de código anteriores.

Úsalo para revisión de código, generación de tests, refactorizaciones de tamaño medio y sesiones de agente local-first cuando la privacidad importa.

Mejor opción ligera: Gemma 4

Gemma 4 es la familia de modelos que conviene probar cuando Qwen3 Coder es demasiado pesado. Las variantes más pequeñas de Gemma 4 están diseñadas para uso local y en el dispositivo, mientras que la variante 26B MoE te da una opción más potente para estaciones de trabajo sin activar todos los parámetros en cada token.

Descarga la versión apta para portátil:

ollama pull gemma4:e4b

Descarga la versión más potente para estaciones de trabajo:

ollama pull gemma4:26b

Gemma 4 es una buena opción para agentes de programación cuando quieres ayuda local rápida con explicaciones, ediciones pequeñas y código privado. Resulta menos atractiva para sesiones autónomas largas en las que el agente necesita mantener coherente un plan de migración completo.

Novedades recientes: Kimi K2.7 Code y Laguna XS 2.1

Dos modelos centrados en programación han llegado a la biblioteca de Ollama este verano y merece la pena seguirlos.

Kimi K2.7 Code es la versión optimizada para programación de Moonshot basada en la línea K2.6, la misma familia cuyo lanzamiento K3 lleva un tiempo superando a modelos cerrados de vanguardia en los leaderboards de Chatbot Arena. Necesita hardware potente (hablamos de 48 GB+ de VRAM o un Mac con mucha memoria), pero si lo tienes, es la línea de modelos de programación de código abierto más potente que puedes ejecutar hoy en local.

ollama pull kimi-k2.7-code

Laguna XS 2.1 es el MoE para agentes de programación de Poolside: 33B parámetros totales con solo 3B activos por token, por lo que funciona mucho más ligero de lo que sugiere su tamaño. Está creado específicamente para el bucle de llamadas a herramientas en el que viven los agentes de programación.

Si estabas usando DeepSeek Coder V2 de una versión anterior de esta guía, retíralo: está dos generaciones por detrás de las opciones actuales y ha desaparecido por completo de las clasificaciones de la comunidad.

Dónde usar estos modelos

• haimaker.ai - usa modelos locales de Ollama junto a modelos en la nube más potentes; enruta el trabajo sencillo de los agentes de programación a tu modelo local y deriva las tareas difíciles a modelos de pago.
• OpenClaw - usa Ollama como proveedor local para sesiones de agente de programación. Consulta la guía de modelos locales de OpenClaw.
• OpenCode - añade Ollama mediante el proveedor compatible con OpenAI. Consulta Ollama con OpenCode.
• Codex y Claude Code - las páginas de modelos de Ollama incluyen ejemplos de ollama launch para entornos de ejecución de agentes, incluidos Codex y Claude Code.

Configuración para agentes compatibles con OpenAI

La mayoría de agentes de programación pueden usar Ollama a través de su endpoint local compatible con OpenAI:

http://localhost:11434/v1

Usa una clave API de marcador de posición si tu herramienta la exige. Ollama no la valida localmente.

{
  "baseURL": "http://localhost:11434/v1",
  "apiKey": "ollama",
  "model": "qwen3-coder:30b"
}

Para OpenCode, el bloque de proveedor tiene este aspecto:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama (local)",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "qwen3-coder:30b": {
          "name": "Qwen3 Coder 30B"
        }
      }
    }
  }
}

Si las llamadas a herramientas no son fiables, reduce primero el tamaño del modelo y luego aumenta el contexto solo hasta donde tu hardware pueda soportarlo. Una ventana de contexto gigante que obliga a usar swap es peor que una más pequeña que se mantiene ágil.

Cuándo no usar Ollama

Los modelos locales son mejores cuando la privacidad, el coste o el trabajo sin conexión importan. No son automáticamente mejores para todas las tareas de programación.

Usa un modelo en la nube cuando:

• La tarea abarca muchos archivos
• El bug es sutil
• Necesitas llamadas a herramientas fiables
• El parche tocará sistemas de producción
• No tienes tiempo para revisar cada línea generada

La configuración práctica es local-first, no solo local. Usa Qwen3 Coder o Gemma 4 para trabajo privado y barato, y luego deriva a un modelo en la nube más potente cuando lo que se encarece es tu atención en lugar de los tokens.

ENRUTA MODELOS LOCALES Y EN LA NUBE CON HAIMAKER

---

Para la configuración local específica de OpenClaw, consulta mejores modelos locales para OpenClaw. Para la configuración de OpenCode, consulta usar Ollama con OpenCode.