From Passive LLMs to Autonomous Agents: The Evolution of AI Workflows

Level 1: The Passive LLM (Large Language Model)

The most familiar form of AI today includes applications like ChatGPT, Claude, and Gemini, which are built on Large Language Models (LLMs). These systems are excellent at generating and editing text based on their vast training data.

However, Level 1 systems have two primary limitations:

• Knowledge Boundaries: Their knowledge is limited to their training data and does not include private or real-time information, such as a user's personal calendar or specific company databases.

• Passive Nature: They are passive systems, meaning they remain idle until a human provides a prompt.

Level 2: AI Workflows and Retrieval-Augmented Generation (RAG)

To overcome the limitations of passive LLMs, developers create AI Workflows. In this stage, the AI is integrated with external tools and follow a specific path defined by human "Control Logic".

The Role of RAG

A key technical component of Level 2 is RAG (Retrieval-Augmented Generation). This process allows the AI to search for information from external sources—like a Google Calendar or a specific API—before generating a response.

Human-Defined Paths

In an AI workflow, a human defines every step of the process. For example, a marketing workflow might involve:

1. Collecting product links in a Google Sheet.

2. Summarizing those products using a tool like Perplexity.

3. Generating social media posts via an OpenAI prompt.

4. Scheduling the posts to go live at a set time.

While efficient, the human remains the decision-maker. If the output is unsatisfactory, the human must manually adjust the prompts or the logic.

Level 3: AI Agents and the ReAct Framework

The transition to an AI Agent occurs when the LLM replaces the human as the primary decision-maker within the workflow. Instead of following a rigid path, the agent is given a high-level goal and must determine the best way to achieve it.

The ReAct Framework: Reasoning + Acting

Most AI agents operate using the ReAct framework, which stands for Reasoning and Acting.

• Reasoning: The agent analyzes the task and "thinks" about the most efficient strategy. It asks questions like, "Should I use a Word document or an Excel sheet for this data?".

• Acting: The agent takes action by using tools (APIs, databases, software) based on its reasoning.

Iteration and Self-Critique

A defining feature of AI agents is their ability to perform iterations. An agent can review its own output, compare it against "best practices," and repeat the process until it reaches an optimal result without human intervention.

Summary: Key Differences

The shift toward AI agents represents a move from AI as a tool to AI as a collaborator, capable of navigating complex tasks with minimal human oversight.

How to concretely implement the ReAct framework

To concretely implement the ReAct framework, you must transition from a human-led workflow to an LLM-led autonomous process where the AI handles both the strategy and the execution. Based on the sources, the implementation follows these core steps:

1. Define the Primary Goal and Tools

Instead of programming a fixed step-by-step path (Control Logic), you provide the agent with a high-level goal and a set of available tools (such as APIs, Google Sheets, or search tools). The agent must be connected to these tools—for example, linking a user's Google account to the system—so it can choose which one to use.

2. Enable the "Reasoning" Phase

The first part of the ReAct logic is Reasoning. The agent does not act immediately; it analyzes the goal to determine the most efficient strategy.

• Implementation logic: The LLM asks itself questions like, "What is the best way to collect these articles?" or "Should I use a Word document or a Google Sheet for this specific task?". It evaluates the options based on the tools you have provided.

3. Execute the "Acting" Phase

Once a strategy is formed, the agent moves to Acting. It uses the tools to perform a specific task, such as fetching data from a URL or summarizing an article. This step produces a temporary result.

4. Build in an Iteration and Evaluation Loop

A key technical requirement for a true AI agent is the ability to perform iterations.

• Self-Critique: You implement a step where the agent reviews its own output. For instance, the agent can use another instance of an LLM to check if the generated content meets "best practices" or specific criteria.

• Decision Making: After evaluating the temporary result, the LLM decides whether it needs to repeat the cycle (Reason + Act) to improve the result or if it is ready to deliver the final output.

Summary of the Implementation Logic:

• Input: User provides a high-level goal.

• Reasoning: The LLM plans the steps and selects tools.

• Acting: The LLM executes the steps using tools.

• Evaluation: The system reviews the outcome against the goal.

• Output: The process repeats until the LLM determines the goal is fully met.

In this framework, the LLM is the decision-maker throughout the entire workflow, replacing the need for a human to manually adjust prompts or fix errors between steps.