Enjambre de agentes OpenCode: ejecuta varios agentes opencode en paralelo

Un enjambre de agentes opencode no es más que varios agentes de opencode trabajando en paralelo en lugar de uno detrás de otro. Como cada sesión de opencode es su propio proceso, nada te impide tener un puñado funcionando a la vez, cada uno con su tarea. El truco no está en arrancar los procesos. Está en no perderles la pista cuando ya tienes tres o cuatro agentes editando archivos, esperando permisos y terminando en momentos distintos. Ahí es donde suelen romperse los enjambres mal montados. opencode añade un matiz que conviene saber de entrada: como es agnóstico de proveedor, los agentes de tu enjambre ni siquiera tienen que compartir el mismo proveedor de modelos. En esta guía te explico las tres formas reales de ejecutar un enjambre de opencode, las comparo de forma honesta y te muestro dónde empieza a doler cada una. Si quieres la foto completa de todas las CLI, empieza por la visión general del enjambre de agentes CLI de IA, y si quieres la mecánica de las sesiones en paralelo en concreto mira cómo ejecutar varias sesiones de opencode.

La respuesta corta: sí, puedes montar un enjambre de opencode

Varios terminales de opencode ejecutándose en paralelo en un único espacio de trabajo de CodeAgentSwarm, cada uno una sesión de opencode independiente — Un enjambre de agentes opencode: varias sesiones de opencode independientes ejecutándose a la vez en una sola ventana de CodeAgentSwarm.

Una sesión de opencode es solo un proceso. La arrancas con el comando opencode, conectas un proveedor de modelos una vez (consulta la documentación oficial de opencode para el flujo exacto de autenticación, algo del estilo opencode auth login) y, a partir de ahí, cada sesión tiene su propia conversación, su propio contexto y su propio directorio de trabajo. Dos sesiones no saben nada la una de la otra.

Así que un enjambre de agentes opencode no es un modo especial que desbloqueas. Es simplemente más de un agente de opencode funcionando al mismo tiempo. Abre un segundo terminal, ejecuta opencode otra vez y ya tienes dos agentes independientes. Uno puede estar migrando una capa de base de datos mientras el otro escribe tests de integración. Añade un tercero y un cuarto y tienes un pequeño enjambre.

opencode tiene una propiedad que la mayoría de agentes CLI no: es agnóstico de proveedor, así que funciona con Anthropic, OpenAI, Google y modelos locales. Eso significa que un enjambre no tiene por qué ser de un solo proveedor a nivel de modelo. Puedes apuntar un terminal a Anthropic, otro a OpenAI, un tercero a Google y un cuarto a un modelo local, todos sobre el mismo repositorio. Cada agente elige el modelo que mejor le va a su tarea, y a ninguno le importa con qué corren los demás.

opencode es de código abierto. Cada agente usa la cuenta de proveedor que le conectaste, así que no hay un plan "de enjambre" aparte ni un sobrecoste por tener varios agentes en paralelo. Le pagas a cada proveedor por lo que cada agente hace en realidad.

El trabajo de verdad es gestionar el enjambre cuando crece. Según tu configuración de permisos, los agentes de opencode se paran a pedir aprobación en algunas acciones, terminan en momentos distintos y a veces tocan los mismos archivos. Los tres métodos de abajo resuelven esa coordinación con muy distinta cantidad de fricción.

Método 1: varias ventanas de terminal (gratis, básico)

La forma más obvia de montar un enjambre de opencode es abrir varias pestañas de terminal, entrar en tu proyecto en cada una y arrancar opencode. No hay nada que instalar más allá del propio opencode (npm install -g opencode-ai).

bash

# Pestaña 1
cd ~/mi-proyecto
opencode

# Pestaña 2
cd ~/mi-proyecto
opencode

# Pestaña 3
cd ~/mi-proyecto
opencode

Cada pestaña es ahora un agente de opencode independiente. Puedes darle una tarea distinta a cada uno e ir cambiando entre ellos mientras trabajan. Si tu configuración de permisos hace que los agentes pregunten antes de ejecutar comandos o escribir archivos, cada pestaña se detendrá a esperarte, lo que te obliga a saltar de pestaña en pestaña para que sigan avanzando. Si además apuntas cada pestaña a un proveedor distinto, tienes que acordarte de qué modelo hay detrás de cada una.

