Chapter 3

Execution Loops, Planning, and Self-Correction

True agents plan, execute, evaluate outcomes, and adapt strategies when intermediate steps fail.

The Concept

Enterprise tasks are rarely solved in one pass. Agents must decompose complex goals, choose actions, evaluate outcomes, and refine the plan when results are incomplete.

Execution loops provide this adaptive control. Instead of a single response, the system runs iterative cycles that connect planning, action, reflection, and retry logic.

This looped architecture improves resilience when tools fail, APIs are rate-limited, or retrieved evidence conflicts with user expectations.

Technical Implementation

Represent plans as explicit state machines with step status, dependencies, and rollback paths. Store these plans so execution can resume safely after interruptions.

After each tool call, run a lightweight evaluator that checks whether acceptance criteria were met. If not, route the flow to replanning with preserved context.

Set hard iteration limits and failure budgets to prevent infinite loops. Escalate unresolved cases to a human review queue with full trace context.

Key Terms

Reason–Act loop

The core agent cycle: think about what to do, act with a tool, observe the result, repeat until done.

Step budget

A hard cap on loop iterations that converts runaway agents into bounded, predictable jobs.

Checkpointing

Persisting loop state after every step so runs can pause, resume, and be audited.

Reflection

A self-critique step where the model reviews its own progress before committing to the next action.

Code Example

MAX_STEPS = 12

def run_agent(goal: str, memory: MemoryTier) -> RunResult:
    trace = Trace(span="agent.run")             # OpenTelemetry child spans
    state = checkpoint.load_or_init(goal)

    for step in range(MAX_STEPS):
        thought = llm.plan(state=state, goal=goal, tools=TOOLS)
        if thought.action == "final_answer":
            trace.close(outcome="completed")
            return RunResult(answer=thought.answer, steps=step + 1)

        observation = safe_execute(thought.tool_call)   # ch.2 gateway
        state.observe(observation)
        checkpoint.save(state)                          # resumable mid-run
        trace.event(step=step, thought=thought, obs=observation)

    escalate_to_human(state, trace)   # budget exhausted -> hand off
    trace.close(outcome="escalated")

Common Pitfalls

• No iteration cap: a confused agent loops on the same failing tool until the bill arrives.
• Discarding intermediate observations — without them the model repeats work it already did.
• Hiding the loop. Every step should emit a trace event; opaque loops cannot be debugged or trusted.

Reason-Act-Reflect Loop

Enterprise Scenario

An operations agent coordinates incident response: gather telemetry, execute diagnostics, summarize probable causes, and update stakeholders with confidence scoring.

Operational Outcomes

• Improved task completion for multi-step objectives.
• Faster recovery from transient API/tool failures.
• Clear escalation when confidence drops below thresholds.

Neural Networks, LLMs, and Agentic Insights

• Agentic loops mirror control systems: observe state, choose action, evaluate delta, and adapt policy.
• ReAct-style prompting increases transparency by separating reasoning traces from external action steps.
• Tree-search or planner-executor variants improve success on tasks that require branching strategy exploration.

Applications

• SOC analysts using autonomous triage agents for alert clustering and response recommendations.
• Supply-chain planners running what-if simulations and replanning around disruption events.
• Developer assistants that iteratively code, test, fix, and verify under policy constraints.

Flow Diagrams

Further Reading

• ReAct: Synergizing Reasoning and Acting in Language Models (arXiv 2210.03629)
• LangGraph — building stateful, multi-step agent runtimes

YouTube Suggestions

Explore these popular topic videos for deeper learning on this chapter.

• ReAct Prompting and Agent LoopsPrompt Engineering Community
• Building Autonomous AI AgentsLangChain / Community
• Planning and Self-Correction in LLM SystemsAI Engineering Talks

Study Guides

Short, beginner-friendly pages that explain this chapter step by step — start here if the material above feels dense.