← AI

Agentic Engineering

Verified Sep 7, 2026

TL;DR

A plain prompt gets one shot: ask, get an answer, done — right or wrong. An agent instead runs a loop: think about what to do next, take an action (usually calling a tool), observe what came back, and repeat until the task is actually finished. Most real tasks can't be answered in one shot — they need information the model doesn't have yet, which means it has to go get it, one step at a time, adjusting its plan as it learns more.

ELI5

A single prompt is like asking someone to guess your weight through a closed door — one shot, no follow-up, no way to check. An agent is like letting them actually open the door, look at the scale, and tell you. If the answer depends on more than one thing — say, whoever'sheaviest out of five people — they need to check each person, remember what they've found so far, and keep going until everyone's checked. That checking-one-thing-at-a-time-and-remembering loop is the entire idea behind an agent. Nothing mystical — just a plan, one real action, one real result, repeated until done.

WHY IT MATTERS

  • Most useful tasks need information gathered during the task, not known up front — a single prompt can't do that.
  • This is the actual mechanical difference between "an AI that answers questions" and "an AI that gets things done."
  • Every real agent framework — regardless of vendor — is built on this same think/act/observe shape underneath.

HOW IT WORKS

Every iteration of the loop has the same three parts:

  1. Thought — what should happen next, given everything learned so far.
  2. Action — a real tool call: a function with real inputs and a real return value, not a guess.
  3. Observation — the actual result, which becomes part of what the next Thought reasons about.

The loop ends when the task is done, or when a step budget runs out — see the lab and Failure Modes below for why that budget matters.

Try it yourself: watch the loop run

A real toy agent, not a canned animation: it's given five packages and a checkWeight(id) tool that returns exactly one package's weight per call — it genuinely doesn't know the heaviest one until it's checked all five.

FAILURE MODES

  • "More loop iterations always means a better answer." An agent without a step budget can loop forever on a task that isn't actually solvable the way it's framed — a runaway loop is a real, common failure mode, not a hypothetical one.
  • "The agent understands the task." It's still predicting the next best step from patterns, one step at a time — see How LLMs Predict Text. It can plan badly, misjudge when it's done, or loop on a mistaken assumption with total confidence.
  • "Agents replace normal software." The tools an agent calls are usually just ordinary, deterministic code — the loop is what's new, not the actions inside it.

DEEP DIVE

  • This pattern has a name: ReAct (Reason + Act) — interleaving reasoning steps with real tool calls, rather than planning everything up front or acting with no reasoning at all. It's the shape almost every modern agent framework builds on.
  • Termination conditions matter as much as the loop itself.A real agent needs an explicit way to decide "done": a success signal, a maximum step count, or a budget on tool calls or tokens — without one, a confused agent just keeps looping.
  • Tool schemas are the actual interface. The model doesn't call your code directly — it's given a description of what tools exist and what arguments they take (this is exactly what the Model Context Protocol standardizes), and it emits a structured request that your system executes and feeds back in.

WHAT I LEARNED

An agent isn't a smarter model — it's the same prediction mechanism wrapped in a loop with real tools and a stopping condition. The intelligence people notice is mostly the loop doing its job: gather information, reassess, and try again, exactly the way a person would.

Go deeper