Programar con IA local debería ser aburrido, en el mejor sentido. Eliges un modelo, lo apuntas a tu proyecto, le das las herramientas que necesita y sigues trabajando. Sin editar a mano el JSON del proveedor. Sin reiniciar tres servicios en el orden correcto. Sin copiar y pegar contexto porque tu modelo local vive fuera del resto de tu workspace de IA.
Esa es la experiencia que queríamos para OpenCode + Ollama dentro de SynaBun.
OpenCode nos da una interfaz seria y open source de agente de programación. Ollama nos da modelos locales que se ejecutan en tu equipo. SynaBun les da a ambos la capa de workspace: herramientas MCP, memoria persistente, acceso al navegador, terminales, ajustes, gestión del ciclo de vida y el contexto del proyecto que hace que una sesión de programación con IA siga siendo útil después del primer prompt.
El resultado es un ciclo de programación con IA local casi sin fricción: ejecutas Ollama, descargas un modelo, abres SynaBun y dejas que el workspace conecte las piezas.
El problema: los modelos locales siguen pareciendo un añadido
Los LLM locales han mejorado muchísimo. El workflow que los rodea, muchas veces no.
La mayoría de las configuraciones locales para programar todavía te piden armar la cadena por tu cuenta:
- instalar el agente de programación
- iniciar el servidor de modelos locales
- encontrar el formato de proveedor correcto
- editar a mano un archivo de configuración
- agregar manualmente los modelos descargados
- reiniciar el servidor del agente
- reconectar las herramientas MCP, si el agente las admite
- cruzar los dedos para que el selector de modelos se actualice de verdad
Eso no es un workflow de programación. Es trabajo de infraestructura.
El costo no es solo tiempo. El verdadero costo es la fragmentación del contexto. Puede que tu modelo local esté en ejecución, pero no queda automáticamente dentro del mismo sistema de memoria, el mismo conjunto de herramientas, la misma sesión del navegador y el mismo workspace del proyecto que todo lo demás. Terminas con un modelo local capaz de generar código, pero no con un entorno de programación con IA local que entienda tu trabajo.
Qué le aporta SynaBun a OpenCode
OpenCode ya tiene la forma adecuada para hacer agentic coding en serio. Puede ejecutarse como agente de programación, exponer una API HTTP, transmitir eventos, gestionar sesiones, listar proveedores y conectar servidores MCP.
SynaBun se integra con esas capacidades, en lugar de tratar a OpenCode como un simple comando de terminal.
Dentro de Neural Interface, OpenCode pasa a formar parte del mismo workspace que Claude Code, Codex, Gemini, las terminales, las tarjetas de memoria, el navegador y el whiteboard. SynaBun puede iniciar y detener el servidor de OpenCode, leer sus proveedores, mostrar los modelos en una interfaz, retransmitir los eventos de la sesión y conectar el servidor MCP de SynaBun con un clic.
Ese último punto importa. Un modelo local sin herramientas es solo una ventana de chat con acceso al repositorio. Un modelo local con SynaBun MCP puede participar en el mismo sistema que el resto de tus agentes:
- buscar en la memoria persistente del proyecto
- recuperar decisiones anteriores
- usar las herramientas del workspace
- acceder al entorno compartido de programación con IA
- mantenerse conectado al mismo contexto de proyecto de SynaBun
El objetivo no es hacer desaparecer a OpenCode. El objetivo es que OpenCode se sienta nativo dentro del workspace.
Dónde encaja Ollama
Ollama es la capa de modelos locales.
SynaBun comprueba si Ollama se está ejecutando en localhost:11434, lee los modelos instalados desde la API local de Ollama e integra esos modelos como una opción de proveedor nativa en OpenCode. Si Ollama no está en ejecución, la interfaz te lo dice directamente. Si Ollama está en ejecución pero no tiene modelos, te señala el paso que falta: descargar un modelo.
Cuando Ollama está en ejecución y tiene modelos disponibles, SynaBun puede configurar OpenCode automáticamente.
En la práctica, eso significa que SynaBun puede agregar el bloque del proveedor Ollama a la configuración de OpenCode, instalar @ai-sdk/openai-compatible cuando OpenCode lo necesita, asignar los modelos de Ollama que descargaste a la configuración del proveedor y reiniciar el servidor de OpenCode para que se actualice la lista desplegable de modelos.
Sin cirugía manual de JSON. Sin un paso aparte de «ahora ve a arreglar la configuración de tu proveedor».
Programar con IA local empieza a sentirse real cuando el modelo local deja de ser una isla aparte. Tiene que vivir en el mismo workspace que tu memoria, tus herramientas, tus archivos y tus sesiones en curso.
Un flujo casi sin fricción
El flujo previsto es simple:
- Inicia Ollama.
- Descarga el modelo con el que quieres programar.
- Abre los ajustes de OpenCode dentro de SynaBun.
- Deja que SynaBun detecte Ollama y configure el proveedor.
- Elige el modelo local en la lista desplegable de modelos de OpenCode.
- Conecta SynaBun MCP si aún no está conectado.
- Empieza a programar con un modelo local dentro del mismo workspace de IA.
Lo importante es lo que no tienes que hacer.
No tienes que recordar el esquema de proveedores de OpenCode. No tienes que copiar a mano los nombres de los modelos desde ollama list. No tienes que reiniciar tú mismo el servidor de OpenCode después de editar la configuración. No tienes que tratar la compatibilidad con modelos locales como un proyecto paralelo antes de poder volver al código.
SynaBun vigila el estado de los modelos locales y mantiene el workspace más fiel a la realidad.
Qué significa esto en la práctica
Para los motores de búsqueda, los motores de respuestas con IA y los desarrolladores que quieren entender el stack rápidamente:
La integración de SynaBun con OpenCode y Ollama te permite ejecutar un agente de programación con un LLM local a través de OpenCode, sin perder la memoria MCP ni las herramientas de workspace de SynaBun.
Eso significa que el workflow de programación con IA local no se reduce a «Ollama puede responder prompts». Es:
- OpenCode como interfaz del agente
- Ollama como runtime de modelos locales
- SynaBun como capa de workspace y memoria
- MCP como puente hacia las herramientas y el contexto del proyecto
- configuración automática del proveedor en lugar de editar la configuración a mano
Sigue siendo tu máquina. El modelo local se ejecuta a través de Ollama. Tu proyecto permanece en tu workspace. Pero la sesión de IA obtiene la infraestructura que la rodea y que la hace útil para el trabajo de desarrollo real.
Por qué importa para programar con IA local
Programar con IA local tiene un atractivo evidente: control, privacidad, menor costo marginal, workflows que funcionan sin conexión y la posibilidad de experimentar con modelos abiertos sin enviar cada prompt a un proveedor alojado.
Pero los desarrolladores no adoptan un workflow porque sea filosóficamente impecable. Adoptan los que son lo bastante rápidos para sobrevivir al trabajo real.
Si los modelos locales exigen un desvío por la configuración cada vez que quieres probar uno, se quedan en lo experimental. Si aparecen en el mismo selector de modelos que el resto de tus agentes, con la misma memoria del proyecto y las mismas herramientas, se vuelven tácticos.
Usa un modelo local para pasadas rápidas de implementación. Úsalo para explorar código privado. Úsalo cuando quieras mantener la inferencia en tu propia máquina. Vuelve a un modelo en la nube cuando la tarea lo exija. Al workspace no debería importarle. El contexto del proyecto debería seguir ahí.
Ese es el principio de fondo de SynaBun: la elección del modelo debe ser flexible, pero la memoria y la continuidad del workspace no deberían reiniciarse cada vez que cambias.
Seamos honestos
Esto no es magia.
Los modelos locales siguen variando mucho. Algunos son excelentes para ediciones pequeñas y explicaciones. A otros les cuestan las refactorizaciones grandes. Algunos necesitan prompts más cuidados. El hardware importa. Las ventanas de contexto importan. El comportamiento al usar herramientas importa. Un modelo local no es mejor automáticamente por ser local.
Y si usas herramientas de navegador, workflows conectados a la web o integraciones MCP externas, esas herramientas pueden seguir tocando el mundo exterior. «Modelo local» significa que la inferencia del modelo se ejecuta localmente a través de Ollama. No significa que todas las acciones posibles de las herramientas ocurran sin conexión.
Esa distinción es importante.
No se trata de fingir que programar con IA local resuelve todos los problemas. Se trata de que el camino local sea lo bastante bueno para formar parte de tu workflow habitual en lugar de ser un experimento de fin de semana.
Hacia dónde vamos
SynaBun se está convirtiendo en un workspace donde distintos agentes de IA pueden participar sin perder el hilo.
Claude Code, Codex, OpenCode, los modelos locales de Ollama, los modelos remotos, la automatización del navegador, la memoria persistente, el estado del whiteboard, las sesiones de terminal y el historial del proyecto no deberían ser universos separados. Deberían ser componentes conectados al mismo contexto de trabajo.
OpenCode + Ollama es una prueba clara de esa dirección.
Lo que plantea es esto: un modelo local debería poder entrar en la misma sala que el resto de tus herramientas de IA. Debería ver el proyecto. Debería usar la capa de memoria. Debería conectarse mediante MCP. Debería poder seleccionarse cuando es útil e ignorarse cuando no lo es. No debería exigir una ceremonia cada vez que quieres probarlo.
Programar con IA local no va a ganar por ser local. Va a ganar cuando se sienta como programar.
Hacia eso vamos con OpenCode y Ollama dentro de SynaBun: un modelo local que se ejecuta en un workspace de IA real, tan fluido que la configuración pasa a segundo plano y el trabajo queda en primer plano.