The Agent Loop

I The Gap

Imagine asking your AI assistant to reschedule your 3pm meeting to tomorrow, check if the conference room is free, and send an updated calendar invite to everyone. Simple enough that you'd trust an intern with it.

A chatbot gives you a well-written paragraph about how you could do those things. An agent actually does them.

II The One-Shot LLM

A standard LLM interaction is one question in, one answer out. The model has no memory, no access to external systems, and no ability to take action.

Three fundamental limitations follow:

1. No access to live data. Anything the model says about current state is either stale or fabricated.
2. No ability to take action. It can only describe actions, not perform them.
3. No way to self-correct. If its first response is wrong, it cannot check or try a different approach.

Try it yourself:

The LLM was articulate, confident, and completely incapable of doing anything. It described actions instead of performingthem — the colleague who replies "great question, here's what I'd do" and then does absolutely nothing. For products that need to interact with the real world, we need to give the LLM a body.

III The Loop

The agent loop transforms an LLM from a one-shot oracle into an iterative problem-solver. Anthropic's engineering team, after shipping Claude Code and working with dozens of production deployments, landed on a core principle: what separates a working agent from a prototype isn't model capability — it's system design. Context management, error handling, and the loop itself matter more than raw intelligence. Four phases, repeated until the task is complete:

1. Think. The LLM examines the current context and reasons about what to do next.
2. Act. The agent executes a concrete action: calling an API, querying a database, running code.
3. Observe.The result comes back — data, an error, a confirmation — and gets fed into the LLM's context.
4. Decide. Is the task done? If yes, deliver the answer. If not, loop back to Think with new information.

Explore the loop in the interactive diagram below:

IV An Agent in Action

Imagine you ask your AI agent: "Find the top 3 bugs by user impact from Sentry, summarize them, and post to #engineering on Slack."

Loop 1 — Gather. The agent queries the Sentry API for recent issues sorted by frequency, getting back 10 issues with titles and error counts.

Loop 2 — Refine.Frequency alone isn't user impact. The agent makes a second call to get unique users affected for the top 5 issues.

Loop 3 — Deliver. It ranks the top 3, writes a markdown summary, and posts it to Slack.

Walk through this scenario step by step:

V When to Use What

Agents are powerful — and slow, expensive, and unpredictable. The engineering equivalent of calling in a specialist when a bandaid would do. It's also worth knowing where agents actually work today: Anthropic's analysis of millions of agent interactions found that roughly 50% of all agentic tool calls are software engineering tasks. Every other domain — BI, customer service, sales, finance — is in the single digits each. Coding dominates because outputs are machine-checkable, tools are already API-first, and a meaningful unit of work fits inside an agent's attention budget. Use the right tier:

VI What's Next

The agent loop is the heartbeat of every AI agent — but it's only as useful as the actions the agent can take. Right now we've been hand-waving about "tool calls" and "API requests." In Part 2, we'll get specific.

You'll learn how tools are defined and exposed to the LLM, how the model decides which tool to call, and the design patterns that make tool use reliable. Anthropic's Barry Zhang puts it bluntly: "Build skills, not agents" — treat each tool as a discrete, testable capability, and let the loop orchestrate them. The loop gives agents their rhythm. Tools give them their reach.