Standard large language models (LLMs) operate on a simple input-output basis. You give them a prompt, they generate a response. This works well for straightforward tasks like summarising an email or writing a poem. But what about complex, multi-step goals? A single prompt can't handle a request like, "Research the top three competitors for my new coffee shop and compile their marketing strategies into a report."

To tackle these challenges, we need to move from a static prompt-and-response model to a dynamic reasoning loop. This is the core idea behind AI agents. Instead of just generating text, an agent can reason about a goal, create a plan, and take actions to achieve it. It operates in a cycle, continuously thinking, acting, and learning from the results.

One of the most effective architectures for building agents is called ReAct, which stands for "Reason + Act." It's an elegant solution that teaches an LLM to mimic human problem-solving. We don't just jump to a conclusion; we think about a problem, decide on an action, see what happens, and then think about the next step.

The ReAct pattern structures this process into a clear, repeatable loop. For any given task, the agent generates a chain of thoughts and actions until it reaches a final answer. This creates what are known as reasoning traces—a step-by-step log of the agent's internal monologue and decisions.

This loop always follows the same three steps.

1. Thought: The LLM thinks about the overall goal and its current status. It analyzes the problem and decides what the very next step should be.
2. Action: Based on its thought, the agent chooses an action. This is usually a tool call—like searching the web, querying a database, or running a piece of code.
3. Observation: The agent receives the result of its action. This could be a snippet of text from a website, a row from a database, or the output of a calculation. This observation becomes the input for the next thought, and the loop repeats.

ReAct is not the only pattern for agentic reasoning. Another common approach is Plan-and-Execute. In this model, the agent first creates a complete, step-by-step plan to address the entire prompt. Only after the full plan is generated does it begin to execute the steps one by one.

This contrasts with ReAct's dynamic nature, where the agent thinks and acts one step at a time, adjusting its approach based on the observations it gathers. Neither approach is universally better; the choice depends entirely on the task.

Plan-and-Execute excels at predictable tasks, like following a recipe. ReAct is better for unpredictable tasks that require exploration, like debugging code or conducting research. The trade-off is often between the speed and efficiency of a static plan versus the robustness and flexibility of a dynamic loop.

The ReAct model's higher latency and token usage come from its conversational nature. Each turn of the Thought-Action-Observation loop is a separate call to the LLM, and the entire history of the loop is included in the context for each new call. This provides the agent with memory but comes at a computational cost.

Now, let's test your understanding of these concepts.

By understanding these core reasoning patterns, you can start building more sophisticated AI systems that go beyond simple text generation and begin to tackle complex, real-world problems.