Ironhack
Material del workshop · 10 de noviembre de 2026

Agentes que trabajan solos

Cómo convertir una tarea repetitiva en un equipo de agentes que la hace por ti, y en el que tú solo revisas el resultado.

1 · Sonnet ×4ClasificadorCuatro a la vez, 5 incidencias cada uno
2 · OpusVerificadorComprueba cada error en el código real
3 · SonnetRedactorInforme que se lee en un minuto
4 · PersonaTú revisasDecides qué se arregla
Cada lunesProgramadoSe lanza solo, sin que estés
Pablo Salmerón, ponente del workshop Pablo Salmerón · @pabloinpublic · Experto en Automatización con IA
Lo que viste en la demo

20 incidencias ordenadas en menos de un minuto

Una app para repartir los gastos de un viaje tenía 20 incidencias de usuarios mezcladas: errores, ideas, dudas y repetidas. Un equipo de agentes las ordenó, comprobó en el código cuáles eran errores de verdad y dejó un informe listo para decidir.

~55 sde principio a fin
~0,35 $por pasada
4errores reales, con fichero y línea
3falsos errores descartados
2repetidas detectadas
El esquema

Los 5 pasos de un equipo de agentes

  1. Recoge. Reúne en un sitio el material de entrada: incidencias, correos, documentos, filas de una hoja.
  2. Clasifica. Un agente decide qué es cada cosa, con un formato fijo. Si hay mucho volumen, varios a la vez, cada uno con su lote.
  3. Verifica. Otro agente distinto comprueba el trabajo contra una fuente real. No se fía del primero.
  4. Redacta. Un tercer agente escribe el resultado para quien decide, solo con lo ya comprobado.
  5. Revisas tú. El informe es una propuesta. La decisión es tuya.
Las reglas

Cuatro reglas para que salga bien

Un contrato por agenteQué recibe, qué entrega y en qué formato. Si no lo cumple, el equipo se para.
Un agente que verificaEl que comprueba nunca es el que hizo el trabajo.
Límites de permisos y costeSolo lectura, tope de turnos y tope de gasto por agente.
Una persona al finalNada se aplica sin que alguien lo haya revisado.
Antes de empezar

¿Merece la pena automatizar esa tarea?

Piensa en una tarea concreta de tu semana y marca lo que se cumple.

Marca las que se cumplen.
Tu equipo

Diseña tu equipo de agentes

Rellena los huecos con tu tarea. Debajo se compone el esquema completo, listo para copiar y pegar en tus notas o dárselo a un agente para que te ayude a montarlo.

Por dentro · 1

Las instrucciones de un agente

Cada agente es un fichero corto en lenguaje normal: su papel, qué puede mirar, qué no puede hacer y su contrato de salida. Este es el verificador, adaptado para que lo copies y cambies lo que está entre corchetes.

# Verificador

Eres el verificador del equipo. Otro agente ya ha clasificado [las incidencias];
tú compruebas contra [el código real] lo que ha marcado como [error].

## Qué puedes mirar
- salida/clasificacion.json: lo que decidió el clasificador.
- [entrada/datos.json]: el material original.
- [fuente/]: la fuente de verdad. Busca y lee solo lo necesario.

## Qué no puedes hacer
- No modificas ficheros ni ejecutas comandos. Solo lees y respondes.
- No confirmas nada sin haberlo visto en la fuente.

## Cómo decides
- Confirmado: la fuente demuestra lo que dice el usuario. Evidencia: ruta:línea.
- Rechazado: la fuente demuestra lo contrario. Evidencia: la línea que lo prueba.

## Contrato de salida
Entrega el resultado llamando a la herramienta StructuredOutput:
{"verificaciones":[{"id":"1","veredicto":"confirmado","evidencia":"fuente/carrito.js:3"}]}
Por dentro · 2

El script que los encadena

Unas 40 líneas de bash con Claude Code en modo no interactivo (claude -p). Cada agente solo puede leer, nunca pide permisos, tiene tope de turnos y de gasto, y entrega un JSON que se valida contra un esquema. Los ficheros los escribe el script, no los agentes.

#!/usr/bin/env bash
# Equipo de 3 agentes: clasifica, verifica y redacta.
# Los agentes solo leen; los ficheros los escribe este script.
set -euo pipefail
cd "$(dirname "$0")"
mkdir -p salida && find salida -mindepth 1 -delete   # empieza de cero

# agente <modelo> <instrucciones.md> <esquema.json> <petición>
agente() {
  claude -p "$4" \
    --append-system-prompt "$(cat "$2")" \
    --model "$1" --max-turns 12 --max-budget-usd 1 \
    --tools Read,Grep,Glob --permission-mode dontAsk \
    --setting-sources project --strict-mcp-config \
    --json-schema "$(cat "$3")" \
    --output-format json --no-session-persistence < /dev/null \
  | jq -e '.structured_output'
}

