So far, you've likely interacted with large language models (LLMs) through single prompts. You ask a question, and you get an answer. It's a simple, one-off transaction. Agentic AI, however, operates on a completely different principle: a continuous loop. Instead of just answering, an agent observes its environment, thinks about what to do next, takes an action, and then observes the result of that action. This cycle repeats until a goal is achieved.

This thinking-acting-observing cycle is the engine of an autonomous agent. It transforms the LLM from a static knowledge base into a dynamic problem-solver that can interact with software, APIs, or other data sources to get things done. One of the most influential frameworks for structuring this cycle is called ReAct

ReAct, which stands for "Reason + Act," provides a simple yet powerful structure for this loop. It prompts the model to explicitly separate its internal monologue from its external actions. At each step, the model first generates a "Thought"—a piece of reasoning that explains its current understanding of the problem and what it plans to do next. Then, it generates an "Action"—a specific, executable command, like querying a search engine or accessing a database.

The system executes the action, gets a result (an "Observation"), and feeds that result back into the loop as context for the next thought. This interleaving of reasoning and acting is what makes the agent seem intelligent. It's not just guessing; it's forming a hypothesis (Thought), testing it (Action), and analysing the results (Observation) before deciding on its next move. This is a profound shift from simply generating text to performing tasks.

The reasoning part of the ReAct loop often relies on a technique you might already know: Chain-of-Thought (CoT) prompting. In a standard LLM interaction, CoT helps the model break down a complex problem into steps to arrive at a better final answer. In an agent, CoT becomes its internal monologue, the narrative that connects each step in the reasoning loop.

Instead of a one-time reasoning chain, the agent produces a new snippet of thought at every turn. For example, if a user asks, "What was the weather like in London on the day the first Harry Potter book was published?", the agent's loop might look like this:

1. Thought: I need to find the publication date of the first Harry Potter book.
2. Action: search("first Harry Potter book publication date")
3. Observation: June 26, 1997.
4. Thought: Now I have the date. I need to find the weather in London on June 26, 1997.
5. Action: weather_api(city="London", date="1997-06-26")
6. Observation: Partly cloudy, high of 22°C.
7. Thought: I have all the information. I can now answer the user's question.
8. Action: finish("The weather in London on June 26, 1997, when the first Harry Potter book was published, was partly cloudy with a high of 22°C.")

Each thought builds on the previous observation, creating a coherent, step-by-step plan.

For this loop to work, the agent must maintain context, or state. It needs to remember the original goal, what it has already tried, and what it has learned from previous observations. This is known as state management.

The history of thoughts, actions, and observations forms a running log or 'scratchpad'. At each new step, the LLM is given this entire history along with the original prompt. This allows it to make informed decisions based on the full context of the task so far.

This process of iterative refinement is crucial. The agent doesn't need to know the entire solution from the start. It just needs to know the best next step. By breaking a complex problem down into a series of small, manageable think-act-observe cycles, an agent can tackle tasks that would be impossible to solve with a single prompt.

This cyclical approach of reasoning, acting, and observing is fundamental to how modern AI agents operate, turning them from simple text generators into powerful, autonomous tools.