Programma Les 176 van 250 · Agents bouwen (Tool-Use & ReAct)
Agents bouwen (Tool-Use & ReAct)

Planning, Reflectie & Herplanning

Eén ReAct-lus is prima voor één toolaanroep, maar echte taken hebben stappen: een onderwerp onderzoeken en dan samenvatten; een vlucht boeken en dan een hotel. Een capabele agent improviseert niet één actie tegelijk - hij maakt een plan, werkt het af en reflecteert na elke stap om te beslissen of hij doorgaat, bijstuurt of stopt. Die cyclus van plannen, handelen en reflecteren laat een agent een lange taak afmaken zonder af te dwalen.

1. Splits het doel op in een plan

Plannen betekent een vaag doel omzetten in een geordende lijst van deeltaken. In productie schrijft het model dit plan; hier maken we het deterministisch en op trefwoorden gebaseerd, zodat het testbaar is. Hetzelfde idee, vastgelegde uitvoer:

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. Reflecteer op het resultaat van elke stap

Nadat een deeltaak gedraaid heeft, bekijkt de agent de uitkomst en neemt hij een besturingsbeslissing. We geven hem een klein resultaat-dict {"ok": bool, "last": bool} (is de stap gelukt, en is het de laatste stap) en drie mogelijke beslissingen:

  • "replan" - de stap is mislukt. Wat we ook probeerden, het werkte niet, dus het huidige plan is verdacht.
  • "done" - de stap is gelukt en het was de laatste. Het doel is bereikt.
  • "continue" - hij is gelukt, maar er is meer te doen. Ga naar de volgende deeltaak.

De volgorde doet ertoe: een mislukking betekent "replan", zelfs bij de laatste stap (een kapotte laatste stap is niet "done").

3. Plan één keer opnieuw bij een mislukking

De controller brengt het samen. Hij loopt het plan af, roept execute(subtask) aan voor elke stap, markeert of het de laatste was en reflecteert. Bij "continue" gaat hij verder; bij "done" stopt hij met succes; bij "replan" bouwt hij een nieuw herstelplan en begint opnieuw - maar hoogstens max_replans keer, zodat een hopeloze taak niet eeuwig kan lussen (de discipline van de lusbewaker van eerder). Zijn de herplanningen op, dan stopt hij met "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] + rest

execute is hier een nepfunctie - een functie die je meegeeft en die {"ok": ...} voor een deeltaak teruggeeft - in plaats van de echte toolaanroepen, zodat de controller volledig deterministisch en testbaar is. In een echte agent stuurt dezelfde controller echte tools en een door het model geschreven plan aan zonder dat zijn logica verandert. Druk op Run om een plan te zien slagen, en daarna een plan dat bij een stap faalt en zich bij de herplanning herstelt.

Jij bent aan de beurt

Bouw een planning controller. Schrijf decompose(goal) die de geordende subtask lijst teruggeeft (research/report -> ["gather sources", "extract facts", "write summary"]; trip/travel -> ["pick dates", "book flights", "book hotel"]; anders -> ["understand goal", "do the work", "review result"]). Schrijf reflect(step_result) over {"ok", "last"} die "replan" teruggeeft als niet ok, anders "done" als laatste, anders "continue". Schrijf replan(goal, failed_step) -> een recovery plan dat de mislukte step opnieuw probeert en daarna nog steeds elke step uitvoert die daarna kwam in decompose(goal): voor een research doel dat faalt bij "extract facts", ["retry: extract facts", "write summary"]. (Een recovery plan dat het resterende werk overslaat en "done" rapporteert is de klassieke agent bug: de samenvatting is nooit geschreven.) Als failed_step zelf een retry is, verwijder dan eerst het "retry: " prefix zodat het niet dubbel wordt. Schrijf dan run_plan(goal, execute, max_replans=1) dat door het plan loopt, execute(subtask) aanroept (geeft {"ok": bool} terug), reflecteert (je stelt last in), een (subtask, ok, decision) trace vastlegt, tot max_replans keer opnieuw plant bij een fout (de recovery plan opnieuw startend vanaf de eerste step) en {"status": "done"|"failed", "trace": [...], "replans": int} teruggeeft.

Een probleem ontdekt in deze les? Meld het · Vraag naar deze les

Deze oefening opent binnenkort

Maak de les ervoor af voordat deze wordt ontgrendeld. De hele cursus is gratis, geen account nodig, en je kunt deze les nu lezen.