Nivel inicial15 min de lectura · Revisado el

Git worktree: agentes de IA y Claude Code en paralelo

Agentes en paralelo con git worktree: tres partidas de cocina separadas, cada una con su tarea, y un pase donde una persona comprueba lo que llega de las tres. Agentes en paralelorubentejera.com ivacupónenvío Cada uno, aparteUna persona integra
Cada agente trabaja en su partida; el pase es la integración, y ahí sigue haciendo falta una persona.

git worktree es un comando de Git que crea varias carpetas de trabajo del mismo repositorio, cada una con su rama. Trabajar con agentes de IA en paralelo es aprovecharlo para repartir varias tareas entre varios agentes, cada uno en su carpeta, y después integrar lo que entregan.

Si cinco agentes terminan cinco tareas en una hora, ¿quién revisa e integra cinco cambios en esa hora? Es la pregunta que deja la semana. El 17 de noviembre de 2026, Cognition presentó Devin Bots, agentes que dirigen a otros agentes, y Replit presentó Missions, varios agentes hacia un objetivo con presupuesto. Los dos anuncios prevén puertas: integración continua y revisión en Devin, aprobaciones y un juez con criterios de éxito en Replit. Este artículo explica git worktree, cómo montarlo con agentes y con tests, con una prueba ejecutada, y por qué el límite no está en los agentes sino en la integración. Es la idea de la IA Limpia: la IA acelera lo que ya hay, también el atasco.

Un símil: varias partidas, un solo pase

En un restaurante grande hay varias partidas: una para los fríos, otra para la plancha, otra para los postres. Cada una trabaja a su ritmo sin estorbar a las demás. Pero todos los platos pasan por el mismo sitio antes de salir: el pase, donde el jefe de cocina comprueba que el plato está bien y que los de una mesa salen juntos.

Los worktrees son las partidas: cada agente cocina en la suya. La integración es el pase. El símil se queda corto en una cosa: en la cocina, un plato mal hecho se ve. En el código, dos cambios que funcionan por separado pueden fallar juntos sin que nada lo avise, salvo un test.

Qué es git worktree

Un worktree es una carpeta de trabajo extra del mismo repositorio. Comparte el historial y el remoto con la carpeta principal, pero tiene sus propios ficheros y su propia rama. Según la documentación de Claude Code, dar a cada sesión su propio worktree permite que una construya una funcionalidad mientras otra corrige un fallo, sin que sus cambios choquen.

Git worktree, ramas, stash o clonar dos veces

Opción Dos tareas a la vez Qué comparte
Cambiar de rama No: una carpeta, una rama cada vez Todo
git stash No: guarda una tarea para seguir con otra Todo
Clonar dos veces Sí Solo el remoto: dos repositorios y dos historiales que sincronizar con push y fetch
git worktree Sí El historial y el remoto; cada carpeta tiene sus ficheros y su rama

Comandos básicos de git worktree

Crear un worktree con una rama nueva:

git worktree add -b agente/iva ../tienda-iva
Preparing worktree (new branch 'agente/iva')
HEAD is now at 7fb12d6 Precio final sin descuentos

Crear uno con una rama que ya existe:

git worktree add ../login fix/login
Preparing worktree (checking out 'fix/login')
HEAD is now at da70066 Inicio

Ver los que tienes:

git worktree list
~/tienda       7fb12d6 [main]
~/tienda-cupon 7fb12d6 [agente/cupon]
~/tienda-iva   7fb12d6 [agente/iva]

Borrarlo cuando terminas (solo si no tiene cambios ni ficheros nuevos sin commit; si los tiene, Git se niega y pide --force):

git worktree remove ../tienda-iva

Limpiar los que borraste a mano con rm, que Git sigue apuntando:

git worktree prune -v
Removing worktrees/login: gitdir file points to non-existent location

Después, la rama se borra con git branch -d.

Claude Code y git worktree: –worktree y subagentes

Claude Code lo hace en un paso. Según su documentación, claude --worktree nombre crea por defecto el worktree en .claude/worktrees/nombre/, en una rama nueva llamada worktree-nombre que sale de la rama principal del remoto, y abre la sesión dentro. Algunos detalles que conviene saber:

  • Al salir, si el worktree no tiene cambios y la sesión no tiene nombre, lo borra con su rama; si hay trabajo o la sesión tiene nombre, pregunta si lo conservas.
  • Parte de la rama principal del remoto, no de tu trabajo local: si tienes commits sin subir, el agente no los ve, salvo que pongas worktree.baseRef en "head".
  • Un worktree empieza limpio: hay que instalar las dependencias en cada uno, y los ficheros que Git ignora, como .env, no aparecen. Estos se copian con un fichero .worktreeinclude.
  • Los permisos se comparten. Si en un worktree eliges «Yes, and don’t ask again», la regla se guarda en la carpeta principal y vale para todos los worktrees: lo que apruebas para un agente lo apruebas para todos.
  • Los subagentes también pueden trabajar cada uno en su worktree, con isolation: worktree en su definición; la documentación de subagentes lo explica, y en esta web, el artículo sobre subagentes de Claude Code.
  • Mientras trabaja en un worktree, Claude Code bloquea las ediciones de ficheros y los comandos que se ejecutan en la carpeta principal o llevan Git a ella. No vigila qué ficheros escribe un comando: un cp o una redirección hacia la carpeta principal no los para, y eso queda para los permisos y la sandbox.

