How AI Agents Are Classified and Built: From Reactive to Planning Modes

AI Agent Classification Overview

Previous articles referenced:

AI Intelligent Agent Core Principles: From Agentic AI to AI Agent

AI Agent Software Engineering Key Technologies Overview

Classification by Autonomy Level

Agents are distinguished by whether they possess iterative capabilities:

Low Autonomy : The agent cannot iterate; it behaves like a router handling a single task at a time. Human input is required for subsequent steps. Example: Function Call Agent.

High Autonomy : The agent can iterate, plan, decide, act, and self‑adjust based on goals. Human involvement is limited to providing the goal and reviewing results. Example: ReAct Agent.

The key difference between ReAct and Function Call agents is the presence of self‑observation and self‑optimization, which are essential for iterative loops.

Classification by Capability Requirements

Beyond autonomy, agents are evaluated on four core capabilities:

Reasoning and planning ability

Domain knowledge ability

Tool execution ability

Feedback and iteration ability

Classification by Iteration Style

High‑autonomy agents mainly adopt two iteration types:

Reactive Iteration : The agent alternates between reasoning (Think) and action (Act) within a single loop, adjusting dynamically based on real‑time feedback. Steps include Think → Act → Observe → Loop.

Think: Define the current sub‑task.

Act: Execute an action such as calling an API.

Observe: Capture the result of the action.

Loop: Re‑think based on the observation and continue until the task is complete.

Planning Iteration : The agent first creates a complete plan (a list of steps) and then executes it, typically without changing the plan during execution. Steps include Plan → Execute → (optional) Re‑plan.

In practice, ReAct and Planning are often combined in a Planner‑Actor or Planning‑ReAct mode.

Classification by Number of Agents

Agents can be single‑agent or multi‑agent systems.

Classification by Development Mode

The following development modes are commonly used:

Reflection Mode : Self‑reflection and iterative optimization before output. Typical scenarios: content creation, academic reasoning. Key technology: generative LLM + reflection module.

Tool Mode : Integration of external tools or APIs to extend LLM capabilities. Typical scenarios: real‑time data queries, code execution. Key technologies: toolset module, function‑call API, MCP protocol.

ReAct Mode : Agile, reactive loops that adapt to environment changes. Typical scenarios: robot control, customer‑service ticket handling. Key technologies: reasoning LLM, toolset, execution module, memory and reflection modules.

Planning Mode : Decompose complex, multi‑step tasks into a structured TODO list, then execute each sub‑task, often using ReAct for individual steps. Typical scenarios: project management, long‑term workflows. Key technologies: planner + ReAct.

Multi‑Agent Mode : Multiple specialized agents collaborate via shared memory and A2A protocols. Typical scenarios: cross‑domain software development, medical consultations. Key technologies: role‑based agents, shared memory, delegation mechanisms.

Reflection Mode Details

Application scenarios include creative writing and complex problem solving. The core process involves receiving a user request, generating an initial output, using a reflection module to critique and improve the output, iterating until the output passes validation, and finally returning the response. Advantages stem from self‑reflection and metacognition, improving logic and accuracy.

Tool Mode Details

Used when the agent needs to call external services such as flight‑price APIs or financial data sources. The core workflow is: receive request → decide whether a tool is needed → select appropriate tool(s) → execute tool calls → integrate results with LLM reasoning → return final response. This mode expands the agent’s functional boundary.

ReAct Mode Details

Suited for tasks requiring step‑by‑step reasoning and immediate action, such as robot navigation or dynamic customer support. The loop consists of reasoning, tool calling, result storage, reflection, and final response generation. Real‑time adaptability is the main advantage.

Planning Mode Details

Ideal for long‑duration, multi‑stage tasks like travel planning. The planner first generates a TODO list, then the agent executes each sub‑task (often via ReAct), validates results, and iterates if necessary before aggregating all outcomes into a final response.

Multi‑Agent Mode Details

Agents assume specific roles (e.g., project manager, tech lead, DevOps, developer) and collaborate through delegation, shared memory, and A2A protocols. The project‑manager agent orchestrates task distribution, integrates results, and delivers the final output. This specialization improves efficiency and overcomes single‑agent limitations.

General Functional Modules for AI Agents

LLM selector and connector

Planner and iterative planner

Action module (function‑call, tool‑call, toolset)

Context processor (optimization and compression)

Memory module (short‑term, long‑term, compression)

Execution environment (sandbox, VM)

Product Forms and Their Core Modules

General Agent

High autonomy, high capability, ReAct mode, multi‑agent architecture. Core is goal‑directed reactive iteration (Observe → Reason → Act → Summarize).

DeepResearch Agent

Low autonomy, high capability, Planning mode, single‑agent. Emphasizes information gathering, classification, and summarization using a reference searcher.

Self‑Evolving Agent

High autonomy, high capability, combined Planning‑ReAct mode, single‑agent. Focuses on iterative self‑improvement and exploring unknown domains.

Workflow Agent

Low autonomy, high capability, Tool mode. Executes predefined, structured business processes with reliable, repeatable steps.

Key Challenges in Deploying AI Agents

1. Injecting Private Knowledge and Logical Chains

LLMs lack internal private‑domain knowledge, leading to poor understanding of enterprise contexts. Solutions include Retrieval‑Augmented Generation (RAG), chain‑of‑thought (COT) prompts describing logical relations, and fine‑tuning LLMs.

2. Ensuring Trustworthy Planning, Interpretability, and Error Propagation in Multi‑Agent Systems

Challenges stem from hallucinations, opaque reasoning, and error amplification across agents. Solutions comprise programmatic prompt engineering, reflection and self‑critique modules, comprehensive logging and audit trails, human checkpoints, layered memory architectures, fact‑checking against standards, role‑based orchestration, and enterprise data‑governance.