Ejecuta agentes de IA para programar en tu Mac: guía sin rodeos

Por Qué Elegir Soluciones Locales

Todos hemos pasado por eso. Estás metido de lleno en una sesión de código, la creatividad fluye, y entonces... se cae internet. Tu asistente de IA basado en la nube se vuelve inútil, y te quedas mirando tu código preguntándote qué hacer.

Eso me pasó hace poco, y fue el empujón que necesitaba para finalmente explorar cómo ejecutar un agente de IA para código completamente en local. Lo que descubrí me sorprendió: con la configuración adecuada, puedes lograr un rendimiento bastante decente en Apple Silicon, incluso superando soluciones especializadas optimizadas para Mac.

La Configuración Que Realmente Funciona

Después de bastante pruebas y benchmarking, esta es la configuración que mejores resultados me dio en mi M1 Max con 64GB de memoria unificada:

Stack principal:

• llama.cpp compilado con aceleración Metal
• Gemma 4 26B-A4B en formato GGUF (cuantizado a Q4)
• Modelo draft Multi-Token Prediction (MTP) para decodificación especulativa
• Proyector multimodal de Gemma 4 para soporte de capturas de pantalla
• Pi como agente de código basado en terminal

No es la configuración más potente que podrías construir teóricamente, pero es el punto óptimo para uso real. Lo que quieres es velocidad medida en tokens por segundo, no minutos por respuesta.

Los Números Que Importan

Ejecuté benchmarks consistentes usando este prompt en todas las configuraciones:

"Escribe una función compacta en Python que analice un diff unificado y devuelva las rutas de los archivos modificados. Luego explica dos casos extremos."

Cada prueba generó aproximadamente 128 tokens, lo que nos dio una comparación justa de la velocidad de generación.

Rendimiento Base:

Ejecutar Gemma 4 directamente a través de llama.cpp con Metal nos dio 58.2 tokens por segundo. Es usable, pero siendo honesto... se sentía lento durante sesiones reales de código donde estás haciendo múltiples llamadas a herramientas y esperando respuestas.

La Diferencia del MTP:

Aquí es donde las cosas se ponen interesantes. Multi-Token Prediction permite que el modelo "especule" varios tokens por delante, aceptando predicciones correctas y deshaciendo las incorrectas. Con el modelo draft MTP Q8 habilitado, el rendimiento subió a 72.2 tokens por segundo — una mejora del 24% sin ningún cambio en el modelo principal.

El procesamiento del prompt se mantuvo esencialmente igual (alrededor de 297-299 tokens/segundo), pero la velocidad de generación es lo que importa para flujos de trabajo de agentes. No estás enviando nuevos prompts constantemente — estás esperando que el modelo genere respuestas, tome decisiones y ejecute herramientas.

Probé conteos de tokens draft de 1 a 6, y en mi M1 Max, 3 tokens draft encontró el punto óptimo. Valores por encima de 4 en realidad comenzaron a ralentizar las cosas, lo cual tiene sentido — más especulación significa más trabajo desperdiciado cuando las predicciones fallan.

llama.cpp vs. MLX: El Ganador Sorprendente

Esto me catchoff guardó: esperaba que MLX (el framework nativo de ML de Apple) dominara ya que está específicamente optimizado para Apple Silicon. La realidad fue diferente.

| Runtime | Tokens/seg generación | |---------|------------------------| | llama.cpp Metal + MTP | 72.2 | | llama.cpp Metal | 58.2 | | MLX-LM (Unsloth 4-bit) | 45.8 | | MLX-LM (standard 4-bit) | 43.9 | | MLX-LM (OptiQ 4-bit) | 38.1 |

Llama.cpp con MTP fue aproximadamente 58% más rápido que la mejor configuración de MLX. Los años de trabajo de optimización que se han invertido en llama.cpp claramente han dado sus frutos — funciona excellentemente en macOS a pesar de ser multiplataforma.

Agregando Capacidades de Visión

Para una experiencia completa de agente de código, quieres poder enviar capturas de pantalla. Quizás quieres que el agente vea lo que ha construido, o revise un cambio de UI que acabas de hacer.

El problema? Solo Gemma 4 12B es nativamente multimodal. El modelo 26B que estamos usando necesita el proyector multimodal externo cargado junto a él.

Cuando agregué el proyector --mmproj a llama.cpp, publicitó correctamente las capacidades multimodales a Pi, y los outputs de herramientas de imagen comenzaron a fluir correctamente. Más importante aún, esto no introdujo ninguna ralentización medible — la velocidad de generación se mantuvo en 72.2 tokens por segundo.

La Experiencia Real

Con esta configuración, estás mirando aproximadamente 17GB de archivos de modelo (16GB para el modelo principal, más el head MTP y el proyector). Para alguien con 64GB de memoria unificada, eso es completamente manejable.

Pi como agente proporciona una interfaz limpia de terminal que se conecta a la API compatible con OpenAI que el modo servidor de llama.cpp expone. Esto significa que puedes usarlo con cualquier herramienta que soporte el formato de API de OpenAI, dándote flexibilidad sin lock-in.

El mayor beneficio? Cuando tu internet falla — y lo hará, en el peor momento posible — sigues codificando. El agente puede ser ligeramente más lento que las alternativas en la nube, pero es lo suficientemente responsivo para mantener tu flujo de trabajo.

Empezando

Necesitarás compilar llama.cpp con soporte Metal habilitado. El proyecto tiene buena documentación para builds en macOS, y una vez compilado, el modo servidor te da ese endpoint compatible con OpenAI.

Para los modelos, las cuantizaciones GGUF de Unsloth en Hugging Face están bien optimizadas. Querrás la cuantización Q4_K_XL para el modelo principal y el modelo draft MTP Q8 correspondiente.

Ajusta tu valor --spec-draft-n-max — empieza en 3 y prueba de 1 a 6 para encontrar lo que mejor funciona en tu hardware específico. Diferentes configuraciones de Apple Silicon pueden tener diferentes puntos óptimos.

¿Vale la Pena?

Si programas regularmente con asistentes de IA y tienes el hardware (mínimo 16GB, 32GB+ recomendado), absolutamente. La independencia de la conectividad a internet por sí sola lo hace valioso, y con MTP llevando las velocidades de generación a territory genuinamente usable, la experiencia es sorprendentemente pulida.

No vas a igualar la inteligencia de clase GPT-4 con estos modelos abiertos, pero para completado de código, refactorización, asistencia en debugging y tareas generales de agente de código? Es más capaz de lo que la mayoría espera, y es tuyo — ejecutándose localmente, en privado, sin picos de latencia ni caídas de servicio.

Las herramientas han madurado significativamente. Si has probado modelos locales antes y te has decepcionado por la velocidad, dale una oportunidad a esta configuración. MTP cambia la ecuación considerablemente.