Una prueba: dos agentes, dos tareas, una integración

Para verlo sin depender de ningún agente concreto, la prueba simula a dos: cada uno hace su tarea en su worktree, con sus tests en verde. El proyecto es una tienda con una función de precio y un test:

// precio.mjs
export function precioFinal(precio) {
  return precio;
}
// precio.test.mjs
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { precioFinal } from './precio.mjs';

test('sin descuentos, el precio no cambia', () => {
  assert.equal(precioFinal(100), 100);
});

El agente del IVA, en tienda-iva, añade el 21 % (return Math.round(precio * 1.21);) y cambia el test a 121. El agente del cupón, en tienda-cupon, añade un descuento de 10 € (return cupon === 'VERANO' ? precio - 10 : precio;) y un test nuevo que espera 90. Cada uno pasa sus tests y hace commit en su rama. Hasta aquí, todo en verde.

Al integrar, desde la carpeta principal (~/tienda, en main), la primera rama entra sin problema. La segunda choca:

git merge agente/iva
git merge agente/cupon
Auto-merging precio.mjs
CONFLICT (content): Merge conflict in precio.mjs
Auto-merging precio.test.mjs
Automatic merge failed; fix conflicts and then commit the result.

El conflicto en precio.mjs es lo esperado: los dos cambiaron la misma función. La clave está en la línea que no avisa de nada: Git fusiona precio.test.mjs sin conflicto, porque cada agente tocó una parte distinta del fichero. El resultado tiene los dos tests:

test('añade el 21 % de IVA', () => {
  assert.equal(precioFinal(100), 121);
});

test('el cupón VERANO descuenta 10 €', () => {
  assert.equal(
    precioFinal(100, 'VERANO'), 90);
});

Quien integra junta las dos ideas en la función, aplicando el cupón y después el IVA:

const aCentimos = (n) => Math.round(n * 100) / 100;

export function precioFinal(precio, cupon) {
  const base = cupon === 'VERANO'
    ? precio - 10
    : precio;
  return aCentimos(base * 1.21);
}

Y los tests, que Git había fusionado sin protestar, fallan:

node --test
✖ el cupón VERANO descuenta 10 €
  AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:

  108.9 !== 90

Ninguno de los dos agentes se equivocó. El test del cupón se escribió en un mundo sin IVA, y en el mundo integrado ya no es cierto. Martin Fowler, en su artículo sobre integración continua, llama a esto un conflicto semántico: los conflictos de texto se detectan con facilidad; los semánticos no, y por eso, dice, es tan importante tener código que se prueba solo. Aun así, avisa, un test en rojo solo dice que hay un conflicto entre cambios: qué es y cómo resolverlo hay que averiguarlo. ¿El cupón se descuenta antes o después del IVA? Antes, el cliente paga (100 − 10) × 1,21 = 108,90 €. Después, 121 − 10 = 111 €. Eso no lo decide Git ni ninguno de los agentes por separado: es una regla de negocio, y la decide una persona. Aquí, que el cupón va antes del IVA:

test('el cupón VERANO descuenta 10 € antes del IVA', () => {
  assert.equal(
    precioFinal(100, 'VERANO'), 108.9);
});
ℹ pass 2
ℹ fail 0

Con todo integrado, se borran los worktrees y sus ramas:

git worktree remove ../tienda-iva
git worktree remove ../tienda-cupon
git branch -d agente/iva agente/cupon

El cuello de botella se mueve a la integración

Esta sección es interpretación nuestra, salvo donde se cita una fuente.

La prueba es pequeña, pero muestra el patrón. Los worktrees aíslan la escritura: dos agentes no pueden pisarse los ficheros. No aíslan las decisiones: dos cambios correctos por separado pueden ser incoherentes juntos, y Git solo avisa cuando chocan las líneas, no cuando chocan las ideas.

Los propios anuncios lo dejan ver. Cognition cuenta que su bot de Android fusionó 1.134 pull requests en 44 días con 183 mensajes del ingeniero que lo dirigía, y que fusionaba las que pasaban la integración continua y Devin Review, su propia revisión de código con IA; la mayoría de esos mensajes trataban de algo que necesitaba una decisión humana, como una pull request que pedía una revisión de seguridad. Es decir: el sistema funciona porque hay una puerta automática y una persona para lo que la puerta no sabe decidir.

