LLM-based AI Agent Model

• LLM-based AI agent model is an intelligent system that integrates large language models with planning, memory, and tool-use components to achieve autonomous, goal-directed behavior.
• It distinguishes itself from traditional, task-specific agents by leveraging pre-trained language capabilities for chain-of-thought reasoning, zero-shot generalization, and adaptive self-reflection.
• The model's architecture supports diverse applications—from chatbots and web agents to multi-agent systems—by embedding decision-making frameworks, external tools, and robust memory mechanisms.

An LLM-based AI agent model is an intelligent agent whose “brain” is a LLM, supported by core components for planning, memory, and tool use, and situated in an environment or application loop that allows it to perceive, reason, act, and update state over time (Zhao et al., 2023). In later architectural treatments, the LLM is not identified with the agent itself: the agent is instead a goal-directed autonomous entity formed by systematically integrating one or more LLMs with decision-making frameworks, perception modules, memory or retrieval mechanisms, tool-use capabilities, guardrails, and action execution modules (2505.16120). Across surveys, systems papers, and evaluation frameworks, the model appears in single-agent, multi-agent, service-oriented, model-based, and multimodal forms, but its common structure remains an LLM-centered control architecture rather than a standalone text generator (Zhao et al., 2023).

1. Conceptual foundations and distinction from earlier agents

The basic contrast with traditional AI agents is drawn along several recurring axes. Traditional agents are usually task-specific, using predetermined algorithms, rules, or reinforcement-learning policies for narrow environments such as game playing or robot navigation. LLM-based agents inherit broad priors from pretraining on large corpora, enabling generalization across tasks and domains with minimal or no task-specific training; they also exhibit emergent abilities such as chain-of-thought reasoning and zero-shot generalization, which allow them to decompose tasks verbally, reflect on mistakes, and adjust plans using natural-language feedback (Zhao et al., 2023). Knowledge storage also changes form: traditional agents rely on hand-coded rules, learned policies and value functions, or structured knowledge bases, whereas LLM-based agents store massive world, commonsense, and semantic knowledge in parameters and then extend that parametric “training memory” with external memories (Zhao et al., 2023).

A second foundational distinction concerns what counts as the agent. In the system-level formulation used for industrial applications, an AI model is a functional component that performs pattern recognition or data transformation, while an AI agent is a full architecture that perceives its environment, reasons and decides using cognitive functions, and acts autonomously to pursue goals in an environment (2505.16120). A common misconception is therefore that the LLM alone is the agent. In the architectural literature, the LLM is instead the cognitive core or reasoning engine inside a larger autonomous system, and the defining properties of the agent are autonomy, environmental coupling, and goal-oriented behavior rather than text generation alone (2505.16120).

This reframing has practical consequences. Once the LLM is treated as one component among others, it becomes possible to distinguish agent capabilities that arise from parametric knowledge, prompt-level context, retrieval, external tools, safety layers, and execution interfaces. This suggests that the field’s central modeling problem is not merely scaling the LLM, but specifying how the model is embedded in a decision loop and how responsibilities are partitioned across modules.

2. Core architectural components

The canonical decomposition organizes the model around three core components—planning, memory, and tool use—with the LLM as the central decision and reasoning engine (Zhao et al., 2023). Planning designs sequences of actions that transition states to achieve goals. In LLM-based agents this includes task decomposition through Chain-of-Thought, Tree-of-Thought, or translation from natural language into classical planning formalisms such as PDDL, and it also includes self-reflection mechanisms that revise plans based on environmental feedback (Zhao et al., 2023). Representative methods include ReAct, which interleaves reasoning and actions; Reflexion, which adds actor, evaluator, and self-reflection modules with memory; human-feedback-based reflection; program-like planning with assertions in ProgPrompt; adaptive refiners in AdaPlanner; and retrospective critics such as Retroformer (Zhao et al., 2023). In operational terms, planning and self-reflection form a feedback loop:

Plan → Act → Observe → Reflect (LLM) → Update Plan

Memory is treated as a central design axis and is redefined for LLM-based agents into training memory, short-term memory, and long-term memory (Zhao et al., 2023). Training memory is the knowledge and facts learned during pre-training and stored in model parameters. Short-term memory is temporary information processed during task execution and LLM inference, including in-context examples, intermediate reasoning steps, and prompt-local working memory. Long-term memory is persistent information stored in external systems such as databases, vector stores, or logs, and it is explicitly organized as a three-step pipeline of information storage, information retrieval, and information updating (Zhao et al., 2023). This taxonomy differs from traditional human-memory taxonomies by separating parametric knowledge from external storage and by excluding sensory memory from the explicit memory module, treating it instead as input embeddings (Zhao et al., 2023). In the industry-oriented architectural view, this same function is often implemented through Retrieval-Augmented Generation, which grounds outputs in external documents, knowledge bases, past interactions, and logs (2505.16120).

