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 Felesh team5 min
The perceive–reason–act loop
How does an agent “think”? The simplest model is a loop that repeats until a goal is reached: perceive, reason and plan, act, then perceive again. During perception, every input — text, image, audio, or raw data — is converted into text the model can parse. The more precise that description, the better the agent reasons. It then decides on a course of action, executes it, observes the result, and the loop continues.
The loop turns every result into the next input: the three seats the agent just found are what it perceives on the next turn.
Reasoning before acting
The most widely used version of this loop is “reason and act,” built from three repeating steps: thought, action, and 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 exact 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.
Before every action the agent writes down why, so the trace keeps the reason right next to the call it led to.
Tools
An agent without tools is just the model alone. Each tool consists of three parts: a name, a description the model reads to decide when to use it, and defined inputs. A precise description matters a great deal; a vague one leads the agent to choose the wrong tool. There is also an operational principle: give the agent only the tools it truly needs, and require human approval for irreversible actions.
A tool is a name, a description and inputs; the model picks by the description, so a vague one gets the wrong tool picked.
Why this makes an agent auditable
There is a quiet benefit in how these pieces fit together. An agent’s capabilities aren’t hidden inside it; they are handed to it explicitly — this exact model, these specific tools, each with a name and a readable description. 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.
An agent's abilities are the list it was handed, so reading that list tells you everything it is able to do.
Combine that with the think-out-loud trace from earlier, and every step becomes inspectable. For each action the agent took, you have its stated reason, the exact tool it called, and the result it observed. You can follow the entire chain after the fact: which tool fired, on what input, and why. An agent built this way isn’t a black box emitting an answer; it is a decision you can audit, step by step.
When to stop
A loop with no stopping condition can spin forever and run up costs. An agent therefore needs clear conditions for halting: when the final answer is ready, when it reaches a hard cap on the number of steps, or when it calls the same tool with the same input repeatedly and is clearly stuck. Defining these exit conditions matters just as much as the loop itself.
One goal, several degrees of autonomy
Not all agents operate with the same independence. At one end is an assistant that only suggests, leaving the human to decide every step. In the middle is an agent that takes a goal, lays out the steps, and asks for approval at key points. At the other end is the fully independent agent — still more of a laboratory thing than something ready for real work. Choosing the degree of autonomy is itself a core part of the design.
The same rebooking at three degrees of autonomy: who decides each step changes, the task does not.
