# Agentes y flujos de trabajo

> Los agentes de IA que intervienen en una sesión de AI CodeOps y los 16 flujos de trabajo integrados que los ordenan, desde Plan, Build, Review & Test hasta Incident Response.

Fuente: https://aicodeops.dev/es/docs/agents

Una sesión no es un modelo de IA respondiendo a un prompt. Es un **flujo de trabajo**: una secuencia fija de pasos, cada uno ejecutado por un **agente** con su propio rol y sus propias instrucciones. Planificar, desarrollar, revisar y probar lo hacen agentes distintos, de modo que el trabajo lo comprueba algo distinto de lo que lo escribió.

## Los agentes integrados

| Agente             | Rol                                                    |
| ------------------ | ------------------------------------------------------ |
| Architect          | Planes, riesgos, ejecución por etapas.                 |
| Builder            | Implementa los cambios aprobados.                      |
| Reviewer           | Revisión de corrección y mantenibilidad.               |
| Tester             | Pruebas, comprobación de tipos y controles de calidad. |
| Security Auditor   | Riesgos de seguridad, secretos, CVE.                   |
| UI Designer        | Planificación visual y de UX.                          |
| DevOps Engineer    | CI/CD, infraestructura, pipelines.                     |
| Product Analyst    | Requisitos y criterios de aceptación.                  |
| Project Planner    | Planes de entrega por fases.                           |
| Researcher         | Antecedentes y estudio de la base de código.           |
| Backend Engineer   | Implementación del lado del servidor.                  |
| Frontend Engineer  | Implementación del lado del cliente.                   |
| E2E Tester         | Cobertura de pruebas de extremo a extremo.             |
| Dependency Auditor | Auditoría de la cadena de suministro.                  |
| Database Engineer  | Diseño de esquemas y migraciones.                      |
| Incident Responder | Triaje de incidentes.                                  |
| Site Reliability   | SLO, runbooks, postmortems.                            |
| ADR Writer         | Registros de decisiones de arquitectura.               |