Tool use is the third canonical component. It is motivated by persistent weaknesses of LLMs on up-to-date information, precise computation, and domain-specific operations, and it extends the agent by allowing external tool calls to APIs, search engines, calculators, databases, or specialized models (Zhao et al., 2023). The basic pattern is stable: the LLM interprets the request, decides whether a tool is needed, formats a tool call, receives the result, and integrates that result into further reasoning or a final answer (Zhao et al., 2023). Representative designs include single-tool augmentations, MRKL’s adapter-and-expert architecture, self-play tool learning, API-Bank and tool-augmented evaluation, fine-tuned API invocation, interleaved reasoning and tool calls in ART, orchestration of models as tools in HuggingGPT and Chameleon, and tool generation by the LLM itself when the required tool does not yet exist (Zhao et al., 2023).

Taken together, these components define the minimal internal anatomy of the model. Planning governs action selection, memory determines what information remains available across steps and episodes, and tool use extends the agent beyond the LLM’s internal competence. Their joint design largely determines whether the resulting system behaves as a reactive prompt wrapper or as a robust autonomous agent.

3. Decision loops, state representations, and planning paradigms

Although survey papers do not present a single monolithic equation for the entire agent, they do describe a recurring closed-loop workflow. The loop begins with perception or input encoding, where environment state or user request is converted into text or multimodal embeddings. It then performs context and memory retrieval, combining current dialogue, in-context examples, and long-term retrieved items. Next comes planning and reasoning in the LLM, possibly including decomposition into subtasks and tool selection. The agent then performs tool invocation if needed, executes actions in the environment, gathers observation and feedback, and finally updates short-term and long-term memory before repeating the cycle (Zhao et al., 2023). In industrial architectural terms, the same pattern is described as a Task Input → Context Augmentation → Decision and Planning Phase → Output Guardrail Mechanism → Action Execution loop, followed by iterative feedback (2505.16120).

Recent planning analyses make this loop more explicit by mapping current web-agent architectures to classical search paradigms. Step-by-Step agents are treated as analogous to Breadth-First Search, since they repeatedly inspect the current state and select a single next action with horizon $d = 1$. Tree Search agents correspond to Best-First Tree Search, maintaining an explicit search tree and selecting frontier states according to a value estimate $V(s)$. Full-Plan-in-Advance agents correspond to Depth-First Search, because they produce a complete action sequence $\tau = (a_1, a_2, \dots, a_n)$ from the initial state and then attempt to execute that branch with limited re-evaluation (Shahnovsky et al., 13 Mar 2026). This reframing makes failures such as context drift, incoherent task decomposition, or local myopia legible as planning failures rather than generic “LLM errors” (Shahnovsky et al., 13 Mar 2026).

The same planning-theoretic perspective also clarifies representation choices. In web agents, the state is often not a raw screenshot but an accessibility tree or related structured browser state; the action space is a finite set of browser operations such as click, type, hover, scroll, navigation, tab management, and stop with answer (Shahnovsky et al., 13 Mar 2026). This suggests that many contemporary agent models are already implicit planners over structured state-action spaces, even when their architecture is described primarily in prompt-engineering terms.

4. Architectural variants and formalized agent models

One major line of development externalizes capabilities that are often hidden inside a single LLM. CACA Agent is explicitly designed to avoid putting “everything inside one LLM” and instead decomposes the system into collaborative capabilities organized around an open service-computing architecture (Xu et al., 2024). Its major modules are Reception Capability, Workflow Capability, Planning Capability, Methodology Capability, Profile Capability, Tool Capability, Tool Broker, and Tool Service (Xu et al., 2024). Planning is formalized as

$$PlanCap(Task, Methodology) \rightarrow [\text{Proc}(ST_1), \ldots, \text{Proc}(ST_n)]$$

with each process element decomposed as

$$\text{Proc}(ST_i) : (\text{Execute}(ST_i), \text{Branch}(ST_i), \text{Loop}(ST_i)).$$

Tool discovery is also formalized as

$$\{T_{\text{selected}}, T_{\text{param}[\text{input}]}\} = \text{DiscoverTool}(U_{\text{req}}, \{T_{\text{registered}}\}).$$

