The agent loop

Concept 1

The four stages, one cycle

Every agent — no matter how fancy — is running this same little cycle. Each trip around the loop is one "step." Read them in order:

That last arrow is the whole trick: Stage 4 feeds back into Stage 1. The agent keeps circling — perceive, reason, act, observe — and each lap it knows a little more than the last.

Concept 2

Why the loop is the whole point

A plain chatbot gets one shot: it reads your question and must answer immediately, right or wrong. The loop changes everything.

This is why agents handle messy, multi-step jobs. Booking a trip, debugging code, researching a topic — none of these can be done in one guess. The loop lets the agent break a big goal into steps and recover when a step goes sideways.

Concept 3

How it knows to stop

A loop that never ends is a bug, not a feature. Agents get two brakes so they always halt:

• The "done" check — every Stage 4, the agent asks "is the goal actually met?" If yes, it exits the loop and gives the final answer.
• A max-iterations limit — a hard cap (say, 10 steps). Even if it's stuck, it stops after N laps instead of spinning forever and burning money.

Think of the step limit as a safety net. The "done" check is the normal way out; the iteration cap catches the agent when it gets confused and can't find the exit on its own.

Concept 4

The loop, in pseudocode

Strip away the jargon and the whole agent fits in a few lines. Watch the four stages — they're labeled right in the code:

# goal comes from the user; give it a step limit so it can't run forever
def run_agent(goal, max_steps=10):
    for step in range(max_steps):

        # ── Stage 1: PERCEIVE ── take in goal + everything so far
        context = goal + history

        # ── Stage 2: REASON & PLAN ── LLM picks the next move
        thought, action = llm.decide(context)

        # ── Stage 4 (early exit): the "done" check ──
        if action == "finish":
            return thought        # goal met — leave the loop

        # ── Stage 3: ACT ── call the chosen tool for real
        result = tools.run(action)

        # ── Stage 4: OBSERVE ── record the result, then loop again
        history += (thought, action, result)

    return "Hit the step limit before finishing."   # the safety brake

Concept 5

Watch the loop run: Thought → Action → Observation

Let's send one goal through a few laps. This shape — Thought, Action, Observation — is called ReAct (Reason + Act), and it's the most common way agents run the loop. Here's a goal that takes 3 passes:

# GOAL: "How many days until New Year's, and what's the weather in Austin?"

# ── Pass 1 ──
Thought      → "Two things to find. Start with the date math."
Action       → days_until("Jan 1")
Observation  → 170 days

# ── Pass 2 ── (loops back with what it just learned)
Thought      → "Got the days. Now the live weather."
Action       → get_weather("Austin, TX")
Observation  → 99°F, sunny

# ── Pass 3 ── (the "done" check passes)
Thought      → "I have both answers. Goal met — finish."
Action       → finish
Answer       → "170 days until New Year's, and it's 99°F and sunny in Austin."

Notice how the agent could've hit a snag — say get_weather failed — and it would simply loop again with a different action instead of giving up. That resilience is the payoff of the loop. You'll build a full ReAct agent in Station 7.

Recap. The agent loop is the heart of everything: perceive → reason → act → observe → repeat. It's what turns a one-shot chatbot into an agent that chips away at a goal, recovers from bad results, and stops when it's done (or hits a step limit). The ReAct shape — Thought, Action, Observation — is how you'll usually see it. Next up: the tools the loop reaches for when it acts.