# Revisiones multiagente

> Cómo revisa AI CodeOps un cambio con varios agentes: los pasos de revisión, una pasada de hallazgos sobre el diff real, la gravedad y el triaje, y la aprobación humana que viene después.

Fuente: https://aicodeops.dev/es/docs/multi-agent-reviews · Última actualización: 2026-10-18

En AI CodeOps, el agente que escribe un cambio no es el que lo comprueba. Los pasos de revisión del flujo de trabajo miran el trabajo desde distintos ángulos. Después, una pasada de hallazgos revisa el diff real y registra hallazgos estructurados. Una persona toma la decisión final.

## Pasos de revisión en el flujo de trabajo

La mayoría de los [flujos de trabajo](https://aicodeops.dev/es/docs/workflows) incluyen uno o más pasos de revisión, cada uno ejecutado por su propio agente:

- **Plan, Build, Review & Test** tiene un paso Review a cargo del [Reviewer](https://aicodeops.dev/es/agents/reviewer).
- **Security-Sensitive Change** tiene un paso Risk analysis antes del cambio y un Audit diff después, ambos a cargo del [Security Auditor](https://aicodeops.dev/es/agents/security-auditor).
- **Parallel Review** tiene tres revisiones (corrección a cargo del Reviewer, seguridad a cargo del Security Auditor y cobertura de pruebas a cargo del [Tester](https://aicodeops.dev/es/agents/tester)), y después un paso Merge findings que las combina.
- **Release Readiness** añade una comprobación E2E sanity y una auditoría de dependencias, y después un paso Go / no-go.
- **Architecture Debate** hace que dos arquitectos propongan cada uno un enfoque, que un crítico los revise y que haya una síntesis final.

Los pasos se ejecutan uno tras otro. Cada uno ve lo que escribieron los pasos anteriores, de modo que un paso de fusión o de síntesis trabaja a partir de todas las revisiones que lo preceden. Nada se decide por votación.

### Cuándo se ejecuta un paso de revisión

Un paso que comprueba el trabajo solo puede comprobar trabajo que existe. Por eso una sesión se ejecuta en este orden:

1. Los pasos hasta el que implementa el cambio se ejecutan primero. En Plan, Build, Review & Test son Plan y Build; en Security-Sensitive Change son Scope change, Risk analysis e Implement.
2. Se escribe el cambio, y las pruebas de tu proyecto se ejecutan sobre él.
3. Se ejecutan los pasos posteriores al paso de implementación: Review y Test, o Audit diff y Validate. A cada uno se le muestra el cambio tal como se escribió (el diff, recortado para que quepa y con el corte marcado cuando es largo) y el resultado de pruebas registrado, y se le indica que cite los archivos que leyó.

Si uno de esos pasos posteriores falla o se queda sin tiempo, la sesión conserva su cambio y el paso se marca como fallido en la página de la sesión.

Un flujo de trabajo sin paso de implementación, como Parallel Review, Swarm Inspection o Release Readiness, ejecuta todos sus pasos antes de que se escriba ningún código. Sus revisiones son del código que ya está en tu repositorio. Architecture Debate escribe documentos y nada de código.

## La pasada de hallazgos

Los pasos de revisión escriben notas en texto. Por eso, después de que el cambio se haya escrito y probado y esos pasos se hayan ejecutado, AI CodeOps ejecuta una revisión aparte del propio diff, que registra los hallazgos que condicionan el paso del cambio por el control. Recibe:

- el diff, como lo que hay que revisar;
- las notas de todos los pasos cuyo nombre menciona review, security, audit, risk o test, como contexto;
- en una sesión de seguimiento, lo que plantearon las rondas anteriores y lo que decidió una persona sobre cada punto.

A la revisión se le indica que un hallazgo de gravedad high o critical tiene que señalar la entrada concreta que lo desencadena y qué sale mal, y que un hallazgo que no pueda respaldar de ese modo es medium como máximo.

Registra hasta 12 problemas concretos como hallazgos. Se atribuyen al Security Auditor si ese agente se ejecutó en la sesión; si no, al Reviewer; si no, al último agente que se ejecutó.

Cada hallazgo tiene un título, una descripción, una recomendación y, normalmente, un archivo.

### Gravedad

| Gravedad | ¿Bloquea el cambio mientras no se resuelva? |
| -------- | ------------------------------------------- |
| critical | Sí                                          |
| high     | Sí                                          |
| medium   | No                                          |
| low      | No                                          |
| info     | No                                          |

### Categoría

Seguridad, calidad, rendimiento, accesibilidad, cumplimiento, dependencias, documentación, cobertura de pruebas, fiabilidad, costo, UX u otra.

### Cuando la revisión no puede terminar

La pasada de hallazgos tiene dos minutos. Una respuesta que no se puede leer como hallazgos se pide una vez más, y una respuesta cortada a medias conserva los hallazgos que terminó. Si el modelo falla o se queda sin tiempo, si el presupuesto se agota antes o si la respuesta sigue sin poder leerse, la revisión cuenta como no completada. El cambio queda entonces retenido, y la página de la sesión dice cuál de esas cosas ocurrió y qué hacer: volver a ejecutar la sesión, o subir antes el presupuesto. Una lista vacía, en cambio, es una revisión completada en la que no se encontró nada.

## Triaje de hallazgos

Abre la página de una sesión y busca la lista **Findings**. Fija el estado de cada hallazgo desde su desplegable:

| Estado                                      | ¿Sigue bloqueando (si es high o critical)? |
| ------------------------------------------- | ------------------------------------------ |
| open, acknowledged, in progress             | Sí                                         |
| fixed, won't fix, false positive, duplicate | No                                         |

Elige **Fix** en un hallazgo para lanzar una sesión que lo corrija. A esa sesión se le pide que incluya una prueba que reproduzca el hallazgo. Los hallazgos de todo el espacio de trabajo están en **Build & Test → Quality**. Cambiar un estado requiere un rol con permiso de triaje; el rol Viewer no lo tiene. Consulta [Controles de calidad](https://aicodeops.dev/es/docs/quality-gates).

## La revisión humana

Cuando la pasada de hallazgos ha terminado y la sesión produjo un diff, AI CodeOps abre una solicitud de revisión en **Review & Gate → Approvals**. Una persona lee el diff y los hallazgos, y después aprueba o rechaza.

- La persona que lanzó la sesión no puede aprobarla mientras otra persona del espacio de trabajo pueda hacerlo. Un espacio de trabajo de una sola persona puede aprobar su propio cambio.
- Un rechazo pone fin a la solicitud.
- Editar el cambio después de la aprobación lo devuelve a la espera de aprobación.

La aprobación abre el pull request, si el control de calidad también se supera. Consulta [Aprobaciones y políticas](https://aicodeops.dev/es/docs/approvals-and-policies).

## Siguientes pasos

- [Controles de calidad](https://aicodeops.dev/es/docs/quality-gates)
- [Cómo funciona AI CodeOps](https://aicodeops.dev/es/docs/how-it-works)
- [Revisión de código con IA](https://aicodeops.dev/es/product/review)

## Preguntas frecuentes

### ¿La revisión mira el código o el plan?

El código. Un paso de revisión que sigue al paso que implementa el cambio se ejecuta después de que el código esté escrito, y se le muestra el diff y el resultado de las pruebas. Después, la pasada de hallazgos lee el mismo diff, con las notas de los pasos de revisión como contexto.

### ¿Los agentes que revisan votan?

No. Cada paso de revisión escribe su análisis por turno, y un paso final o la pasada de hallazgos los lee todos. No hay votación ni recuento de consenso.

### ¿Qué pasa si la revisión con IA falla?

El cambio queda retenido. Sus hallazgos se desconocen, así que no puede abrir un pull request hasta que vuelvas a ejecutar la sesión.