This architecture externalizes process knowledge through Methodology Capability and manages tools through a Registration–Discovery–Invocation pattern, thereby reducing dependence on any single LLM and supporting extensibility of both planning and tools (Xu et al., 2024).

A second line of work replaces purely autoregressive reasoning with explicit world models. WorldCoder is a model-based LLM agent in which the LLM writes a Python program representing the transition and reward structure of the environment, and a conventional planner then executes on that learned model (Tang et al., 2024). The model is constrained by a data-fit condition over observed tuples and an optimism condition that requires the learned program to admit a rewarding path from the current initial state, yielding higher sample efficiency than deep RL, greater compute efficiency than ReAct-style agents, and transfer across environments by editing code (Tang et al., 2024). SimuRA moves the same idea into a natural-language latent space: it introduces an LLM-based world model for simulation over textual belief states and simulated high-level actions, and on difficult web browsing tasks it raises flight-search success from $0\%$ to $32.2\%$, with world-model-based planning showing up to $124\%$ advantage over autoregressive planning (Deng et al., 31 Jul 2025). This suggests a shift from “LLM as one-step policy” toward “LLM as world model, planner, critic, and actor in a structured internal loop.”

A third line develops multi-agent specialization. In software engineering, ALMAS aligns specialized LLM agents with agile roles such as Sprint Agent, Supervisor Agent, Summary Agent, Control Agent, Developer or Code Agent, and Peer Agent, covering requirements, planning, localization, implementation, testing, review, and maintenance across the SDLC (Tawosi et al., 3 Oct 2025). In ethical software development, LLM-BMAS uses three role-specialized agents—two senior Python developers and one AI ethicist—engaged in structured multi-round discussions, with source code and documentation generated across repeated rounds (Cerqueira et al., 2024). In legal adjudication, L4M combines prosecutor-aligned and defense-aligned LLM agents, an autoformalizer, a judge LLM, and an SMT solver to produce solver-validated verdicts and sentences (Chen et al., 26 Nov 2025). In AI-mediated communication, the Intersubjective Model uses a paired architecture in which each human interacts with an LLM-based agent that represents the other human; each agent has Extraction and Conversation modules, and the two agents exchange abstracted information rather than raw messages (Aoyama et al., 25 Feb 2025). These systems indicate that “the” LLM-based AI agent model now includes not only single-agent architectures but also distributed role-based assemblies.

5. Application domains and representative instantiations

Survey literature identifies a broad application taxonomy built on the common core of planning, memory, and tool use. Representative domains include chatbots, games and embodied environments, coding and design, scientific research, collaboration or multi-agent systems, general-purpose autonomous agents, and vision-language agentic systems (Zhao et al., 2023). Representative systems include Pi for emotionally oriented companionship; Voyager as a GPT-4-powered Minecraft agent with a reusable skill library and in-context lifelong learning; GPT Engineer for code-generation workflows; Diagram for AI-assisted design; ChemCrow for chemistry with 17 tools integrated with GPT-4; Agent for autonomous experimental design and execution; DialOp, MindOS, MetaGPT, and Multi-GPT for collaborative settings; Generative Agents for simulating a town of 25 agents; and general-purpose autonomous frameworks such as Auto-GPT, BabyAGI, SuperAGI, and AgentGPT (Zhao et al., 2023).

Industrial surveys further organize these systems by environment coupling into software-based agents, physical agents, and adaptive and hybrid agents (2505.16120). Software-based agents operate entirely in digital environments and appear in customer service, software development, and financial trading. Physical agents combine LLM reasoning with sensors and actuators for settings such as manufacturing automation. Adaptive and hybrid agents combine digital and physical actions in healthcare assistants, predictive maintenance, traffic management, supply-chain management, and personalized education (2505.16120). This framing broadens the model beyond chat interfaces and places LLM-based agents within enterprise workflows, cyber-physical systems, and regulated domains.

