A standard Large Language Model (LLM) takes a prompt and produces an output. It's a one-shot process. An AI agent, however, does something more sophisticated. Instead of just answering, it operates in a continuous loop, figuring out how to solve a problem step-by-step. This is where agentic reasoning loops come into play.

The most common architecture for this is called ReAct, which stands for Reason and Act. It’s a simple but powerful idea. The agent receives a goal, and instead of trying to solve it all at once, it generates a 'thought' about what it should do first. Based on that thought, it performs an 'action,' like searching a database or calling an API. Then, it makes an 'observation' of the result. This cycle—thought, action, observation—repeats until the goal is achieved.

Let's break down the cycle:

1. Thought: The agent internalises the goal and the current state. It thinks, "What is the next logical step I need to take to solve this?" This is a private monologue where the LLM reasons about strategy.
2. Action: Based on the thought, the agent chooses a tool and uses it. This could be search('latest financial news') or calculate(345 * 1.15). The action is a concrete, executable step.
3. Observation: The agent receives the output from its action. This might be a snippet of text from a web search, a number from a calculation, or an error message if the tool failed. This new information feeds back into the loop, informing the next thought.

This iterative process is tracked in what's called an agent's scratchpad. Think of it as the agent's internal notebook or working memory. It's a running log of the thoughts, actions, and observations, allowing the agent to maintain context and follow a chain of logic. Without it, the agent would be stateless, forgetting what it just did in the previous step.

A crucial part of the reasoning loop is the ability to terminate autonomously. The agent doesn't loop forever. In each thought step, it evaluates whether it has successfully completed the original goal.

In the example above, after finding the population of Paris, the agent's thought process concluded it had all the necessary information. It then chose a special action, often called finish or return, providing the final, synthesized answer and ending the loop. This self-assessment is what makes agents autonomous.

ReAct isn't the only way for an agent to tackle a problem. Another common approach is the Plan-and-Execute pattern. Here, the agent first creates a complete, step-by-step plan to solve the entire problem. Only after the plan is fully laid out does it begin to execute each step, one by one.

This is like creating a detailed recipe before you start cooking, whereas ReAct is more like tasting and adjusting as you go. Each approach has distinct advantages and disadvantages depending on the task.

The choice between ReAct and Plan-and-Execute involves a trade-off. ReAct is fantastic for dynamic environments where things might change mid-task. If a web link is broken or an API returns an unexpected result, a ReAct agent can observe the failure, think about a new approach, and try again. A Plan-and-Execute agent would likely fail because its rigid plan didn't account for the error.

However, Plan-and-Execute can be much more efficient for predictable, multi-step tasks. It requires fewer calls to the LLM, which can save time and computational cost. The key is to match the agent's reasoning pattern to the nature of the problem it's designed to solve.