How an AI agent thinks

An agent takes a goal, reasons, acts, and observes the result — repeating that loop until it's done. A simple mental model for how agents reason and decide.

The perceive–reason–act loop

How does an agent “think”? The simplest picture is a loop that repeats until the goal is reached: perceive, then reason and plan, then act, then perceive again. In perception, every input — text, image, audio, or data — is turned into text the model can understand; the more precise that description, the better the agent reasons. The agent then decides what to do, takes an action, observes the result, and continues the loop.

Reasoning before acting

The most widely used version of this loop is called “reason and act,” and it is built from three repeating steps: thought, action, observation. In the thought step, the agent asks itself “what should I do now?” and reasons step by step. In the action step, it calls a specific tool with specific inputs. In the observation step, it reads the result. Then it thinks again. The key insight is that forcing the agent to “think out loud” before acting leads to better decisions.

Tools

An agent without tools is just the model alone. Each tool has three parts: a name, a description that the model reads to decide when to use it, and defined inputs. A precise description matters a great deal; a vague one makes the agent pick the wrong tool. There’s also an important principle: give the agent only the tools it truly needs, and require human approval for irreversible actions.

Why this makes an agent auditable

There’s a quiet benefit in how these pieces fit together. An agent’s capabilities aren’t hidden inside it; they’re handed to it openly — this exact model, these specific tools, each with a name and a description you can read. So you can see at a glance everything an agent is able to do, simply by looking at what it was given. Nothing reaches for a capability in secret.

Put that next to the think-out-loud trace from earlier, and every step becomes inspectable. For each action the agent took, you have its stated reason (“what should I do now?”), the exact tool it called, and the result it saw. You can follow the whole chain after the fact — which tool fired, on what input, and why. An agent built this way isn’t a black box that emits an answer; it’s a decision you can audit, step by step.

When to stop

A loop with no stopping condition can spin forever and run up a cost. So an agent needs clear conditions for halting: when the final answer is ready, when it has reached a cap on the number of steps, or when it calls the same tool with the same input several times in a row and is clearly stuck. Defining these conditions matters as much as the loop itself.

One goal, several degrees of autonomy

Not all agents are equally independent. At one end, an assistant that only suggests, while the human decides every step. In the middle, an agent that takes a goal, lays out the steps, and asks for approval at key points. At the other end, a fully independent agent — still more of a laboratory thing than something ready for real work. Choosing the degree of autonomy is itself part of the design.