Planificación, reflexión y replanificación
Un solo bucle ReAct sirve para una llamada a herramienta, pero las tareas reales tienen pasos: investigar un tema y luego resumirlo; reservar un vuelo y luego un hotel. Un agente capaz no improvisa una acción cada vez: hace un plan, lo va cumpliendo y reflexiona tras cada paso para decidir si sigue, corrige el rumbo o para. Ese ciclo de planificar, actuar y reflexionar es lo que permite a un agente terminar una tarea larga sin perderse.
1. Descomponer el objetivo en un plan
Planificar significa convertir un objetivo difuso en una lista ordenada de subtareas. En producción es el modelo quien escribe este plan; aquí lo hacemos determinista y guiado por palabras clave para que se pueda probar. Misma idea, salida fijada:
def decompose(goal):
g = goal.lower()
if "research" in g or "report" in g:
return ["gather sources", "extract facts", "write summary"]
elif "trip" in g or "travel" in g:
return ["pick dates", "book flights", "book hotel"]
return ["understand goal", "do the work", "review result"]2. Reflexionar sobre el resultado de cada paso
Tras ejecutarse una subtarea, el agente mira el resultado y toma una decisión de control. Le damos un pequeño dict de resultado {"ok": bool, "last": bool} (si el paso salió bien y si es el último) y tres decisiones posibles:
"replan": el paso falló. Lo que intentamos no funcionó, así que el plan actual es sospechoso."done": el paso salió bien y era el último. El objetivo se ha cumplido."continue": salió bien pero queda más por hacer. Pasa a la siguiente subtarea.
El orden importa: un fallo significa "replan" incluso en el último paso (un paso final roto no es "done").
3. Replanificar una vez ante un fallo
El controlador lo une todo. Recorre el plan, llama a execute(subtask) en cada paso, marca si era el último y reflexiona. Con "continue" avanza; con "done" para con éxito; con "replan" construye un plan de recuperación nuevo y vuelve a empezar, pero solo hasta max_replans veces, para que una tarea sin remedio no pueda repetirse para siempre (la disciplina de las protecciones del bucle de antes). Si se agotan las replanificaciones, para con "failed".
def replan(goal, failed_step):
# retry the failed step, then still do every step that came after it
base = failed_step[len("retry: "):] if failed_step.startswith("retry: ") else failed_step
plan = decompose(goal)
rest = plan[plan.index(base) + 1:] if base in plan else []
return ["retry: " + base] + restexecute es aquí una simulación (una función que pasas tú y que devuelve {"ok": ...} para una subtarea) que sustituye a las llamadas reales a herramientas para que el controlador sea totalmente determinista y se pueda probar. En un agente en vivo, el mismo controlador mueve herramientas reales y un plan escrito por el modelo sin cambiar su lógica. Pulsa Ejecutar para ver un plan salir bien, y luego ver otro fallar un paso y recuperarse con la replanificación.
Construye un controlador de planificación. Escribe decompose(goal), que devuelva la lista ordenada de subtareas (research/report -> ["gather sources", "extract facts", "write summary"]; trip/travel -> ["pick dates", "book flights", "book hotel"]; en otro caso -> ["understand goal", "do the work", "review result"]). Escribe reflect(step_result) sobre {"ok", "last"}, que devuelva "replan" si no es ok, si no "done" si es el último, y si no "continue". Escribe replan(goal, failed_step) -> un plan de recuperación que reintente el paso fallido y luego siga haciendo cada paso que venía después en decompose(goal): para un objetivo de investigación que falla en "extract facts", ["retry: extract facts", "write summary"]. (Un plan de recuperación que se salta el trabajo pendiente e informa de "done" es el fallo clásico de los agentes: el resumen nunca se escribió.) Si failed_step ya es un reintento, quita primero el prefijo "retry: " para que no se duplique. Luego escribe run_plan(goal, execute, max_replans=1), que recorra el plan, llame a execute(subtask) (devuelve {"ok": bool}), reflexione (tú fijas last), registre una traza (subtask, ok, decision), replanifique hasta max_replans veces ante un fallo (reiniciando el plan de recuperación desde su primer paso) y devuelva {"status": "done"|"failed", "trace": [...], "replans": int}.
¿Has visto un problema en esta lección? Avísanos · Preguntar sobre esta lección
Este ejercicio se abre pronto
Termina la lección anterior y esta se desbloquea. Todo el curso es gratis, no hace falta cuenta, y puedes leer esta lección ahora mismo.
Este navegador está bloqueando las cookies de learn.floati.life, así que las lecciones que terminaste aquí no se pueden abrir en orden. Permite las cookies de este sitio y recarga.