Ventajas

Gratis, nada que configurar más allá de opencode
Funciona al instante con herramientas que ya tienes
Fácil de razonar: una pestaña es un agente

Desventajas

Pierdes la pista de qué pestaña hace qué casi de inmediato
Sin aviso cuando un agente de opencode termina o se para a pedir un permiso
Sin vista compartida: tienes que entrar en cada pestaña para ver el progreso
No hay forma de buscar en el historial de conversación de los distintos agentes
Si dos agentes editan el mismo archivo, desliarlo es cosa tuya
Con tres pestañas o más todas se ven iguales, y nada indica qué proveedor usa cada una

Para dos agentes va bien. A partir de ahí, el tiempo que pasas buscando la pestaña que necesita tu atención empieza a comerse la velocidad que ganaste al ir en paralelo.

Método 2: tmux o screen (gratis, avanzado)

Si vives en el terminal, tmux te deja dividir una ventana en paneles y mantener sesiones vivas en segundo plano. Puedes ver varios agentes de opencode a la vez sin cambiar de pestaña.

bash

# Inicia una sesión nueva de tmux
tmux new-session -s opencode-swarm

# Divide en horizontal
tmux split-window -h

# Divide el panel derecho en vertical
tmux split-window -v

# Ahora tienes 3 paneles - ejecuta opencode en cada uno

tmux también te deja desconectarte y volver a conectarte, así que tus agentes de opencode siguen funcionando aunque cierres la ventana del terminal. Eso es muy útil para migraciones o refactors largos, sobre todo cuando un panel corre en un modelo más lento o más barato que los demás y tarda más en terminar.

Ventajas

Gratis y disponible en casi cualquier máquina Unix
Ves varios paneles a la vez, sin cambiar de pestaña
Las sesiones sobreviven a las desconexiones, ideal para tiradas largas
Programable y configurable hasta el último atajo de teclado

Desventajas

Curva de aprendizaje real si nunca has usado tmux
Sigue sin haber aviso de escritorio cuando un agente termina o pide un permiso
Sin historial de conversación ni búsqueda entre agentes
Los paneles de solo texto se quedan estrechos pasando de tres o cuatro agentes de opencode
No hay tablero de tareas ni capa de organización encima
Rehaces el layout a mano en cada sesión, salvo que lo programes
Los conflictos entre agentes que tocan el mismo archivo siguen siendo tu problema

tmux es un gran multiplexor de propósito general y muchos developers ya lo usan. Pero nunca se diseñó para supervisar agentes de IA en concreto. En el momento en que un agente de opencode en el panel 3 se para en silencio a pedir un permiso mientras tú lees el panel 1, notas el hueco.

Método 3: CodeAgentSwarm (visual, completo)

CodeAgentSwarm es una app de escritorio hecha justo para esto: ejecutar y supervisar un enjambre de agentes CLI de IA en un solo sitio. Funciona en macOS, Linux y Windows, te da varios terminales en un mismo espacio de trabajo y te deja elegir el agente por terminal. Para un enjambre de opencode solo tienes que elegir "opencode" en el selector SELECT AI AGENT de cada terminal que quieras con opencode.

Un terminal de CodeAgentSwarm mostrando el selector SELECT AI AGENT donde eliges el agente por terminal, incluido opencode — En CodeAgentSwarm eliges el agente por terminal. Pon cada uno en opencode para montar un enjambre de opencode.

Esto es lo que ganas cuando todos los agentes son opencode (o una mezcla):

Varios agentes de opencode en paralelo

Pon cada terminal en "opencode" para un enjambre 100% opencode, o mezcla Claude Code y Codex CLI donde encajen mejor. Cada terminal es un proceso de opencode totalmente independiente, con su propia conversación y contexto de proyecto, y cada uno puede apuntar al proveedor que le conectaste. CodeAgentSwarm funciona por encima de tus cuentas actuales, así que no es un proveedor de modelos: solo orquesta los agentes que ya pagas.

Visibilidad en tiempo real con títulos dinámicos

Cada terminal actualiza su propio título para reflejar lo que está haciendo su agente de opencode en ese momento. En lugar de varias pestañas etiquetadas todas como "opencode", lees títulos como "Migrando esquema de usuarios", "Escribiendo tests de API" o "Refactorizando auth". Sabes qué agente lleva qué tarea sin entrar en ninguno.