# 1. CLASIFICA: dos agentes a la vez, cada uno con su lote
agente sonnet agentes/clasificador.md esquemas/clasificacion.json \
  "Clasifica los elementos 1 y 2 de entrada/datos.json." > salida/lote-1.json & p1=$!
agente sonnet agentes/clasificador.md esquemas/clasificacion.json \
  "Clasifica los elementos 3 y 4 de entrada/datos.json." > salida/lote-2.json & p2=$!
wait $p1 && wait $p2 || { echo "Falló la clasificación"; exit 1; }
jq -s '{elementos: [.[].elementos[]]}' salida/lote-*.json > salida/clasificacion.json

# 2. VERIFICA: otro agente comprueba contra la fuente
agente opus agentes/verificador.md esquemas/verificacion.json \
  "Verifica los errores de salida/clasificacion.json contra fuente/." > salida/verificacion.json

# 3. REDACTA: el informe, solo con lo ya verificado
agente sonnet agentes/redactor.md esquemas/informe.json \
  "Escribe el informe a partir de entrada/ y salida/." | jq -r '.informe' > salida/informe.md

echo "Listo: salida/informe.md"   # 4. REVISAS TÚ
Los esquemas JSON de este ejemplo

Van en esquemas/. Son el contrato de cada agente: si la salida no encaja, Claude Code obliga al agente a corregirla antes de terminar.

// esquemas/clasificacion.json
{"type":"object","required":["elementos"],"properties":{"elementos":{"type":"array","items":{"type":"object","required":["id","tipo","duplicado_de"],"properties":{"id":{"type":"string"},"tipo":{"enum":["error","mejora","duda","duplicado"]},"duplicado_de":{"type":["string","null"]}}}}}}

// esquemas/verificacion.json
{"type":"object","required":["verificaciones"],"properties":{"verificaciones":{"type":"array","items":{"type":"object","required":["id","veredicto","evidencia"],"properties":{"id":{"type":"string"},"veredicto":{"enum":["confirmado","rechazado"]},"evidencia":{"type":"string"}}}}}}

// esquemas/informe.json
{"type":"object","required":["informe"],"properties":{"informe":{"type":"string"}}}
Qué hace cada opción de claude
  • -pModo no interactivo: hace la tarea y termina.
  • --append-system-promptAñade las instrucciones del agente (su fichero .md).
  • --tools Read,Grep,GlobLas únicas herramientas que existen para ese agente: puede leer y buscar, nada más.
  • --permission-mode dontAskLo que no está permitido se deniega sin preguntar, así que nunca se queda esperando. Además limita la lectura a la carpeta del proyecto.
  • --max-turns y --max-budget-usdTopes de turnos y de gasto por agente.
  • --setting-sources project --strict-mcp-configNo carga tus ajustes personales ni tus servidores MCP. Más barato y más predecible.
  • --json-schema y --output-format jsonLa respuesta sale como JSON validado en el campo structured_output.
  • < /dev/nullEvita que espere 3 segundos a una entrada que no va a llegar.

Necesitas Claude Code con la sesión iniciada y jq. Probado con Claude Code 2.1.319; si algo falla, compara con claude --help, porque las opciones cambian entre versiones.

Que trabaje solo

Prográmalo

Con el script listo, que se lance solo. En tu ordenador, con crontab -e:

# Cada lunes a las 08:00
0 8 * * 1 cd ~/ruta/a/tu-equipo && ./equipo.sh >> ~/equipo.log 2>&1

O en GitHub Actions, con un flujo programado (on: schedule) que ejecute el script y guarde salida/informe.md como artefacto. En ese caso necesitas una clave de API como secreto del repositorio; nunca la escribas en el código.

Lo que aprendí montándolo

Cinco errores que te ahorras

  • Sin perfil limpio, cada llamada carga todo lo tuyo.Con mi configuración personal, una sola llamada costó 0,85 $. Con --setting-sources project --strict-mcp-config, el equipo entero se queda en céntimos.
  • Topes de turnos demasiado justos paran el equipo.Con 6 turnos, un agente podía quedarse sin margen. Usa 12 y deja que el tope de gasto haga de freno.
  • Pídele que entregue con StructuredOutput.Si escribe primero el JSON como texto, gasta un turno de más y a veces repite el trabajo.
  • El clasificador no debe hacer el trabajo del verificador.Si lo dejas, descarta él solo los falsos errores y nadie lo comprueba. Que marque como error todo lo que el usuario dice que falla.
  • Empieza de cero en cada pasada.Vacía la carpeta de salida al arrancar, o mezclarás resultados de dos pasadas.
Para esta semana

Tu primer equipo, en tres pasos

  1. Elige una tarea que pase la checklist de arriba con 4 o 5 marcas.
  2. Empieza con dos agentes: uno que hace el trabajo y otro que lo verifica. El redactor y el paralelismo, después.
  3. Lánzalo a mano tres veces y compara los resultados. Cuando salgan estables, prográmalo.
Ironhack · Próximamente

Este workshop es un adelanto de un nuevo programa que estamos preparando.