AWS Builder Center
Introducción a Kiro Worflows

Introducción a Kiro Worflows

Kiro Workflows es un feature de Kiro que permite ejecutar flujos de agentes de diversas maneras, es bastante flexible y se integra con sus demás caraterísticas. En éste artículo cuento mi experiencia probándolo con uno de mis proyectos de prueba.

Sr. Cloud Engineer

¿Qué es Kiro Workflows?

Kiro Workflows es una nueva característica de Kiro que le permiten al usuario orquestar múltiples agentes, definiendo el flujo en un lenguaje estructurado declarativo (JSON o YAML) y éste organiza el trabajo como un grafo con secuencias ordenadas de pasos por agente, ramas en paralelo y bucles con parada condicional.

¿Cómo funciona?

El Runtime de Kiro ejecuta los flujos en segundo plano, corriendo cada paso en su propia sesión, por lo tanto un agente revisor puede evaluar el trabajo sin heredar el razonamiento previo que hizo otro agente el cuál escribió el código. Todos los pasos pasan sus resultados hacia adelante mediante referencias de salida. Los bucles se repiten hasta que se cumpla una condición (una nota de aprobación por ejemplo), y toda la ejecución reporta su progreso de vuelta a nuestra sesión de chat principal para que continúe el trabajo, o haya que responder alguna pregunta ocasional o ofrecer una guía en medio de la ejecución.
En resumen, mientras que una sesión de chat regular obliga al usuario a guiar al modelo por cada fase y recordarle una y otra vez las decisiones previas, un flujo (workflow) captura ese proceso una sola vez como una receta reutilizable y deja que el runtime lo ejecute — convirtiendo "implementa..., ahora revisa..., ahora corrige..." en un único proceso al que puedes pulir y volver a ejecutar.

Esquema

El esquema de un Workflow es similar a éste:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
{
"name": "",
"description": "",
"inputs": {
# Values that are going to be interpolated when referenced.
},
"steps": [
{
"type": "",
"id": "",
"steps": [
{
"type": "step",
"id": "",
"agent": "",
"prompt": "",
"artifacts:" {
# Agent report as a file
}
},
]
}
]
}

Tipos de nodo

Existen cinco tipos de nodos en un flujo (workflow) de Kiro:
  1. step — ejecuta una sola sesión de agente con un prompt. La unidad básica de trabajo.
  2. sequence — ejecuta sus nodos hijos en orden, uno tras otro.
  3. parallel — ejecuta varias ramas de forma concurrente, con una política de unión (all, allSettled o any).
  4. repeat — repite sus nodos hijos hasta que se cumple una condición de parada (o se alcanza maxIterations), con un comportamiento onMaxIterations de abort, continue o pause.
  5. watch — sondea un sistema externo (sin LLM), por ejemplo un PR de GitHub (github-pr) o un manejador personalizado de tipo command.
Una pequeña nota de terminología: solo step ejecuta realmente un agente. Los otros cuatro son nodos estructurales o de control de flujo — sequence, parallel y repeat organizan otros nodos, y watch observa un sistema externo sin invocar a un modelo. Así que si la pregunta es específicamente "cuántos tipos de pasos de agente hay", la respuesta es uno (step); si es "de cuántos tipos de nodos se construye el grafo de un flujo de trabajo", son cinco.

Inputs (entradas)

En un flujo de Kiro (workflow), los inputs son variables de plantilla, no un esquema tipado.
Por ejemplo en el proyecto los inputs son un mapa donde cada clave es un nombre de variable y el valor es una cadena de referencia al tipo (type hint) — una descripción legible para humanos, no un tipo forzado:
1
"inputs": { "profile": "AWS SSO profile for credentialed phases (default: Walsen)", "run_deploy": "whether to run `just deploy` (default: false)"}
Esa cadena "whether to run ... (default: false)" es documentación para quien la lee; el runtime no convierte run_deploy en un booleano ni lo valida. En el lanzamiento, lo que pasemos como inputs se sustituye en los prompts de los pasos donde aparezcan {{run_deploy}}, {{profile}}, etc.
Así que el panorama práctico es:
  • En el momento de la definición — la referencia de tipo puede decir cualquier cosa: "prompt", "file", "string", "whether to...", la descripción de una ruta, el nombre de una rama. Son convenciones que veremos en las recetas incluidas (p. ej. goal: "prompt", prd_path: "file", max_iterations: ...), pero son etiquetas descriptivas, no un sistema de tipos validado.
  • En el momento del lanzamiento — los valores que realmente pasamos son cadenas (strings). Cuando se lanza mediante workflowPath con inputs, cada valor es una cadena (por eso run_deploy se pasa como "false", la cadena, no un booleano JSON). El runtime los interpola como texto en los prompts.
  • Todo es, en última instancia, sustitución de texto. No hay validación de enum, ni exigencia de requerido/opcional, ni parseo de números por parte del runtime. Si un input debe comportarse como un booleano o una opción, esa lógica vive en el prompt del paso — p. ej. el paso de deploy lee {{run_deploy}} y el prompt indica al agente "si esto no es true, no despliegues". El agente lo interpreta; el runtime solo entrega la cadena.
Convenciones comunes de lo que representan los inputs (no tipos forzados, solo cómo se usan típicamente):
  • Texto libre de prompt — una descripción de tarea (goal, prompt, research_directions).
  • Ruta de archivo o directorio — rutas absolutas que los pasos leen/escriben (design_path, prd_path, report_path, workdir, spec_dir, worktree_path).
  • Referencia de Git — un nombre de rama o de mainline (branch, worktree_branch, mainline_branch).
  • Cadena tipo bandera (flag) — un sí/no o una opción que el prompt interpreta (run_deploy).
  • Escalar corto — un nombre de perfil, un conteo, un identificador (profile, max_iterations).