Notificaciones de escritorio

Esto es lo que más arregla un enjambre. Cuando un agente de opencode termina su tarea o se para a pedir un permiso, recibes una notificación nativa de escritorio. Dejas de vigilar paneles y dejas que los agentes te llamen cuando de verdad te necesitan, que es justo el sentido de tenerlos en paralelo.

Historial completo de conversaciones, con búsqueda

opencode guarda sus sesiones en local, y CodeAgentSwarm las lee, así que cada conversación de opencode se guarda y se puede buscar, también entre agentes distintos. Puedes volver atrás y encontrar qué decidió ayer un agente de opencode, retomarlo o rastrear exactamente qué agente hizo un cambio concreto. La guía del historial de conversaciones de opencode explica cómo funciona. Con un enjambre en marcha, ese rastro es lo que mantiene legible todo el conjunto.

Tablero de tareas integrado

Un tablero kanban de tareas vive junto a tus terminales, y los propios agentes lo actualizan por MCP. Creas tareas, se las pasas a los terminales y ves moverse las tarjetas a medida que cada agente de opencode coge, trabaja y termina. Cuando varios agentes avanzan sobre funcionalidades relacionadas, el tablero mantiene el plan a la vista en lugar de solo en tu cabeza.

Modo full auto según la configuración de opencode

opencode no tiene un único flag de full-auto ni de saltarse las confirmaciones. Cómo de autónomo corre un agente lo decide su configuración de permisos en opencode.json, que puedes fijar de forma global en ~/.config/opencode/opencode.json, por proyecto o por agente. Así que la forma de ejecutar un enjambre sin intervención es aflojar los permisos en esa configuración, no pulsar un interruptor. Por eso CodeAgentSwarm no añade un toggle de Turbo Mode para opencode como sí hace con Claude Code y Codex. En su lugar mantiene supervisada una configuración permisiva de opencode: tienes los diffs en vivo y las notificaciones de escritorio de abajo para que una configuración sin intervención nunca corra a ciegas. La guía del modo YOLO de opencode tiene la foto completa sobre autonomía y permisos.

Diffs de archivos en vivo por terminal

Puedes ver en tiempo real los cambios de archivos que va haciendo cada agente de opencode, por terminal y a nivel de proyecto. Cuando dos agentes editan el mismo archivo, lo ves mientras pasa en lugar de descubrirlo más tarde en un diff hecho un lío. Git sigue encargándose del merge, pero esa visibilidad hace que las ediciones solapadas nunca te pillen por sorpresa. Con opencode esto importa más precisamente porque no hay un interruptor de full-auto en el que apoyarse: los diffs en vivo son la forma de mantener responsable una configuración permisiva.

¿Es la primera vez que ejecutas varios terminales a la vez? La guía de múltiples terminales repasa el layout y el flujo de trabajo, y se aplica igual tanto si el agente es opencode como Claude Code.

Comparativa rápida

Así quedan las tres formas de ejecutar un enjambre de opencode en lo que de verdad molesta cuando pasas de dos agentes:

Coste

Pestañas de terminal: Gratis
tmux/screen: Gratis
CodeAgentSwarm: Plan gratuito disponible, Pro para funciones avanzadas. Tu uso de opencode lo facturan los proveedores que conectes.

Tiempo de configuración

Pestañas de terminal: Cero, solo abrir pestañas y ejecutar opencode
tmux/screen: De 10 a 30 minutos para lo básico, más para programar un layout reutilizable
CodeAgentSwarm: Un par de minutos para descargar, abrir y elegir opencode por terminal

Notificaciones

Pestañas de terminal: Ninguna
tmux/screen: Ninguna salvo que programes algo a medida
CodeAgentSwarm: Notificaciones nativas de escritorio cuando un agente termina o necesita un permiso

Historial de conversaciones

Pestañas de terminal: Se pierde al cerrar la pestaña
tmux/screen: Se mantiene mientras la sesión viva, sin búsqueda
CodeAgentSwarm: Lee las sesiones que opencode guarda en local y las hace buscables entre todos los agentes

Supervisión en full-auto