Several domain-specific systems illustrate how the model specializes. EEschematic is a multimodal LLM-based AI agent for analog circuit schematic generation that translates SPICE netlists into JSON-based schematic representations and rendered images through a recurrent perception–reasoning–action loop using Visual Chain-of-Thought; on a CMOS inverter, a 5T-OTA, and a telescopic cascode amplifier, it achieved correctness rates of $9/10$, $V(s)$0, and $V(s)$1, with aesthetic rates of $V(s)$2, $V(s)$3, and $V(s)$4, respectively (Liu et al., 19 Oct 2025). An LLM-based AI agent for AMS circuit sizing integrates LLMs with Ngspice and analysis functions in a ReAct-style loop; after evaluating five LLMs on seven basic circuits, it selected Claude 3.5 Sonnet for a 20-transistor rail-to-rail opamp and reported success rates of $V(s)$5 for two requirement groups (Liu et al., 14 Apr 2025). AI-Sinkhole embeds an LLM-based classification component into a DNS-blocking pipeline that senses new domains, classifies whether they are general-purpose LLM chat services, and updates a Pi-hole-based blocklist, reaching $V(s)$6 accuracy and $V(s)$7 around $V(s)$8–$V(s)$9 with cross-lingual $\tau = (a_1, a_2, \dots, a_n)$0 (Kassa et al., 20 Mar 2026). These examples show that the model is now used not only for conversational or office tasks, but also for EDA, network policy enforcement, and other domain-specific engineering workflows.

6. Evaluation, limitations, and open research directions

Evaluation has become a central issue because static benchmarks do not capture interactive planning, tool use, or environment-dependent behavior. MCPEval addresses this for MCP-based agents by automating task generation from tool specifications, task verification via a frontier MCP client, and agent evaluation with both tool-call matching and LLM-based judging (Liu et al., 17 Jul 2025). Its tool-call evaluator measures Name Match Score, Parameter Match Score, and Order Match Score, with an overall weighted score using weights $\tau = (a_1, a_2, \dots, a_n)$1, $\tau = (a_1, a_2, \dots, a_n)$2, and $\tau = (a_1, a_2, \dots, a_n)$3, under both strict and flexible matching (Liu et al., 17 Jul 2025). Across 5 domains and 10 models, it reports 676 tasks for tool-call analysis, approximately 10,115 individual task evaluations, 5K trajectories and 5K completions, and 50 model-domain combinations in the LLM-judger evaluation (Liu et al., 17 Jul 2025). Average tool-call scores include 80.2\% strict / 84.3\% flex for GPT-4o and 79.4\% / 83.6\% for GPT-4.1-mini, while LLM-judger results show 90.3\% trajectory / 80.7\% completion for GPT-4o and 87.6\% / 94.9\% for O3, revealing that tool-call similarity to the GPT-4.1 reference is not identical to downstream task success (Liu et al., 17 Jul 2025). The framework’s main conceptual point is that protocol-level correctness and behavioral quality are aligned but not redundant.

Trajectory-level evaluation in web settings points in the same direction. A planning framework for LLM-based web agents introduces five evaluation metrics beyond success rate and supports them with 794 human-labeled trajectories from WebArena (Shahnovsky et al., 13 Mar 2026). In its comparison of Step-by-Step and Full-Plan-in-Advance agents, the Step-by-Step agent achieves 38\% overall success and aligns more closely with human gold trajectories, whereas the Full-Plan-in-Advance agent reaches 89\% element accuracy, indicating that different architectures optimize different aspects of trajectory quality (Shahnovsky et al., 13 Mar 2026). This undercuts the assumption that a single scalar success rate is sufficient to select an agent model.

The limitations identified across the literature are consistent. Surveys and system papers repeatedly cite generalization gaps, hallucination and factuality problems, difficulty in long-horizon tasks, planning robustness and correctness, reward and objective specification, scalability and computation, high inference latency, lack of standardized evaluation metrics, and security and privacy vulnerabilities (Zhao et al., 2023, 2505.16120). In web agents, explicit planning analyses diagnose failures as context drift, incoherent decomposition, or poor recovery behavior rather than generic model error (Shahnovsky et al., 13 Mar 2026). In modular systems, additional bottlenecks arise from prompt brittleness, methodology management, branch and loop handling, and reliable tool metadata (Xu et al., 2024). In evaluation frameworks, “ground truth” trajectories themselves may be style-biased when produced by a frontier agent, and synthetic tasks may miss real-user edge cases (Liu et al., 17 Jul 2025).

The main research directions proposed in the surveys are correspondingly architectural. They include deeper integration of LLMs with classical planners and tree search, advanced long-term memory systems with efficient retrieval and forgetting, broader tool-use learning and orchestration, multi-agent collaboration, embodied and multimodal reasoning, end-to-end benchmarking, and stronger alignment, safety, and robustness mechanisms (Zhao et al., 2023). A plausible implication is that future work will continue to move away from monolithic prompt loops toward agent models with more explicit state representations, more auditable internal artifacts, and more formalized interfaces between language reasoning, memory, tools, and environment dynamics.