Dos salvedades para que esto no induzca a error:
  1. Las salidas de los pasos son algo distinto de los inputs. Además de los inputs de lanzamiento, los pasos se referencian entre sí mediante {{step_id.output}} y {{previous.output}}, y los artefactos mediante {{artifacts.<name>}}. Esos no se declaran en inputs — se producen en tiempo de ejecución. El validador sí comprueba esas referencias estructurales (que un paso referenciado se ejecute antes y produzca salida), mientras que no valida las pistas de tipo de inputs.
  2. Para las formas de receta que toman inputs en el lanzamiento (un workflowPath o una receta bundled:///agent://), mantén los valores cortos — rutas, ramas, cadenas de una línea. El texto largo de la tarea va en los prompts de los pasos de la receta (incrustados cuando se crea el flujo de trabajo), no se pasa como input de lanzamiento.
Así que, para responder directamente: no hay un conjunto fijo de tipos de input que Kiro imponga — los inputs son variables de cadena con nombre y con pistas de tipo descriptivas, y el "tipo" es en realidad solo una convención (prompt / ruta / referencia / bandera / escalar) a la que los prompts de los pasos dan significado.

Tipos de agente

Los agentes registrados y disponibles en Kiro — el conjunto que se puede nombrar en el campo agent de un nodo step — son estos nueve agentes integrados wf-*/revisor:
  • wf-coder — lee archivos, edita código, ejecuta pruebas, hace commits; implementación general.
  • wf-planner — investiga una base de código y produce un plan de implementación ordenado.
  • wf-design — redacta documentos de requisitos y de diseño técnico para una funcionalidad.
  • wf-design-reviewer — revisa diseños técnicos buscando ambigüedad, lagunas y supuestos no verificados; veredicto mecánico.
  • semantic_reviewer — revisión de código conductual y narrativa de un diff local o de un PR; escribe una reseña y un veredicto.
  • wf-review-aggregator — fusiona varias salidas de revisión en un único veredicto consolidado.
  • wf-auto-researcher — subagente de investigación autónomo: ejecuta experimentos, hace benchmarks, hace commit de las mejoras.
  • wf-pr-submitter — abre un pull request desde una rama y registra los metadatos del PR.
  • wf-pr-responder — responde a los comentarios de revisión del PR y a la retroalimentación de CI.
También existe wf-workflow-creator, que es el agente que diseña/guarda las definiciones de flujos (workflows) , pero normalmente no lo colocarías en un step.

El primer experimento

Para una de mis charlas, creé un proyecto pequeño que es un Sudoku en línea desplegado en AWS Amplify con Lambda y DynamoDB como backend.
Para éste proyecto quería 2 cosas:
  1. Tener un flujo de testeo con varios agentes que identifiquen problemas y los reparen in situ. Una vez completado desplegar los fixes.
  2. Implementar un nuevo feature, que es, permitir al usuario elegir un nivel de complejidad antes de lanzar el juego; y desplegar el nuevo feature una vez terminado. El despliegue sería condicional usando un feature flag.
Para quien quiera ver el proyecto está disponible aquí .
He aquí mi test en vivo: https://youtu.be/HU6tNaMHt2g 

Mi opinión

Al igual que cuando salió KiroCrew, Kiro Workflows tiene sus defectos, es complicado entender cómo habilitarlos, o cómo ejecutarlos, en la documentación no está tan claro. Aunque es tan simple como decirle a Kiro "ejecuta el workflow ....".
He oído comentarios de que consume muchos tokens, pero sinceramente a mi no me ha ocurrido, para el workflow de testeo no fueron más de 70 tokens, para el de implementación como 150, entonces creo que es muy razonable. Es obvio además que no lo he usado de la forma más correcta, sino hasta donde la intuición y Kiro me han llevado.
Lo único que realmente no me gustó es que no se puedan usar agentes creados por uno mismo en los flujos, tienen que ser agentes que ya vienen en Kiro por defecto.
Es un feature que tiene un enorme potencial, permite ejecutar flujos de muchas maneras, incluirlos en automatización, generarlos dinámicamente, y un gran etc.
Yo creo que hay que esperar, hay que usarlos y enviar el feedback indicado al Kiro Team para que se moldee de acuerdo a las necesidades reales del mercado.

Documentación

Workflows (visión general)  —  El concepto: grafos de pasos de agente, secuencias, bucles y ramas en paralelo; cada paso en su propia sesión nueva.
Author workflows (Crear flujos de trabajo)  — Cómo se crean las recetas (describe el resultado en el chat, Kiro genera el grafo, guárdalo como receta para reutilizarlo). Aquí es donde se cubren los tipos de nodo, las referencias {{...}} y los inputs.
Workflow examples (Ejemplos de flujos de trabajo)  — Las formas de las recetas incluidas (y una nota de que el conjunto de recetas incluidas puede variar entre versiones del cliente).
Run and manage workflows (Ejecutar y gestionar flujos de trabajo)  — Ejecución en segundo plano, puntos de control (checkpointing), estado/salidas/artefactos de los nodos, progreso de los bucles (repeat), cursores de watch, pausar/reanudar.
Referencias de apoyo:
[Introducing Kiro workflows (el blog, conceptual)](https://kiro.dev/blog/introducing-workflows/  Introducing Workflows in Kiro Web (changelog) — https://kiro.dev/changelog/web/introducing-workflows/ 
Empieza en https://kiro.dev/docs/workflows/  y en la página de authoring que está debajo — eso es lo más parecido a la referencia del esquema para las definiciones que comentamos (tipos de nodo, inputs como variables de plantilla {{...}}, referencias {{step_id.output}}, los agentes de paso wf-*).
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article