🧭 Fundamentals: what an agent loop is

An AI that reasons about what to do, acts, and observes the result — repeating until the goal is achieved.

It's the foundation for everything; without it, “swarms” and “fleets” are just jargon.

LLM, tool, iteration, objective.

Think→Act→See, "model uses tools," "runs on its own," and "one boss, several helpers"—all the same idea.

You stop thinking they’re different things and see the single underlying structure.

Same blueprint, four disguises.

The step where the agent reads its own result instead of assuming it worked.

It's what makes the loop converge; without observing, it confidently delivers garbage.

Observe = ground truth; the basis for checking "done?".

An intern you don't micromanage: you give them the goal, they figure out the next step, and check their own work.

Helps calibrate what to delegate and what to verify.

Objective given, steps discovered, self-correction.

A single prompt = one response and done; a loop = many iterations until you verify it’s finished.

Most tasks are a single prompt; use a loop when there’s verification and iteration.

One-shot × iterative; the cost of each.

Each cycle is one step; the loop keeps running until the "ready?" check passes or a safety limit stops it.

Gives you the mental model that works for any agent tool.

Turn = step; guardrail; course baseline glossary.

An LLM at the center decides what to do on each turn. You don’t program the steps; the model chooses.

Remove the model and there is no loop, just a script.

The model drives every iteration.

The actions the model can take: read/write files, run commands and tests, search, call an API.

Without tools, the model only talks; it doesn't act. The craft is in the tools.

Tool-calling; clear description of the actions.

The result of each action returns to the context, so the next iteration is better informed than the previous one.

For long tasks, write the state to disk (a progress file + commits) so you can pick up between sessions.

Context, context window, externalized state.

A clear goal, written so the model knows when it's finished. "All tests pass" is a goal; "improve the code" isn't.

It's one of the few elements every source agrees is essential.

Verifiable objective × vague objective.

Before continuing, the agent checks its own work against the objective: runs the tests, rereads the requirement, confirms the file changed.

Anthropic calls "check your work" "the most underrated step." It's what separates a loop that converges from one that produces confidently wrong output.

gather → act → verify → repeat.

Something that ends the loop: the completed objective (tests pass) + a hard limit (maximum number of iterations).

The sources disagree here—that’s exactly why you need to define one deliberately. Don’t assume the model will stop on its own.

max_turns; the objective is invariant, stopping isn't.

Auditing 45 verified sources reveals 11 distinct mental models of the “loop”—your instinct that it was confusing was right.

Knowing they disagree immunizes you against "so-and-so said it, so it must be true."

Minimum convergence × fractures at the edges.

"An LLM using tools in a loop until the task is done" (Willison, Anthropic, LangChain). The loop is trivial; the craft is in the tools.

It's the baseline definition. But today it's also the “punching bag” practitioners attack for being too minimal.

Agent = loop, in one sentence.

Each cycle = think → act → observe, repeat. The only school that names an internal cognition cycle.

It's the vocabulary you'll encounter most often in documentation and papers.

ReAct, “thought” (thinking without observation).

Self-verification (the same agent checks) × separate evaluator (a second agent scores it until PASS).

It's the root of the maker→checker pattern you use in Track 2.

Evaluator-optimizer; the generator never approves its own work.

A Runner/orchestrator owns the loop (OpenAI/Google/Bedrock, with max_turns) × an autonomous loop that prompts itself and runs unsupervised (AutoGPT).

Shows that a “loop” can be a runtime object OR a scheduled system.

Runner, max_turns, auto-prompt.

“Design the loop, not the prompt”; memory loop between attempts (Reflexion); “loop isn’t the right primitive” (swyx); and the terminology trap: “loop” = human-in-the-loop.

Avoid copying an HITL guide when you think it’s a build standard.

HITL = human supervision, not agent cognition.

Who owns it, what ends the loop, whether “verify” is part of it, the scope of an iteration, whether tools are essential, and whether “loop” is the right primitive.

Knowing the axes lets you read any definition and see where it falls.

6 axes; the invariant core underneath.