Chapter 02 · Intuition

What is an agent, really?

An LLM by itself is a function: text in, text out. An agent is what you get when you put that function inside a while-loop, give it a list of buttons it can press, and let it decide when to stop.

The simplest possible definition

Forget frameworks for a minute. An agent is three things:

An LLM that can produce structured output (specifically: "call tool X with args Y" or "final answer: Z").
A set of tools — Python functions the runtime knows how to execute when the LLM asks.
A loop that runs LLM → maybe-tool → LLM → maybe-tool → … until the LLM stops asking for tools.

That's it. The entire industry of "agentic AI" is variations on those three pieces. LangChain doesn't invent anything new here — it makes those pieces composable, observable, and production-ready.

A 30-second mental model

Imagine you hire a smart intern who has never been to your office. You give them:

A job description ("you help customers with refund questions") — that's the system prompt.
A list of internal tools they can use ("the order DB query tool, the Stripe refund tool") — that's tool binding.
A customer's question — that's the user message.
A scratchpad where they write down what they did and saw — that's the message history.

The intern reads everything in front of them, decides on their next action, performs it (or hands the answer back), updates the scratchpad, and reads everything again. They have no memory between turns except what's on the scratchpad. That is exactly how a LangChain agent works.

This is the most important sentence on this page. The model has no hidden memory of what it did two seconds ago — every loop iteration sends the entire growing message list back to the API. If a piece of information isn't in the messages, the agent doesn't know it. Why a loop instead of one prompt?

You could try to write one giant prompt: "Search the web for X, then summarize, then email it to me." A few problems:

The model would have to guess the search results — it can't actually run the search.
If the first action fails (bad URL, empty result), there's no place to recover.
The branching is fixed at prompt-write time, not at runtime.

The loop fixes all three. The LLM produces one decision at a time. Between decisions, the runtime runs real code. After each tool result comes back, the LLM gets to re-plan with new information. That's the whole game.

Where this breaks (and we'll fix later) If the model never decides to stop, you'll burn tokens and money. We set a max_iterations cap and a wall-clock timeout. (Chapter 7.) Network errors, rate limits, bad arguments. The executor catches exceptions and feeds them back as tool messages so the LLM can self-correct — but only if you wire it up. (Chapter 7.) Every loop iteration sends the entire message history. By turn 10, you're sending the prompt + 9 tool results + 9 thoughts every call. We'll cover trimming and summarization. (Chapter 10.) Next chapter zooms into the smallest unit — messages — because everything in LangChain is, at the wire level, just a list of messages.