Algunos flujos de trabajo usan también un Technical Writer, un Migration Specialist y un Performance Tester. Hay más información sobre cada agente en la [página de agentes](https://aicodeops.dev/es/agents).

## Los flujos de trabajo integrados

Elige un flujo de trabajo en la lista **Workflow** cuando [lances una sesión](https://aicodeops.dev/es/docs/sessions). **Develop → Workflows** muestra el catálogo completo.

| Flujo de trabajo                             | Pasos                                                                                                                |
| -------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| **Plan, Build, Review & Test** (por defecto) | Plan → Build → Review → Test                                                                                         |
| **Quality-Gated Change**                     | Build → Test → Review                                                                                                |
| **Security-Sensitive Change**                | Scope change → Risk analysis → Implement → Audit diff → Validate                                                     |
| **Parallel Review**                          | Revisiones de corrección, de seguridad y de cobertura de pruebas, una tras otra, y después se fusionan los hallazgos |
| **UI Implementation**                        | UI plan → Implement → Code review → Behavior test                                                                    |
| **DevOps Change**                            | DevOps plan → Risk review → Apply → Validate                                                                         |
| **Feature SDLC**                             | Requirements → Delivery plan → Technical design → Backend → Frontend → E2E tests → Security review → User docs       |
| **Discovery & Spec**                         | Prior art → Requirements → Delivery plan (sin código)                                                                |
| **Architecture Debate**                      | Dos arquitectos proponen, un revisor critica y el arquitecto sintetiza                                               |
| **Threat Model**                             | Scope & data-flow → STRIDE analysis → Record ADR                                                                     |
| **Swarm Inspection**                         | Porciones de revisión, de seguridad y de pruebas por toda la base de código, y después un resumen fusionado          |
| **Release Readiness**                        | Revisión, seguridad, comprobación E2E básica y auditoría de dependencias, y después un go/no-go                      |
| **Incident Response**                        | Triage → Root cause → Mitigation → Verify → Postmortem                                                               |
| **Dependency Refresh**                       | Audit → Upgrade → Test → Verify secure                                                                               |
| **Performance Tuning**                       | Profile → Optimization plan → Apply → Re-measure                                                                     |
| **Data Migration**                           | Schema → Migration → Validate → Security → Final review                                                              |

Architecture Debate, Discovery & Spec y Threat Model registran un registro de decisión de arquitectura (ADR) que puedes encontrar en **Plan → ADRs**.

## Cuándo se escribe y se comprueba el código

El código se escribe después del paso que implementa el cambio (Build, Implement, Apply, Mitigation, Upgrade, Migration, o Backend y Frontend), y las pruebas de tu proyecto se ejecutan sobre él. Los pasos posteriores a ese, como Review, Test, Audit diff o Re-measure, se ejecutan a continuación. Se les muestra el cambio tal como se escribió y el resultado de pruebas registrado, así que comprueban el código, no un plan. Un flujo de trabajo sin paso de implementación, como Parallel Review, ejecuta todos sus pasos antes de que se escriba el código.

Sea cual sea el flujo de trabajo, una sesión que escribe código pasa por las mismas comprobaciones: las pruebas de tu proyecto se ejecutan contra el cambio, una revisión con IA registra hallazgos y una persona lo aprueba antes de que se abra un pull request. Consulta [Controles de calidad](https://aicodeops.dev/es/docs/quality-gates).

## Modelos por paso

Con los modelos de la plataforma y **Auto**, cada paso recibe el nivel que le conviene: los pasos de dirección (Architect, Reviewer, Security Auditor, Researcher y los planificadores) reciben el mejor nivel para el que tengas cuota, la escritura de código recibe Standard y la redacción recibe Economy. Consulta [Modelos y niveles](https://aicodeops.dev/es/docs/models).

## Agentes personalizados y skills

En **Configure → Agents**, elige **New agent** para definir tu propio agente: su modelo, sus permisos y su prompt.

Una skill es un conjunto de instrucciones reutilizables que los agentes de una sesión siguen cuando es pertinente. Las sesiones cargan dos tipos:

- **Skills del repositorio.** Un archivo `SKILL.md` en una carpeta bajo `.codeopsstudio/skills/` (o `.claude/skills/`) en el repositorio de un proyecto. Añade o cambia una haciendo commit. Todas las sesiones de ese proyecto la cargan.
- **Skills integradas.** Documentation, Security Review, Refactor, Migration y Test Generation. Están desactivadas hasta que las activas: en **Configure → Skills**, elige un proyecto y pulsa **Turn on** junto a una skill. A partir de entonces, todas las sesiones de ese proyecto la cargan. **Turn off** la quita de nuevo. Para cambiar esto necesitas permiso para gestionar proyectos, y cada cambio se anota en el registro de auditoría.

Si el repositorio de un proyecto tiene su propia skill con el mismo nombre que una integrada, las sesiones usan la del repositorio. Una sesión lanzada sin proyecto no carga ninguna skill.

Las políticas pueden limitar qué agentes y flujos de trabajo se ejecutan sin aprobación. Consulta [Aprobaciones y políticas](https://aicodeops.dev/es/docs/approvals-and-policies).

## Siguientes pasos

- [Lanzar una sesión](https://aicodeops.dev/es/docs/sessions)
- [Controles de calidad](https://aicodeops.dev/es/docs/quality-gates)
- [Todos los agentes](https://aicodeops.dev/es/agents)

## Preguntas frecuentes

### ¿Con qué flujo de trabajo debería empezar?

Plan, Build, Review & Test. Es el flujo por defecto y sirve para la mayoría de los cambios de código. Elige un flujo de trabajo especializado cuando la tarea sea claramente de seguridad, de interfaz, de infraestructura, de datos o de incidentes.

### ¿Puedo añadir mis propios agentes?

Sí, para los roles integrados. En Configure → Agents puedes dar a un agente tu propio prompt, modelo y permisos; tiene efecto allí donde un paso de un flujo de trabajo usa ese agente. Los flujos de trabajo en sí todavía no se pueden personalizar, así que un agente para un rol completamente nuevo no se ejecuta.
