# Cómo ejecutar varios agentes de Claude Code en paralelo

URL: https://agentvera.dev/es/blog/run-multiple-claude-code-agents/ · Publicado: 2026-10-08

Ejecuta varios agentes de Claude Code en paralelo con terminales, tmux, git worktrees o una app de escritorio y evita conflictos de merge, límites y gasto extra.

**En resumen:**

- Puedes ejecutar varios agentes de Claude Code en terminales separadas, tmux, git worktrees, la app de escritorio de Claude Code o AgentVera; tmux da visibilidad, no aislamiento.
- Todas las sesiones de una misma cuenta comparten los límites de 5 horas y semanal, así que cuatro agentes llegan al límite unas cuatro veces más rápido.
- Los worktrees no evitan los conflictos de merge: fusiona una rama cada vez, deja los archivos compartidos a un solo agente y empieza con dos agentes.

Una sesión de Claude Code resuelve una tarea paso a paso. Mientras lee archivos y ejecuta tests, tú esperas. Ejecutar varios agentes de Claude Code en paralelo convierte ese tiempo de espera en trabajo: un agente construye la API, otro escribe los tests y un tercero arregla un bug que no tiene nada que ver con los otros dos.

Este artículo va de la configuración más simple a la más cómoda: terminales normales, tmux, git worktrees, las sesiones paralelas del propio Claude Code y, por último, AgentVera. Cada paso añade algo que le faltaba al anterior. Al final hay una lista de las trampas que suelen morder: conflictos de merge, límites y tokens.

## ¿Se puede ejecutar más de un agente de Claude Code a la vez?

Sí. Claude Code es un CLI; cada vez que ejecutas `claude` inicias una sesión independiente con su propia conversación y contexto. Nada te impide iniciar cinco. Lo que puede salir mal no es arrancarlos, sino coordinarlos: dos sesiones en la misma carpeta editarán alegremente el mismo archivo, y todas las sesiones con una misma cuenta comparten sus límites.

Así que la pregunta real es cómo mantenerlos separados y cómo seguirlos.

## Opción 1: ventanas de terminal separadas

La configuración más rápida es una pestaña de terminal por agente:

```bash
# tab 1
cd ~/code/acme-web && claude
# tab 2
cd ~/code/acme-web && claude
```

Funciona para tareas pequeñas y bien separadas. Dile a cada agente en su primer mensaje qué carpetas puede tocar («solo `src/api/`», «solo `tests/`»).

Los inconvenientes aparecen enseguida: no ves qué pestaña está esperando aprobación, ambas sesiones comparten una única copia de trabajo, y cuando un agente ejecuta `git checkout`, el otro de repente está en otra rama.

## Opción 2: tmux

tmux mantiene las sesiones vivas cuando cierras la terminal y te deja ver varios paneles a la vez:

```bash
tmux new-session -d -s agents -c ~/code/acme-web
tmux split-window -h -t agents -c ~/code/acme-web
tmux send-keys -t agents:0.0 'claude' Enter
tmux send-keys -t agents:0.1 'claude' Enter
tmux attach -t agents
```

Ahora ambos agentes se ven lado a lado y sobreviven a la tapa del portátil cerrada (mientras la máquina siga encendida). tmux resuelve la visibilidad, no el aislamiento: ambos paneles siguen editando la misma carpeta.

## Opción 3: un git worktree por agente

Los git worktrees son la respuesta estándar a «dos agentes, un repositorio». Un worktree es una segunda carpeta de trabajo en su propia rama, que comparte el mismo historial de `.git`:

```bash
cd ~/code/acme-web
git worktree add ../acme-web-api -b feat/api
git worktree add ../acme-web-tests -b feat/tests

cd ../acme-web-api && claude     # agent 1
cd ../acme-web-tests && claude   # agent 2
```

Ahora cada agente tiene sus propios archivos y su propia rama. El `git checkout` o el archivo a medio escribir de un agente no afecta al otro. Cuando un agente termina, su rama se fusiona como cualquier rama de feature.

Algunas notas prácticas:

- **Instala las dependencias en cada worktree.** `node_modules`, los entornos virtuales y la salida de compilación no se comparten. Ejecuta `pnpm install` (o equivalente) en cada carpeta nueva.
- **Copia la configuración local.** Los archivos `.env` suelen estar ignorados por git, así que no aparecen en un worktree nuevo.
- **Los puertos chocan.** Dos servidores de desarrollo en el puerto 3000 no arrancan; dale a cada worktree su propio puerto.
- **Limpia.** `git worktree remove ../acme-web-api` cuando la rama esté fusionada, y `git worktree prune` para las carpetas que borraste a mano.

