> ## Content Index
> Fetch the complete content index at: https://cesarbeassuarez.dev/llms.txt
> Use this file to discover other available public pages before exploring further.

# Siete agentes en paralelo, un merge por vez
- URL: https://cesarbeassuarez.dev/siete-agentes-un-merge/
- Published: 2026-10-29T01:59:21.000Z
- Updated: 2026-10-29T01:59:21.000Z
- Description: Siete agentes escriben a la vez. Después los integro de a uno. El cuello se me mudó.
- Author: César Beas Suárez
- Tags: QA Estratégico, IA aplicada al testing

Tengo siete agentes trabajando al mismo tiempo sobre el mismo repo de tests. La pregunta obvia es cómo no se pisan, y la respuesta es aburrida: **ninguno trabaja sobre la misma carpeta.**

Lo interesante no es eso. Es que el paralelismo termina exactamente donde empiezo yo: los siete escriben a la vez, y después los integro de a uno. Siete carriles que desembocan en uno.

---

## Una carpeta por agente, un solo repo

Cada agente tiene su propia carpeta de trabajo y su propia rama, las dos creadas desde la rama de integración. No son copias del repo: es la misma historia de git vista desde siete lugares distintos. Un repositorio, siete árboles de trabajo.

![Un repositorio con una sola historia de git y siete carpetas de trabajo colgando. Cada una tiene sus archivos y su rama; comparten el APK, la memoria y el turno de los dos devices.](https://cesarbeassuarez.dev/content/images/2026/10/diagrama-aislar-y-compartir.png)

Aislar lo que se edita, compartir lo que se consulta.

Eso resuelve el único problema que realmente importa cuando hay varios agentes: que dos editen el mismo archivo al mismo tiempo. Pueden tocar el mismo archivo —pasa seguido— pero no en el mismo momento ni sobre la misma copia. Cada uno salió del último estado de la rama de integración y avanza solo.

No todo conviene separarlo. El APK que se instala en el celular y la memoria del agente están enlazados al principal: si cada carpeta tuviera su copia, actualizar la app sería actualizarla siete veces, y lo que un agente aprendió no serviría para el siguiente.

La regla que me quedó: **aislar lo que se edita, compartir lo que se consulta.**

---

## Los devices son dos, no siete

Esto no se arregla con carpetas. Hay un celular físico y un emulador Android, y siete agentes que quieren correr tests.

Lo ordena un lock: el que quiere un device lo toma, los demás esperan. Vive en el repositorio común, así que lo ven los siete sin que yo tenga que coordinar nada.

En la práctica son dos agentes corriendo y cinco escribiendo o arreglando tests. El paralelismo real no es de siete contra la app: es de siete escribiendo y dos probando.

Y si el emulador se cuelga —pasa, la notebook da lo que da— hay un mecanismo que lo recupera sin que yo intervenga, que es [algo que automaticé antes por la misma razón](https://cesarbeassuarez.dev/de-8-tests-por-dia-a-150/). Con eso, dos devices alcanzan. No es ahí donde está el límite.

---

## Pueden leer el producto, no pueden tocarlo

Los agentes necesitan ver el código del front y de la API para entender qué hace la app de verdad, no lo que yo recuerdo que hace. Así que tienen acceso de lectura a un clon de cada uno, apartado y dedicado a eso.

Leer, sí. Escribir, no: un script corre antes de cada comando de terminal y bloquea cualquier `commit` o `push` sobre esos repos. Todo lo demás pasa sin preguntar nada. Es invisible hasta que alguien intenta algo que no corresponde.

Y hay un segundo control que resultó más útil de lo que esperaba: al abrir cada sesión, un chequeo avisa si esos clones están desactualizados —rama equivocada, atrasados respecto del remoto, hace días que no se traen cambios—. Sin eso, el agente arma tests según cómo era la app hace dos semanas, y lo hace con total seguridad. Un agente desactualizado no duda: afirma.

---

## Lo que probé y saqué

Antes de llegar a esos dos controles probé versiones más estrictas, y las tuve que revertir.

Puse reglas que pedían aprobación para escribir en las bases locales de prueba. Terminé aprobando cosas cada dos minutos mientras preparaba el entorno, que es justo el momento en que uno quiere que la herramienta se haga a un lado.

Puse hooks en el repo del front para frenar los commits desde ahí. Funcionaban demasiado bien: bloqueaban a cualquiera, incluso a una sesión donde yo sí quería autorizar un commit.

\_Error: construí controles que frenaban bien y molestaban más. Los usé unos días y los saqué a todos juntos.

\_Aprendizaje: un control que pide permiso todo el tiempo se termina desactivando. El que sobrevivió es el que no se nota hasta que hace falta.

---

## Dónde termina el paralelismo

Los siete terminan su tarjeta. Y después empieza la parte que no se paraleliza.

Traigo un agente por vez a la rama de integración. Los conflictos no los resuelvo a mano: los resuelve un agente, que para eso tiene las dos versiones y el contexto de las dos tarjetas. Lo que hago yo es decidir el orden, mirar lo que quedó, y decir si la resolución es correcta. Después actualizo a los siete con lo integrado.

Porque eso es lo que hace separar las carpetas: no elimina que dos agentes toquen el mismo archivo, hace que se encuentren después, en un momento donde hay alguien decidiendo. Un conflicto que aparece en el merge se resuelve con las dos versiones a la vista. Uno que no aparece nunca es un archivo donde el último que escribió ganó sin que nadie se entere.

Resolver el merge se delega. Decidir si está bien resuelto, no.

---

## El techo no es el merge

Podría poner catorce agentes y avanzaría más. Ése no es el problema.

El problema está después. Cuando los tests corren, alguien tiene que mirar el reporte de Allure del pipeline —el de CI, el que ve todo el equipo— y reproducir a mano varios de esos casos. Comprobar que la cobertura que ahí figura es la cobertura real, que los casos elegidos son los que correspondía elegir, y que está ordenado de manera que alguien que entra lo entienda.

Eso lo hago yo, y lleva tiempo que muchas veces no tengo porque estoy en otra cosa. Todavía estoy revisando a mano tests que ya están escritos hace rato.

Así que el techo no es cuántos tests puedo generar. Es cuántos puedo revisar.

Y sé por qué esa parte no se delega todavía: el criterio con el que reviso —qué cobertura está bien expuesta, qué caso sobra, cómo tiene que estar ordenado para que el equipo lo lea— no está escrito en las instrucciones que les paso a los agentes. Está en mi cabeza. Mientras siga ahí, el que mira soy yo.

Hay además un costo que no aparece en ningún gráfico de productividad: todos esos agentes consumen del mismo límite de uso que tengo por día y por semana. Gastarlo generando tests que después no voy a llegar a revisar es quedarme sin IA para cualquier otra cosa que me aparezca esa tarde.

---

## Lo que esto no resuelve

- Poner más agentes no mueve el techo. Lo mueve escribir el criterio de revisión, y todavía no lo escribí.
- La integración es serial. Resolver los conflictos se delega, pero el orden y la revisión no.
- Que los agentes lean el código del producto los hace más precisos, no infalibles. Leer el front no es leer la regla de negocio: la regla puede estar mal implementada, y entonces el test retrata el defecto.

---

## Lo que aprendí

Pensaba que el problema de correr varios agentes iba a ser de instrucciones —cómo decirles qué hacer sin que se superpongan—. No. Fue de carpetas y de turnos: dónde escribe cada uno, qué recurso es único, y quién integra.

Nada de eso es de IA. Es lo que hace cualquier equipo con varias personas tocando el mismo repo. La diferencia es la velocidad: lo que un equipo descubre en una semana, siete agentes te lo muestran en una tarde.

Y lo otro: cada vez que automaticé una parte de este trabajo, el límite se corrió un paso más abajo. Primero era escribir, después integrar, ahora revisar. Cada paso que delego empuja el cuello de botella hacia lo que todavía no supe poner por escrito.

---

## Próximo paso

Escribir el criterio con el que reviso el reporte, para que deje de ser mío y pase a ser una regla más. Es la única parte del trabajo que por ahora no sé cómo bajar a texto.