Pestañas de terminal: Todo recae en ti, pestaña a pestaña
tmux/screen: Visible en paneles, pero sin guardarraíles encima
CodeAgentSwarm: La configuración de opencode decide la autonomía, CodeAgentSwarm añade diffs en vivo, notificaciones y visibilidad por terminal para que las configuraciones permisivas sigan supervisadas

Curva de aprendizaje

Pestañas de terminal: Ninguna
tmux/screen: De media a pronunciada, con atajos y archivos de configuración
CodeAgentSwarm: Baja, una interfaz visual con patrones familiares

Si nunca necesitas más de dos agentes de opencode a la vez, las pestañas de terminal van perfectamente. Si ya pasas el día dentro de tmux, meter unas cuantas sesiones de opencode en tus paneles es lo natural. Pero en cuanto ejecutas tres o más agentes de opencode de forma habitual, sobre todo repartidos entre distintos proveedores de modelos, y quieres ver de verdad qué hace cada uno, CodeAgentSwarm te quita la carga de coordinación que las otras dos te dejan encima.

Preguntas frecuentes

Un enjambre de agentes opencode es simplemente varios agentes de opencode funcionando en paralelo en lugar de uno detrás de otro. Cada agente es su propio proceso con su propia conversación y contexto, así que pueden trabajar en tareas distintas dentro del mismo repositorio al mismo tiempo. No es una función especial de opencode, solo una forma de trabajar que puedes montar con pestañas de terminal, con tmux o con una herramienta como CodeAgentSwarm.

Sí. Cada vez que ejecutas el comando opencode obtienes una sesión independiente, así que puedes abrir varios terminales y ejecutar opencode en cada uno. No comparten contexto ni se pisan entre sí salvo que editen los mismos archivos. CodeAgentSwarm admite varios terminales para que supervises todo el enjambre en una sola ventana.

Sí. Como cada agente es solo un proceso aparte, puedes ejecutar opencode en algunos terminales y Claude Code o Codex CLI en otros, todos sobre el mismo proyecto. En CodeAgentSwarm eliges el agente por terminal con el selector SELECT AI AGENT, así que un enjambre mixto es lo normal y no un apaño.

Sí, y es una de las fortalezas de opencode. opencode es agnóstico de proveedor, así que funciona con Anthropic, OpenAI, Google y modelos locales. En un enjambre puedes poner cada terminal en un proveedor distinto: un agente en Anthropic, otro en OpenAI, otro en un modelo local, todos en el mismo repositorio. Cada agente corre en el proveedor que le conectaste, así que puedes ajustar el modelo a la tarea en lugar de quedarte atado a un único proveedor.

No hay recargo por ejecutar agentes en paralelo. Cada agente de opencode usa la cuenta de proveedor que le conectaste, y cada proveedor te factura por el trabajo que su agente hace en realidad, igual que si los ejecutaras uno tras otro. Hacerlo a la vez termina antes, no cambia el coste por agente.

tmux puede alojar perfectamente un enjambre de opencode en paneles divididos, y es gratis. Lo que le falta es todo lo pensado para agentes de IA: ningún aviso de escritorio cuando un agente termina o pide un permiso, ningún historial con búsqueda entre agentes, ningún título dinámico, ningún tablero de tareas y ningún diff en vivo para mantener responsable una configuración permisiva de opencode. CodeAgentSwarm añade todo eso por encima, que es lo que más importa justo cuando ejecutas varios agentes de opencode a la vez, quizá en distintos proveedores.

Ejecuta tu enjambre de agentes opencode en CodeAgentSwarm. Varios terminales de opencode en paralelo, en el proveedor de modelos que quieras, con diffs en vivo y notificaciones de escritorio para mantener a raya a cada agente.

Probar CodeAgentSwarm

También te puede interesar

Agent Teams de Claude Code vs CodeAgentSwarm: cuál es la diferencia

Los agent teams de Claude Code y CodeAgentSwarm parecen competir, pero resuelven problemas distintos y funcionan bien juntos. Los agent teams son la función nativa de Anthropic para que una sola sesión de Claude genere sus propios subagentes y reparta una única tarea. CodeAgentSwarm es un espacio de trabajo de escritorio que ejecuta varias terminales CLI totalmente independientes en paralelo, cada una su propio proceso y conversación.

Leer guía

Ver todas las guías