Los detalles están en [git worktrees para agentes en paralelo](/es/blog/git-worktree-parallel-agents/).

## Opción 4: las sesiones paralelas de Claude Code

La app de escritorio de Claude Code de Anthropic puede ejecutar sesiones paralelas de Claude, cada una en su propio worktree, sin que escribas los comandos de git. Si solo usas Claude y quieres la herramienta oficial, es una parada razonable. Cubre el aislamiento y una vista general básica.

Lo que no intenta hacer: ejecutar otros CLI como Codex o Gemini CLI junto a Claude, pasar la salida de un agente a otro automáticamente, o mover un agente a otra cuenta cuando se agota un límite. Ahí entra una app multiagente dedicada. Para comparar las opciones, consulta [las mejores herramientas para ejecutar varios agentes de código con IA en paralelo](/es/blog/best-tools-parallel-ai-coding-agents/).

## Opción 5: AgentVera

[AgentVera](/es/agents/claude-code/) abre el comando `claude` de tu máquina en terminales reales y distribuye los agentes en una cuadrícula por proyecto. Usa el inicio de sesión propio de Claude Code, así que tu plan Pro o Max funciona tal cual. Así se corresponden los problemas anteriores con sus funciones:

| Problema | En AgentVera |
| --- | --- |
| No ves qué agente te necesita | Cuadrícula de 1×1 a 5×4; cada panel muestra el estado y el tamaño del contexto en vivo; los agentes que esperan aprobación aparecen en la barra de estado |
| Los agentes editan los mismos archivos | Panel de worktrees: crea un worktree desde una rama e inicia un agente directamente en él |
| Dos agentes tocan un mismo archivo de todos modos | Un aviso de conflicto de archivos: cuando dos agentes editan el mismo archivo en la misma carpeta, se avisa al agente y a ti; no se bloquea nada |
| Hay que copiar la salida a mano | Los [Flows](/es/features/flows/) envían la respuesta de un agente a otro mediante una plantilla |
| El límite se agota a mitad de tarea | El [cambio de cuentas](/es/features/account-switching/) mueve el agente a la siguiente cuenta de Claude y copia la conversación |
| El contexto crece en cada turno | `/compact` automático en el umbral que fijes, más [perfiles de contexto](/es/features/token-savings/) |

### Paso a paso

1. **Añade la carpeta del proyecto.** Elígela en la pantalla de proyectos. Se recomienda un repositorio Git.
2. **Crea los worktrees.** En el panel derecho, abre la lista de worktrees y crea uno por tarea desde una rama nueva, por ejemplo `feat/api` y `feat/tests`.
3. **Abre los agentes.** En «New agent», elige Claude Code, selecciona el worktree y dale al agente un nombre, un modelo, un nivel de esfuerzo y un rol corto:

   ```text
   Work only under src/api/. Don't change tests.
   Run pnpm test api after each change.
   Finish with a bullet list of what you changed.
   ```

4. **Organiza la cuadrícula.** Una disposición 2×2 permite dos agentes Claude, un revisor Codex y una terminal con el servidor de desarrollo.
5. **Conéctalos si hace falta.** Un flow puede enviar el resumen final del agente de la API al agente de tests cuando termine su turno. Un límite de turnos evita que dos agentes entren en bucle.
6. **Revisa y fusiona.** La revisión de código automática comprueba cada turno terminado. El [panel de Git](/es/features/git-and-github/) muestra los cambios de cada worktree y cuánto se adelanta a main; fusiona una rama cada vez.

La cuadrícula, los worktrees y la revisión de código están en el plan gratuito. Los flows y el cambio de cuentas están en Pro.

## Trampas y cómo evitarlas

### Conflictos de merge

Los worktrees evitan que los agentes se pisen mientras trabajan; no evitan los conflictos al fusionar. Dos agentes que editan `src/routes.ts` en ramas distintas seguirán chocando al final.

- Divide las tareas por carpeta o módulo, no solo por rama.
- Deja los archivos compartidos (tablas de rutas, esquemas, lockfiles) a un solo agente.
- Fusiona primero la rama más pequeña, luego haz rebase del otro worktree sobre main y deja que su agente resuelva el conflicto: `git rebase main` dentro de ese worktree, y después pide al agente que lo resuelva y vuelva a ejecutar los tests.

### Límites de uso

