Agentic Workflows

Agentic workflows are dynamic, multi-step processes in which autonomous AI agents based on large language models (LLMs) independently make decisions, perform actions, and coordinate tasks with minimal human involvement. In such systems, an LLM is used not only to generate a response to a single query but also to plan a sequence of actions, interact with external tools, and iteratively improve the result.

Unlike traditional automation based on hard-coded rules, agentic approaches are flexible—they can adapt to new data and unforeseen conditions. An agentic workflow differs from a simple LLM call (e.g., for summarizing text) in that the agent is given autonomy to choose its actions, which includes planning, using tools, and self-correction.

Components and architecture of an agentic workflow

An agentic workflow combines several key components to achieve a goal.

AI agent and LLM

The core of the process is the AI agent—an autonomous program acting on behalf of a user or system. The key component of the agent is a large language model, which enables it to understand natural language instructions and generate the necessary reasoning. The agent's performance heavily depends on prompt engineering—various prompting schemes (e.g., Chain-of-Thought) help configure the LLM for the desired mode of operation.

Tools (access to external actions)

Since an LLM's knowledge is limited to its training data, the agent is provided with external tools that extend its capabilities. Tools can include access to knowledge bases, search engines, APIs, code interpreters, and other applications. With their help, the agent can obtain up-to-date information or perform real-world actions outside the model itself.

Memory and context

A distinctive feature of agentic workflows is the presence of a memory mechanism, allowing the agent to consider previous experience and context.

• Short-term memory holds recent information (e.g., conversation history) within the current session.
• Long-term memory stores knowledge and results accumulated over many runs, often using external storage (e.g., vector databases).

Feedback and correction

Feedback mechanisms play a crucial role in enhancing reliability. The agent can receive feedback from the task execution environment, from an auxiliary “critic” model, or from a human (human-in-the-loop mode). For example, the Reflexion system implements internal self-feedback: the agent analyzes its own mistakes and stores “reflections” in memory to improve subsequent attempts.

Multi-agent configurations

In complex scenarios, a multi-agent architecture is employed, where several specialized agents interact with each other. For example, a “planner” agent sets subtasks, while several “executor” agents solve their specific tasks (data retrieval, computation, etc.).

Common patterns and agent algorithms

Although a universally standardized architecture for agentic LLM systems has not yet been developed, recurring patterns began to emerge in 2023–2024.

• Step-by-step planning (Prompt Chaining). The task is broken down into a sequence of stages using a chain of LLM calls. Each step takes the output of the previous one as input and performs part of the overall task. This approach improves interpretability but is less flexible.
• Routing and tool selection (Router Pattern). The agent first classifies the type of input task and then selects a specialized process or tool to solve it, acting as a dispatcher.
• Parallel solution search. Instead of a single linear line of thought, several solution options are explored simultaneously. An example is the Tree-of-Thoughts approach, where the agent branches its chain of reasoning like a tree, generating several candidate “thoughts” at each step and selecting the most promising ones.
• Reflection and self-correction. The agent critically evaluates its own decisions and learns from its mistakes. In the Reflexion method, after each attempt, the agent analyzes the result and saves conclusions that it uses in subsequent cycles.

Examples of well-known approaches

• ReAct (Reasoning and Acting) — a foundational method (2022) that combines reasoning and action. The LLM interleaves the generation of logical conclusions (thoughts) and specific action steps (actions), which are executed using tools.
• Reflexion (2023) — a self-reflection framework that allows agents to learn from their own mistakes through textual feedback, without updating the model's weights.
• Tree-of-Thoughts (ToT) (2023) — a framework that generalizes the Chain-of-Thought idea to organize solution-finding as a tree, allowing the model to consider multiple possible paths.
• Auto-GPT (2023) — one of the first widely known open-source projects demonstrating a fully autonomous agentic workflow. The system generates a group of specialized GPT-4 agents that collaboratively plan and execute steps to achieve a high-level goal set by the user.

Application and impact

Agentic approaches are being applied in numerous fields that require intelligent automation and flexibility.

• Business processes: Agentic systems expand the capabilities of technical support chatbots, which can independently diagnose problems and find solutions. They are also used in finance, human resources, and marketing.
• Generative simulations: Autonomous LLM agents can model complex behaviors of communities or characters. In the paper “Generative Agents” (Park et al., 2023), dozens of GPT agents with different personalities plausibly simulated social life in a modeled town.

According to Gartner analysts, Agentic AI is included among the strategic technology trends for 2025.

Challenges and future directions

Despite their successes, agentic LLM systems remain a new and complex technology.

• Resource costs: Each additional step of planning, searching, or self-analysis is a separate LLM call, which increases execution time and cost.
• Unpredictable behavior: The more freedom an agent has, the harder it is to guarantee which path it will take. This requires implementing constraints and protective mechanisms (guardrails).
• Quality assessment and debugging: Analyzing extensive logs from multi-step systems to find errors is a non-trivial task.
• Security and ethics: As AI autonomy increases, it becomes necessary to ensure that agents act in the best interests of the user and society.

Future research is aimed at creating universal means of using tools, developing unified end-to-end workflows, and optimizing the efficiency of agentic systems.

Links

• Overview of Agentic Workflows from IBM
• Guide to building effective AI agents from Anthropic

Literature

• Yao, S. et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629.
• Schick, T. et al. (2023). Toolformer: Language Models Can Teach Themselves to Use Tools. arXiv:2302.04761.
• Liu, X. et al. (2023). AgentBench: Evaluating LLMs as Agents. arXiv:2308.03688.
• Yao, S. et al. (2023). Tree of Thoughts: Deliberate Problem Solving with Large Language Models. arXiv:2305.10601.
• Shinn, N. et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. arXiv:2303.11366.
• Park, J. S. et al. (2023). Generative Agents: Interactive Simulacra of Human Behavior. arXiv:2304.03442.
• Wang, G. et al. (2023). Voyager: An Open-Ended Embodied Agent with Large Language Models. arXiv:2305.16291.
• Bakhtin, A. et al. (2022). Human-Level Play in the Game of Diplomacy by Combining Language Models with Strategic Reasoning. Science. DOI:10.1126/science.ade9097.
• Wang, L. et al. (2025). A Survey on Large Language Model based Autonomous Agents. arXiv:2308.11432.
• Li, X. (2024). A Survey on LLM-Based Agentic Workflows and LLM-Profiled Components. arXiv:2406.05804.
• Jung, J. et al. (2024). Trust or Escalate: LLM Judges with Provable Guarantees for Human Agreement. arXiv:2407.18370.
• Xu, W. et al. (2025). A-MEM: Agentic Memory for LLM Agents. arXiv:2502.12110.
• He, G. et al. (2025). Plan-Then-Execute: An Empirical Study of User Trust and Team Performance When Using LLM Agents as a Daily Assistant. arXiv:2502.01390.
• Huang, X. et al. (2024). Understanding the Planning of LLM Agents: A Survey. arXiv:2402.02716.
• Kuang, Z. et al. (2023). PEARL: Prompting Large Language Models to Plan and Execute Reasoning over Long Documents. arXiv:2305.14564.