Lo que se deduce para trabajar en paralelo:

  1. Una tarea, un worktree, una rama, un agente. Y tareas pequeñas: cuanto más grande el cambio, más probable el choque al integrar y más difícil de revisar.
  2. Tests en verde antes de integrar, y otra vez después. Los tests de cada rama dicen que cada cambio funciona solo. Los tests después de integrar dicen que funcionan juntos. La prueba de arriba falla justo en ese segundo momento.
  3. Limita el trabajo en curso. Es la idea del límite de trabajo en curso de Kanban, que la Guía de Kanban define como lo empezado y no terminado: tres tareas terminadas valen más que diez a medias. Si los agentes terminan más rápido de lo que se integra, lo que se acumula son ramas pendientes de revisar.
  4. Integra pronto y a menudo. Cuanto más tiempo vive una rama aparte, más se separa del resto. Es la vieja lección de la integración continua, que con agentes llega antes.
  5. Separa las tareas que tocan lo mismo. Si dos tareas cambian la misma regla de negocio, como aquí el precio, no son paralelas: una depende de la otra.

Si los agentes producen más de lo que el equipo entiende, aparece otro problema que no se ve en los tests: la deuda cognitiva. Y el conjunto de tests, CI y revisión que hace falta para sostener todo esto es lo que se llama el arnés del agente.

Errores frecuentes con git worktree

  • La misma rama en dos worktrees. Git lo impide (salvo con --force, que no conviene):

    fatal: 'fix/login' is already used by worktree at '~/login'
  • Borrar la carpeta a mano. Git sigue apuntándola como prunable hasta que ejecutas git worktree prune.

  • Olvidar que el worktree empieza limpio. No están .env, node_modules ni la base de datos local: hay que instalarlos o copiarlos.

  • Dos agentes con los mismos recursos. Si los dos levantan el servidor en el mismo puerto o usan la misma base de datos local, se pisan aunque tengan carpetas distintas.

  • Integrar sin volver a pasar los tests. Es el error de la prueba de arriba.

Qué ofrecen las herramientas (noviembre de 2026)

Cada herramienta lo resuelve a su manera. Esto es lo que dicen sus fuentes oficiales, con fecha, porque cambia cada pocas semanas:

Herramienta Qué ofrece
Claude Code claude --worktree, worktrees por subagente y bloqueo de ediciones en la carpeta principal
Devin Bots, de Cognition (17 de noviembre) Agentes persistentes que dirigen varias sesiones de Devin en paralelo
Replit Missions (17 de noviembre) Varios agentes hacia un objetivo, con criterios de éxito, presupuesto y aprobaciones
OpenCode 2.3.0 (13 de noviembre) Subagentes en segundo plano por defecto, que avisan al terminar
VS Code 1.146 (16 de noviembre) Bandeja de sesiones de agentes de todos los espacios de trabajo, experimental

Límites

  • La prueba es pequeña y simula a los agentes. Los cambios los escribe un guion, no un agente real, para que el resultado sea reproducible. Lo que muestra, que Git fusiona tests incoherentes sin avisar, no depende de quién los escriba.
  • La cifra de Cognition es suya. El ejemplo del bot de Android sale de su anuncio, sin una evaluación independiente, y 1.134 pull requests miden volumen, no resultado; lo de Replit describe funciones, no resultados.
  • Más agentes, más consumo. La propia documentación de Claude Code avisa de que varias sesiones o subagentes a la vez multiplican el uso de tokens.
  • El cálculo está simplificado. Usa decimales en coma flotante; una tienda real trabaja en céntimos enteros, y cómo redondear también es una regla de negocio.
  • No todo se puede paralelizar. Tareas que dependen entre sí, o que tocan el mismo módulo, se integran peor cuanto más se paralelizan.

Tu siguiente paso

Antes de lanzar varios agentes a la vez, elige dos tareas que no toquen los mismos ficheros ni las mismas reglas de negocio. Crea un worktree para cada una, deja que cada agente trabaje con sus tests y, al integrar, pasa todos los tests otra vez, no solo los de cada rama. Si falla algo que en cada rama estaba en verde, ya sabes dónde está el trabajo que no se puede delegar.

Si decides cómo trabaja tu equipo, mide lo que cuesta integrar, no lo que tardan los agentes: cuántas ramas esperan revisión (tu trabajo en curso) y cuántas horas pasan desde que un agente termina hasta que su cambio entra en main. Las métricas DORA dan el marco para medirlo. Si ese número crece, añadir agentes no acelera nada.

Tu chuleta

Quiero… Orden
Un worktree con rama nueva git worktree add -b rama ../carpeta
Un worktree con una rama que existe git worktree add ../carpeta rama
Ver los worktrees git worktree list
Borrar uno git worktree remove ../carpeta
Limpiar los borrados a mano git worktree prune
Claude Code en un worktree claude --worktree nombre

Fuentes

Consultadas el 20 y el 21 de noviembre de 2026.

Código: ejecutado el 21 de noviembre de 2026 con Git 2.53.0 (en inglés) y Node.js 24.21.0 (node --test), en repositorios de prueba. Las rutas de las salidas se han acortado a ~/ y algunas salidas están recortadas. Los comandos se han comprobado también en la documentación de Git 2.56.