Cómo orquestar varios agentes IA con gobernanza
Los equipos que ya aplican un perímetro de archivos y una revisión antes de fusionar siguen viendo conflictos, porque el fallo empieza antes: un brief sin dividir, no los agentes en paralelo en sí. La cadena que realmente evita los conflictos, el trabajo duplicado, y las fusiones sin revisar va del brief a los tickets, de los tickets a agentes en paralelo con perímetro de archivos reservado, de los agentes a la revisión por otra persona, y de la revisión a la integración que repite los propios controles del proyecto, sin importar qué cliente MCP ejecute cada agente.
El fallo empieza antes de que se ejecute el primer agente
Un CTO que dice que ejecutar agentes en paralelo crea conflictos, duplicados, y entregas sin revisar normalmente ya ha resuelto la mitad del problema: un worktree y una rama dedicados por agente, un perímetro de archivos reservado por ticket, y revisión antes de fusionar, las cinco prácticas que una guía relacionada de este blog ya cubre, ilustradas allí con Claude Code pero sin limitarse a él. Lo que rompe la cadena antes de que nada de eso se aplique ocurre antes: un brief que nunca llegó a convertirse en un conjunto de tickets distintos y delimitados desde el principio, y un paso de revisión e integración que tiene que sostenerse sin importar qué cliente ejecutó qué agente.
Nada de lo que sigue repite las prácticas de worktree, perímetro, o revisión antes de fusionar ya documentadas; cubre las dos partes de la cadena que se sitúan a ambos lados, convertir un brief en tickets antes de que empiece el trabajo en paralelo, y coordinar la revisión y la integración una vez que llegan varias entregas al mismo tiempo, construido alrededor de la arquitectura neutral respecto al host propia del Model Context Protocol en lugar de alrededor de un cliente específico.
Tratar las cinco prácticas y esta cadena como la misma cosa es el error que lleva a un equipo a adoptar el perímetro de archivos y la revisión, seguir viendo conflictos, y concluir que las prácticas no funcionan; las prácticas resuelven lo que ocurre una vez que los tickets existen, y un equipo que pasa directamente a agentes en paralelo desde un brief sin dividir sigue expuesto al modo de fallo que esas cinco prácticas nunca estuvieron pensadas para interceptar.
La arquitectura de MCP es neutral respecto al host, por eso la cadena funciona con cualquier cliente
La propia visión general de la arquitectura del protocolo, versión 2026-07-28, describe MCP como un modelo cliente-servidor donde un host MCP, «una aplicación de IA como Claude Code o Claude Desktop», crea un cliente MCP por cada servidor al que se conecta, y cada cliente mantiene una conexión dedicada a su servidor. La documentación da un segundo host, distinto, como su propio ejemplo: cuando Visual Studio Code se conecta al servidor MCP de Sentry y luego a un servidor de sistema de archivos local, el runtime de Visual Studio Code instancia un objeto cliente separado para cada uno.
Ese diseño explica por qué una cadena de gobernanza construida sobre tickets, perímetro, y revisión no tiene que reescribirse para cada cliente: el host cambia, Claude Code, Claude Desktop, VS Code, o cualquier otra aplicación que implemente el protocolo, pero el modelo de conexión cliente-servidor, y las herramientas, recursos, y prompts que expone un servidor, siguen siendo los mismos por debajo. Un ticket que nombra un perímetro de archivos y un criterio de aceptación restringe al agente sin importar qué host lo esté ejecutando ese día.
La misma visión general especifica dos mecanismos de transporte bajo ese modelo cliente-servidor, un transporte stdio para un servidor local que habla con un solo cliente en la misma máquina, y un transporte Streamable HTTP para un servidor remoto que atiende a muchos clientes a la vez, cada uno con el mismo formato de mensaje JSON-RPC sin importar qué transporte u host esté al otro lado.
Del brief a los tickets: qué hay que decidir antes de que empiece el trabajo en paralelo
Un brief, escrito para una persona, normalmente agrupa varios cambios que tocan distintas partes de una base de código o de un conjunto de datos bajo una sola descripción. Dividirlo en tickets que un conjunto de agentes pueda ejecutar en paralelo significa decidir, antes de que arranque ningún agente, qué partes de ese brief se pueden trabajar sin tocar los mismos archivos, cuáles dependen de que otro ticket termine primero, y cuál debería en cambio quedarse como un único ticket que absorba un cambio demasiado entrelazado para dividirlo con seguridad.
Cada ticket resultante sigue necesitando las dos cosas que un modelo de gobernanza basado en tickets ya exige: un perímetro de archivos reservado antes de lanzar el agente, para que dos tickets en curso no puedan reclamar los mismos archivos, y criterios de aceptación escritos de antemano, para que el agente tenga un objetivo verificable y el revisor tenga una prueba objetiva en lugar del propio resumen del agente sobre lo que hizo. Equivocarse en esta división, perímetros que se solapan, o criterios de aceptación copiados literalmente del brief original sin hacerlos específicos para cada ticket, es lo que produce el trabajo duplicado y los conflictos de fusión que un CTO ve más adelante, incluso cuando se sigue correctamente el resto de la cadena.
Un brief que agrupa una migración de base de datos con un cambio de interfaz sin relación es el caso más claro para dividir antes de asignar agentes, ya que ambos tocan archivos disjuntos y conllevan un riesgo independiente; un brief que cambia la firma de una función y todos los archivos que la llaman es el caso más claro para mantener como un único ticket, ya que dividirlo supondría dar a dos agentes un perímetro solapado sobre el mismo cambio.
La cadena, etapa por etapa
La tabla siguiente nombra el control en cada etapa de la cadena, del brief a la integración, y dónde ese control ya aparece con más detalle en otra parte de este blog en lugar de repetirlo aquí.
| Etapa | Qué tiene que pasar | Dónde está cubierto |
|---|---|---|
| Del brief a los tickets | División en perímetros de archivos sin solapar, cada uno con sus propios criterios de aceptación | Este artículo |
| Del ticket al agente en paralelo | Worktree y rama por agente, perímetro aplicado antes del lanzamiento | Guía de agentes Claude Code en paralelo |
| Del agente a la entrega | La lista de herramientas y las acciones disponibles pueden cambiar a mitad de ejecución; los agentes se resincronizan mediante notificaciones MCP | Visión general de la arquitectura MCP |
| De la entrega a la revisión | Revisado por alguien distinto del solicitante, sobre el diff real | Guía de gobernanza de agentes IA |
| De la revisión a la integración | Los propios controles del proyecto se repiten al fusionar, no se asumen solo por la revisión | Guía de gobernanza de agentes IA |
Hacer funcionar agentes en paralelo sin perder el hilo
Una vez que varios agentes se ejecutan contra sus propios perímetros reservados, el problema de coordinación pasa de los conflictos de archivos a mantenerse sincronizado sobre lo que cada agente tiene realmente permitido hacer. El propio sistema de notificaciones de MCP existe exactamente para esto: un servidor puede indicar a los clientes conectados cuándo cambian sus herramientas disponibles, por ejemplo cuando se añade, modifica, o desactiva temporalmente una herramienta, y un cliente suscrito a esa notificación actualiza su lista de herramientas en lugar de seguir trabajando con una lista desactualizada.
Para un equipo que ejecuta varios agentes contra los mismos servidores MCP, eso significa que un cambio de perímetro o de permiso hecho a mitad de ejecución, una herramienta recién bloqueada por un administrador, un servidor puesto fuera de línea para mantenimiento, se propaga a cada agente conectado a través del propio protocolo, en lugar de depender de reiniciar cada agente para que recoja el cambio.
Este es un mecanismo de suscripción voluntaria, no algo que un cliente obtiene automáticamente: la propia documentación del protocolo señala que las notificaciones de cambio solo se envían a los clientes que se suscribieron a ellas, y que el polling sigue teniendo un papel porque la entrega es «best-effort» en lugar de garantizada, en particular tras una reconexión.
La revisión debe ocurrir una vez, por alguien que no hizo el trabajo
Ejecutar cinco tickets en paralelo no significa inventar cinco estándares de revisión distintos; significa aplicar la misma regla, la persona que pidió el trabajo no es la que lo aprueba, a cada entrega que llega, ya sea que lleguen una por una o todas la misma tarde. La propia documentación de GitHub sobre su agente de código Copilot establece la misma restricción para un flujo de trabajo comparable: una aprobación de la persona que asignó el trabajo no cuenta entre las revisiones requeridas de un repositorio.
Lo que cambia bajo carga en paralelo no es el estándar, es el volumen que un revisor tiene que absorber a la vez, que es la razón por la que la misma guía de prácticas ya limita las sesiones simultáneas a lo que la revisión puede realmente seguir, en lugar de tratar la capacidad de revisión como ilimitada solo porque los propios agentes puedan ejecutarse en paralelo.
Un límite en las sesiones simultáneas, ya recomendado en otra parte de este blog en tres a cinco, es la forma práctica que esto adopta: no es un límite sobre cuántos agentes puede ejecutar una herramienta, es un límite ajustado a cuántas entregas puede un revisor, o una rotación de revisión, leer realmente el diff antes de aprobar.
La integración repite los controles, no confía solo en la revisión
Un diff que pasó la revisión igualmente se fusiona en un historial compartido del que depende cada otro ticket en curso, razón por la cual el modelo de gobernanza que este blog ya ha documentado repite los propios controles del proyecto en el momento de la integración, en lugar de depender solo de la revisión que lo precedió. Bajo trabajo en paralelo, ese paso importa más, no menos: dos tickets revisados y aprobados pueden igualmente entrar en conflicto entre sí de formas que ninguno de los dos revisores vio por separado, y la integración es el momento en que ese conflicto realmente sale a la superficie.
Tratar la integración como un segundo control independiente en lugar de como una formalidad tras la revisión es lo que evita que un conflicto de fusión se convierta en un incidente de producción descubierto después de los hechos en lugar de una fusión bloqueada interceptada antes.
Nada de esto requiere una herramienta distinta para el trabajo en paralelo frente al trabajo secuencial; el mismo paso de repetir los controles al integrar se aplica a un único ticket que se fusiona solo, simplemente tiene más ocasiones de detectar algo cuando varios tickets llegan cerca en el tiempo.
Construir la cadena dentro de un equipo
Las prácticas de worktree, rama, y perímetro de archivos que hacen funcionar la etapa de agentes en paralelo de esta cadena, límite incluido, se cubren por completo en atipol.ai/agentic-ai-blog/parallel-claude-code-agents. Cómo se rastrea el coste de ejecutar varios agentes en paralelo por ticket en lugar de por mes se cubre en atipol.ai/agentic-ai-blog/ai-agent-costs, y el recorrido guiado que muestra un ticket pasar del brief al trabajo en paralelo a la revisión y a la integración de principio a fin está en atipol.ai/tour.
Preguntas frecuentes
¿Funciona una cadena de orquestación multi-agente gobernada con clientes de IA distintos de Claude Code?
Sí. La propia arquitectura del Model Context Protocol es neutral respecto al host: su documentación describe Claude Code, Claude Desktop, y Visual Studio Code como ejemplos de hosts que cada uno crea su propio cliente MCP por servidor, con el mismo modelo de conexión cliente-servidor por debajo. Una cadena construida sobre tickets, perímetro de archivos, y revisión restringe al agente sin importar qué host lo esté ejecutando.
¿Qué hay que decidir antes de dividir un brief en tickets para agentes en paralelo?
Qué partes del brief tocan archivos distintos y pueden ejecutarse sin solaparse, cuáles dependen de que otro ticket termine primero, y cuáles están demasiado entrelazadas para dividirlas con seguridad y deberían seguir siendo un único ticket. Cada ticket resultante sigue necesitando su propio perímetro de archivos reservado y criterios de aceptación escritos antes de lanzar el agente.
¿Por qué repetir los controles en la integración si una entrega ya fue revisada?
Porque una revisión cubre un diff de forma aislada, mientras que la integración es donde ese diff se encuentra con cualquier otro cambio fusionado desde que empezó la revisión. Dos tickets revisados y aprobados por separado pueden igualmente entrar en conflicto entre sí de formas que ningún revisor vio, razón por la cual repetir los propios controles del proyecto en el momento de fusionar detecta lo que la revisión por sí sola no puede.
Fuentes
- Model Context Protocol, visión general de la arquitectura (versión del protocolo 2026-07-28), consultado el 11/11/2026
- GitHub Docs, Revisar una pull request creada por Copilot, consultado el 11/11/2026
- NIST, AI Risk Management Framework (AI RMF 1.0), publicado el 26/01/2023
La demo pública muestra una organización ficticia en funcionamiento, sin cuenta. El plan gratuito incluye un proyecto, tres agentes y un agent lead.