Todas las sesiones de una cuenta comparten los mismos límites de 5 horas y semanal. Cuatro agentes no tienen cuatro veces la cuota; llegan al límite cuatro veces más rápido. Revisa `/usage` en Claude Code con regularidad y planifica las sesiones paralelas pesadas al principio de una ventana de límite. Si legítimamente tienes más de una cuenta (por ejemplo, personal y de trabajo) y los términos del proveedor lo permiten, el cambio de cuentas mantiene la tarea en marcha cuando una se agota. Más información en [límites de uso de Claude Code](/es/blog/claude-code-usage-limits/).

### Uso de tokens

Cada agente lleva su propio contexto: prompt del sistema, definiciones de herramientas, CLAUDE.md, servidores MCP y cada archivo que ha leído. Esa base se vuelve a leer en cada turno, por agente.

- Dale a los agentes tareas concretas y acotadas para que lean menos archivos.
- Ejecuta `/compact` antes de que una conversación larga se encarezca, o deja que se ejecute automáticamente en un umbral.
- Desactiva los servidores MCP que un agente no necesita.
- Al pasar la salida entre agentes, envía el resumen, no la transcripción completa.

Hay cifras medidas en [cómo reducir el uso de tokens de Claude Code](/es/blog/claude-code-token-usage/).

### Aprobaciones que bloquean

Un agente que espera permiso se detiene mientras los demás siguen. Con cinco paneles es fácil perder uno de vista. Vigila el estado, usa notificaciones, o permite acciones seguras (leer archivos, ejecutar tests) en los ajustes de permisos de Claude Code para que los agentes pregunten menos.

### Demasiados agentes, demasiado pronto

El cuello de botella pasa de los agentes a ti. Revisar cuatro ramas lleva más tiempo que revisar una. Empieza con dos agentes en tareas claramente separadas y añade un tercero cuando eso funcione.

## Una lista de comprobación mínima

- [ ] Un worktree por agente que pueda tocar código compartido
- [ ] Dependencias instaladas y `.env` copiado en cada worktree
- [ ] El rol de cada agente nombra sus carpetas y su objetivo
- [ ] Puertos distintos para los servidores de desarrollo
- [ ] Un plan de fusión: qué rama primero, quién resuelve los conflictos
- [ ] Un ojo en `/usage` y en el tamaño del contexto

## Para terminar

Ejecutar varios agentes de Claude Code en paralelo es sobre todo cuestión de aislamiento y atención. Los worktrees dan a cada agente sus propios archivos; tmux o una cuadrícula te dejan verlos todos; roles cortos y un plan de fusión mantienen el resultado revisable. Las terminales normales y los worktrees bastan para empezar. Cuando quieras una cuadrícula, flows entre agentes y ayuda con los límites, [descarga AgentVera gratis](/es/download/) y abre tus dos primeros agentes de Claude Code. Para el método general, consulta [agentes de código en paralelo](/es/blog/parallel-coding-agents/).

## Preguntas frecuentes

**¿Puedo ejecutar dos sesiones de Claude Code en la misma carpeta?** Sí, Claude Code arrancará, pero ambas sesiones editan los mismos archivos y ven los cambios a medias de la otra. Dale a cada sesión su propio git worktree, o al menos un límite de carpetas estricto.

**¿Comparten varios agentes de Claude Code un único límite de uso?** Sí. Todas las sesiones con la misma cuenta consumen los mismos límites de 5 horas y semanal, así que cuatro agentes los agotan aproximadamente cuatro veces más rápido.

**¿Cuántos agentes de Claude Code puedo ejecutar a la vez?** Claude Code no impone un tope fijo. En la práctica, entre dos y cuatro es lo que una persona puede seguir; los límites y el tiempo de revisión son el techo real.

**¿Cómo fusiono el trabajo de agentes de Claude Code en paralelo?** Trata cada worktree como una rama normal: ejecuta los tests ahí, haz push y abre un pull request, o fusiona en local. Fusiona una rama cada vez y vuelve a ejecutar los tests después de cada una.

---

**Sobre AgentVera.** AgentVera es una app de escritorio para macOS, Windows y Linux, desarrollada por Solviera Teknoloji. Ejecuta 18 agentes de programación con IA (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) en paralelo, por proyecto, en terminales reales con las instalaciones y sesiones de CLI del propio usuario. El plan gratuito tiene agentes ilimitados. Descargar: https://agentvera.dev/es/download/ · Precios: https://agentvera.dev/es/pricing/