A Comprehensive Survey of the LLM-Based Agent: The Contextual Cognition Perspective

1. Introduction

“Without context, ... actions have no meaning at all."

— Gregory Bateson

Large language model (LLM)-based agents have given rise to phenomenal applications such as OpenClaw and Claude Code [1,2], transitioning from fixed text processing to complex task execution [3,4]. Currently, they demonstrate proficiency across diverse domains, including software engineering [5], scientific discovery [6], web navigation [7], and embodied control [8]. As a result, understanding how LLM agents work and how their intelligence emerges become an increasingly important research question [9,10,11].

Several recent surveys attempt to systematize this field [12,13,14]. Most characterize LLM agents through modular architectures comprising planning, action, reflection, and memory [6,15]. While these works offer a clear taxonomy of functional capabilities, they often rely on a prevalent assumption: agent capacity emerges from stacking additional modules or optimizing components in isolation [16,17]. Although this perspective is sufficient for constructing static engineering frameworks, it falls short in explaining why agents fail to generalize in dynamic, open-ended environments. Real-world environments exhibit dynamics and ambiguity, requiring agents to make decisions by integrating evolving contextual signals and accumulated contextual information [18,19]. In such settings, the simple integration of modules does not guarantee that the agent can understand the evolving situational environments [20,21,22].

This leads to a deeper question that current surveys do not answer: Where does agentic intelligence actually emerge? Despite capabilities in tool use, memory construction, and long-trace reasoning, why do agents still fail at tasks requiring self-adaptation, long-horizon coordination, or mistake recovery? We argue that it expose a critical gap: what agents lack is not another module, but the capacity to manage contextuality as tasks unfold. We strictly define contextuality as the dynamic integration of external observations and the LLMs’ internal states, distinguishing it from static prompt windows or external environments. This dynamic contextuality governs signal interpretation, decision-making, and long-horizon stability, yet it remains overlooked in paradigms that prioritize the mere organization of diverse modules.

To bridge this gap, we introduce the perspective of contextual cognition. As shown in Figure 1, rather than defining an agent as a mere organization of modules, we characterize it as a system that manages contextuality through an iterative cycle of encoding, perception, interaction, and reasoning. Compared to a modern computer, the LLM acts as the central CPU, engaging with the outside world through tools like sandboxes. While prompts remain the underlying carrier of interaction, this process differs essentially from single-turn question-answering due to its high degree of dynamism and adaptability. It requires contextual information to be digitized, semanticized, and capable of forming an closed-loop process. Consequently, we argue that agentic intelligence emerges from the capacity to manage the contextuality.

Based on this perspective, we propose a unified framework structured around four interdependent processes: (1) contextual encoding, which involves the formal presentation of contextuality; (2) contextual perception, where the agent identifies relevant signals from external observations; (3) contextual interaction, through which the agent leverages these observations to dynamically update its internal states; and (4) contextual reasoning, which guides decision-making based on the formed contextuality. This integrated loop enables coherent understanding and adaptive behavior, clarifying why the mere organization of modules is insufficient. It highlights that agentic intelligence relies on the continuous, interaction-driven refinement of contextuality.

Guided by this framework, we review the recent progress of LLM-based agents. We analyze agent construction mechanisms by categorizing current methods into agent runtime and foundation LLM training, examining how each manages the contextual lifecycle. Furthermore, we revisit corresponding benchmarks and applications, such as deep research, coding, GUI, and scientific agents, to evaluate varying task demands on contextual interaction. Finally, we identify critical open challenges and provide a roadmap for overcoming cognitive bottlenecks and fostering contextualized agentic systems. By shifting the focus from the mere organization of modules to the cognitive dynamics of contextuality, this survey establishes an alternative view to analyze and drive the future development of LLM-based agents.

The remainder of this paper is organized as follows. Section 2 reviews recent progress in LLM agents, while Section 3 articulates the necessity of the contextual cognition perspective to address current technical bottlenecks. Section 4 formalizes our unified framework , detailing the cognitive closed loop. This framework is then applied in Section 5 to analyze construction mechanisms like agent runtime and foundation LLM training. Section 6 evaluates framework utility across corresponding benchmarks and applications. Finally, Section 7 and Section 8 discuss open challenges, outline future trends, and summarize our contributions.

2. Background

As shown in Figure 2, the evolution of LLM agents represents a paradigm shift from static text generation to autonomous agents capable of navigating complex contextuality. This section delineates the modern conceptualization of agents through the lens of contextual cognition and critically reviews the burgeoning survey literature to position our unified framework as a departure from traditional architectural modularity.

2.1. Concept of LLM Agents

The conceptualization of agents has evolved from classical entities acting upon environments to complex systems driven by sophisticated and dynamic agentic workflows [23]. In this evolving landscape, intelligence emerges not from static prompting but from the autonomous shaping of contextuality, as systems actively integrate perception, interaction, representation, and reasoning to navigate the unstructured nature of real-world complexity [24,25]. Rather than relying solely on scalar rewards, modern agents leverage interaction and verbal feedback to refine their cognitive loops and strategies [13,26]. This unified framework, supported by versatile agentic platforms like OpenClaw [2], encompasses diverse manifestations ranging from symbol-manipulating language agents [27,28] to embodied systems, since both require grounded reasoning that aligns dynamic internal representations with specific external affordances.

2.2. Existing Surveys

The rapid proliferation of agent research has produced a comprehensive body of literature, which we categorize into four distinct streams: General Architectures, Agentic Learning, Memory Systems, and Domain Applications. A comparative summary is provided in Table 1. While these works offer valuable structural taxonomies, they predominantly view agent capabilities in isolation, treating the agent as a mere aggregation of modules.

As illustrated in Table 1, foundational surveys initially established the standard design of agents, breaking them down into separate components like profile, memory, and planning [17,24]. More recent reviews have expanded this scope to Multi-Agent Systems, analyzing how agents cooperate or debate to solve problems [15,29]. However, these studies predominantly focus on the arrangement of agents or the history of their messages. They tend to overlook the shared cognitive contextuality, which effectively serves as the underlying understanding that allows agents to interact meaningfully beyond simple text exchange.

Parallel advancements in Agentic Reinforcement Learning and Self-Evolving Agents have shifted attention toward long-term optimization [13,14]. These works discuss how agents improve through feedback or even update their own prompts and parameters. Yet, the primary focus remains on optimizing rewards or training data, often neglecting how the agent perceives and interprets the changing situation during the task. Similarly, surveys on memory and retrieval systems [12,30] typically treat contextuality as a static storage problem, focusing on how to save and retrieve tokens, rather than how agents actively use that information to drive reasoning. Even in high-stakes domains like science or finance [6,31], contextuality is frequently reduced to fixed domain knowledge or data streams.

A critical gap remains across this literature. Existing studies largely treat contextuality as a passive input window, a database to be queried, or an isolated external environment. In contrast, this survey introduces the perspective of contextual cognition. We strictly define contextuality not as a static prompt, but as the dynamic integration of an agent’s internal state and external observations. Rather than framing agent operations as sophisticated single-turn question-answering, we argue that contextuality must be digitized, semanticized, and driven by an iterative, closed-loop cycle of encoding, perception, interaction, and reasoning, which establishes a unified foundation for understanding how agent intelligence fundamentally emerges from continuous contextual optimization.

3. Motivation

LLM-based agents are now entering tasks that require long-term planning, tool use, multi-step decision-making, and active interaction with changing environments [12,24,32]. While these systems have become more capable, they often exhibit unstable, inconsistent, or incoherent behavior when operating in real tasks. These failures reveal a deeper issue: current agents process information, but they do not truly form or maintain contextuality as the task unfolds. To understand why this happens and how to improve agent intelligence, we revisit the cognitive basis of contextuality and introduce a perspective centered on contextual cognition [33].

3.1. Why Contextuality Matters for LLM-Based Agents

Intelligent behavior fundamentally depends on contextuality. This concept has deep roots in cognitive science, psychology, and artificial intelligence. Contextual cognition shows that thinking emerges from the coupling between an agent and its environment. Understanding is shaped by how agents interpret and act within the world rather than by internal computation alone. Ecological approaches similarly highlight perception-action loops and environmental affordances that define what an agent can do in a specific setting. Classical AI adds a complementary insight [33]. Coherent behavior under uncertainty requires an internal representation of contextuality, such as a world model that integrates past experiences, current observations, and future goals. These perspectives indicate that contextuality is not merely background information, but a core part of how intelligent systems perceive, decide, and act [34].

Most current LLM-based agents use modular pipelines that treat intelligence as the sum of independent components. Planners, memory modules, and reflection routines are wired together, leaving the formation and updating of contextuality implicit. While this module-centric view works for static tasks, dynamic environments expose failures like losing goals, misinterpreting results, or contextuality collapse. As outlined in Table 2, the evolution of agent frameworks has shifted from prompt [35] and context engineering [36] toward harness engineering [37], where contextual cognition becomes the core focus. In earlier stages, interaction was treated merely as an interface layer. Our perspective treats contextual cognition and interaction as central. Agents must form, maintain, and update contextuality through ongoing environmental interaction to behave adaptively over long horizons. This motivates the layered definition of contextuality in the following subsections.

3.2. Definition of Contextuality in LLM-Based Agents

Instead of viewing LLM agents merely as tool-calling systems, we formalize them as systems for sequential decision-making and search optimization under resource constraints. This distinguishes them from classical Reinforcement Learning (RL), a learning-centric paradigm focused on policy optimization. Unlike RL, which amortizes decisions into a fixed policy, LLM agents are search-centric, dynamically constructing and optimizing multi-step trajectories during inference.

Formally, let an interaction trajectory be denoted as $\tau =(s_0,a_0,s_1,a_1,\dots ,s_T)$, where $s_t$ represents the environment state and $a_t$ is the action generated by the agent. We define the agentic process as an objective to find an optimal trajectory ${\tau }^{*}$ that maximizes the expected utility $U\left(\tau \right)$, subject to an inference resource budget B (e.g., task constraints):

$${\tau }^{*}=arg\underset{\tau \in \mathcal{T}}{max}\mathbb{E}\left[U\left(\tau \right)\right]\mathrm{s}.\mathrm{t}.a_t\sim {\pi }_{\mathrm{LLM}}(·\mid {\mathcal{C}}_t),\sum _{t=0}^{T}c\left(a_t\right)\le B$$

(1)

where $c\left(a_t\right)$ is the step-wise inference cost, ${\pi }_{\mathrm{LLM}}$ denotes the LLM, and ${\mathcal{C}}_t$ represents the contextuality at decision step t.

To clarify these conceptual boundaries, Table 3 contrasts our formulation with standard RL. Classical RL focuses on policy optimization, updating model weights (${\pi }_{\theta }$) to maximize returns based on fully Markovian states ($s_t$) and environmental primitives. Conversely, LLM agents rely on search optimization. They utilize a pre-trained model (${\pi }_{\mathrm{LLM}}$) as a learned prior to conduct heuristic search within a strict inference budget (B). Furthermore, LLM agents operate in partially observable environments through contextual interactions, where decisions depend on an evolving historical context (${\mathcal{C}}_t$). Thus, the critical challenge shifts from learning static weights during training to dynamically managing context during inference.

As illustrated in Figure 3, contextuality ${\mathcal{C}}_t$ is not merely a static input prompt or raw memory material. It is the dynamic integration of internal states (${\mathcal{I}}_t$) and external observations (${\mathcal{O}}_t$) during interactive search, formalized as ${\mathcal{C}}_t={\mathcal{I}}_t\oplus {\mathcal{O}}_t$. These components become true contextuality only when aligned to evaluate trajectories and optimize task success.

Internal States of LLMs (${\mathcal{I}}_t$).

This layer serves as a dynamic cognitive architecture organizing execution variables. It incorporates short-term working memory (e.g., intermediate reasoning traces, chain-of-thought pathways, and subgoal decomposition) as well as persistent episodic records. Furthermore, it integrates meta-level signals like self-estimated confidence and reflection markers to regulate inference costs. Collectively, these elements provide the internal grounding for evaluating explored branches and selecting optimal hybrid actions.

External Observation (${\mathcal{O}}_t$).

External observations constitute the environmental feedback driving sequential decision-making. This layer encompasses direct human instructions, systemic constraints, and dynamic tool outputs, such as ranging from search results to code execution logs and error messages. By integrating historical interactions with these signals, the agent constructs a working view of the partially observable environment, effectively bridging the gap between user objectives and actual state transitions.

The fundamental challenge of this theoretical framework is contextual cognition. Its primary objective is the effective management of this evolving contextuality to navigate the search space within budget constraints.

4. LLM Agents from Contextual Perspective

Following Figure 4, we explore how this management unfolds within the cognitive architecture of LLM agents through four interconnected dimensions: contextual encoding, perception, interaction, and reasoning. We analyze how these components synergize to transform external signals into adaptive actions, establishing a closed-loop framework for grounded decision-making in dynamic environments.

4.1. Contextual Encoding

Contextual encoding structures acquired external context for agent reasoning. Moving beyond the short windows of traditional LLMs, it handles dynamic, long-range information to maintain contextual consistency in long-horizon tasks. Therefore, an effective encoding system must carefully balance capacity and efficiency, as shown in Figure 5.

4.1.1. Textual Encoding

Textual contextual encoding stores context in readable, interpretable text forms such as summaries, key events, or episodic logs. Systems like MEM1 [38], MemAgent [39], and AWM [42] use multi-level summaries or event records to represent user preferences, task progress, or interaction history. This form aligns well with language-based reasoning and is easy for humans to inspect and edit. However, it tends to grow long and redundant, and its quality depends heavily on the model’s extraction and writing abilities, which limits scalability as tasks become more complex.

4.1.2. Vector Encoding

As task demands increase, vector contextual encoding is adopted to improve capacity and retrieval efficiency. This approach encodes context into embeddings and retrieves information via similarity search. Systems such as Memory3 [48] and MemoRAG [47] build large semantic memory pools capable of storing long histories or external knowledge bases. Vector contextual encoding scales well and supports semantic matching in latent space, but it lacks explicit structure and interpretability, making it difficult to encode relations, dependencies, or task logic directly.

4.1.3. Structured Encoding

To address these limitations, recent work introduces structured contextual encoding that uses graphs, hierarchical schemas, event chains, or knowledge trees to explicitly organize context. Examples include HippoRAG [52], Zep [54], A-MEM [55], and G-Memory [56], which capture entities, relations, temporal order, and task dependencies. This form supports more controlled and verifiable reasoning, enables symbolic-style planning, and facilitates multi-agent coordination. Its effectiveness, however, depends on reliable extraction and structure construction, and errors in structure can propagate through the reasoning process.

Despite these advances, contextual encoding still faces significant challenges. Real environments contain heterogeneous sources such as web pages, GUIs, user feedback, sensors, and multimodal signals that are difficult to unify within a single representation. Scalability and continual updating remain problematic as context grows rapidly during long tasks, leading to redundancy, drift, or forgetting. Moreover, aligning structured forms with accurate semantics is nontrivial: errors in extraction can constrain or mislead reasoning. There is also inherent tension between interpretability and control: textual contextual encoding is interpretable but weakly structured, vector contextual encoding is scalable but opaque, and structured contextual encoding is expressive but expensive to build. Current systems lack flexible mechanisms that combine these advantages, and the interaction between contextual encoding and reasoning remains underdeveloped. Progress will require better multimodal integration, more adaptive update strategies, and tighter coupling between encoding and reasoning, enabling agents to form robust context-driven cognitive systems.

4.2. Contextual Perception

As shown in Figure 6, contextual perception processes raw environmental signals into clear features. In complex settings [7], agents face diverse and changing data. To manage this efficiently, we divide perception into two types: observation perception, which captures the current snapshot, and state perception, which tracks changes and feedback over time.

4.2.1. State Perception

State perception shifts the focus from the snapshot to the stream, monitoring the temporal evolution of the environment. As emphasized by AgentBoard [67], real-world tasks are long-horizon and partially observable; the agent must perceive the "delta" between states to understand the consequences of its actions. This acts as a change detector mechanism. For instance, in e-commerce scenarios within WebShop [65], the agent must actively monitor dynamic feedback loops, such as search result updates or error messages, to verify if the environment has transitioned as intended [175].

This dimension is critical for maintaining situational awareness in evolving contexts. CORE [69] suggests that in scenarios with limited visibility, agents must aggregate fragmentary observations over time to perceive the global status, effectively reconstructing the whole from dynamic parts. Similarly, in social simulations like AgentSociety [68], the environment is a flowing stream of dialogue and social interactions. Here, perception involves monitoring the discourse history to detect shifts in topic or sentiment. Furthermore, research on EnvGen [66] indicates that robust state perception requires adaptability and agents must learn to tune their sensitivity to environmental feedback through repeated interaction. Through state perception, the agent captures what is changing, providing the reasoning core with crucial information about task progress and environmental responsiveness.

4.2.2. Observation Perception

Observation perception addresses the challenge of identifying salient objects and functional affordances within a single, noisy observation frame. In web-based agents, raw inputs ranging from massive HTML trees to high-resolution screenshots contain significant redundancy. Mind2Web [59] demonstrates that efficient perception requires a structural filter to prune irrelevant tags from the raw HTML, extracting only the functional sub-tree necessary for the current task. This filtering extends to the visual domain, CogAgent [62] highlights the necessity of using specialized visual encoders to identify GUI artifacts such as icons and layout boundaries that are not explicitly defined in the code, ensuring the agent perceives the interface similar to a human user.

Beyond mere detection, observation perception involves grounding, defined as the alignment of abstract concepts with concrete environmental elements. AlfWorld [61] formalizes this by requiring agents to map textual object references, such as a target fridge, to specific visual regions in the scene. Advanced agents like WebVoyager [60] further enhance this by performing semantic validation during the perceptual phase, such as detecting whether a perceived button is disabled or active. By synthesizing these signals, observation perception reconstructs a clean, denoised view of the current snapshot, isolating what exists before any action is taken.

4.3. Contextual Interaction

Contextual interaction integrates perception, reasoning, and action into an iterative decision-making loop. Agents in this loop actively interpret and adapt to the environment rather than passively receiving information. This process requires the agent to interleave immediate state analysis with historical context processing dynamically. As shown in Figure 7, we categorize these interactions into three modes based on interacting entities: Human-Guided Interaction, Tool-Augmented Interaction, and Multi-Agent Interaction.

4.3.1. Human-Guided Interaction

Human-guided interaction focuses on alignment and feedback reinforcement through natural language, rule-based and model-based signals. Agents utilize these signals to refine strategies and achieve continuous improvement with or without parameter updates. Reflexion [26] introduces a verbal reinforcement learning framework. The agent generates self-reflective text after each trial and stores this feedback in a memory buffer to induce better decision-making in subsequent attempts. Similarly, Voyager [8] demonstrates lifelong learning in embodied environments. It utilizes an iterative prompting scheme where the agent incorporates environmental feedback and execution errors to refine its code library continuously. Recent advancements such as skills [73] encapsulate complex, domain-specific workflows into modular components, enabling humans to direct AI agents through high-level abstractions rather than low-level execution details. These approaches illustrate that linguistic and environmental feedback serves as a critical driver for agent evolution.

4.3.2. Tool-Augmented Interaction

Tool-augmented interaction extends agent capabilities by treating external tools as effectors for high-precision environmental manipulation. The interaction medium primarily involves executable code, API calls, and structured protocols. Early works like ReAct [74] synergize reasoning and acting by interleaving thought generation with tool execution. To enhance reliability, Toolformer [75] and Gorilla [76] employ self-supervised learning and retrieval-augmented fine-tuning. These methods ensure the generation of syntactically correct and functionally accurate API calls. Current research shifts from mere usage to autonomous tool creation and unified retrieval. LATM [81] and ToolMaker [77] enable agents to generate reusable tools for new tasks and reduce reliance on human-developed libraries. Simultaneously, DRAFT [78] refines tool documentation through trial-and-error feedback to bridge the understanding gap. ToolGen [79] and Meta-Tool [80] further integrate tool retrieval directly into the generation process or open-world environments. Evaluation benchmarks such as ToolHop [176] highlight the necessity for robust multi-step reasoning in complex tool chains.

4.3.3. Multi-Agent Interaction

Multi-agent interaction facilitates distributed reasoning and collective intelligence through standardized communication protocols. This mode enables task decomposition and role-based collaboration among heterogeneous agents. HuggingGPT [83] utilizes an LLM as a central controller to plan tasks and orchestrate expert models for multi-modal problem solving. To reduce human intervention, CAMEL [84] employs inception prompting to establish autonomous role-playing dialogues between communicative agents. Addressing logic inconsistency in complex workflows, MetaGPT [85] encodes standard operating procedures into agent prompts. This method assigns specific professional roles to agents and enforces a structured assembly line for output verification. AutoGen [86] generalizes this by providing a flexible infrastructure for orchestrating conversational patterns among agents and humans. Beyond task solving, Generative Agents [43] simulate credible human social behaviors through memory retrieval and reflection in a sandbox environment. Recently, sub-agents [82] act as subordinate executors managed by a centralized controller, whereas agent teams embody a decentralized or semi-structured paradigm where multiple agents negotiate and synchronize their actions.

The transition to dynamic contextual interaction empowers agents to handle open-ended problems but introduces significant challenges. First, precise alignment with dynamic intent poses difficulties as user goals often drift during multi-turn interactions. Second, maintaining consistency of interaction state proves critical to prevent self-contradiction over long horizons. Third, the efficiency bottleneck in long context limits the effective utilization of extensive interaction history. Fourth, robustness in tool use requires agents to handle long-tail distribution of tools and ensure syntactic validity. Finally, multi-agent systems face issues regarding coordination costs and the cascading propagation of errors. Future research must address these bottlenecks to build agents that are truly adaptive and collaborative.

4.4. Contextual Reasoning

Contextual reasoning refers to the process by which an agent uses the contextual information it has already obtained and represented to make decisions, solve problems, and complete tasks. After contextual Perception, the agent must reason on top of these internal structures, selecting, transforming, and integrating contextual signals into coherent decision trajectories. As the final stage of the contextual cognition loop, contextual reasoning links structured context to goal-directed actions, determines how the agent interprets evolving evidence, and shapes the stability of long-horizon behaviors.

Prior surveys typically classify reasoning by prompting strategies, architectural designs, or inference procedures. In contrast, as shown in Figure 8, we adopt a complementary view that organizes reasoning by the space in which it operates. From this perspective, contextual reasoning spans six substrates: natural language, code programs, knowledge graphs, logical symbolic systems, latent implicit spaces, and multimodal environments, each offering distinct structures and constraints for manipulating context. This taxonomy shifts attention from the form of reasoning traces to the representational substrate that shapes how reasoning unfolds.

4.4.1. Natural Language Reasoning

Natural language reasoning situates the entire reasoning process within the linguistic space, where contextual information is transformed through explicit or semi-explicit reasoning traces. Methods such as Chain-of-Thought [35], self-consistency decoding [88], decomposition-based prompting, Tree-of-Thought [89], and ReAct [74] exemplify this paradigm. These approaches allow step-by-step alignment, provide interpretability, and flexibly incorporate retrieved evidence or user feedback. In contextual settings, natural language reasoning operates directly over summaries, episodic logs, and historical observations. However, its reliance on free-form text makes it vulnerable to hallucination, context drift, and inconsistencies during long-horizon tasks [177,178].

4.4.2. Code Program Reasoning

Code program reasoning leverages executable programs as the medium of inference. Instead of producing purely linguistic reasoning traces, the agent translates contextual information into programmatic expressions, such as Python programs, DSL specifications, or tool-centric action code, that are executed and verified by external runtimes. Representative systems include PAL [94], Program-of-Thoughts [95], ViperGPT [99], VISPROG [100], and tool-integrated agents [98]. This paradigm offers deterministic computation, modularity, and verifiability, making it well-suited for tasks requiring grounded interaction with APIs, environments, or external toolchains. Yet, program generation is brittle: minor contextual misinterpretation may yield syntactically or semantically incorrect code, and the reliance on external execution environments introduces additional points of failure [179].

4.4.3. Knowledge Graph Reasoning

Knowledge graph reasoning embeds inference within explicit graph structures consisting of entities, relations, events, or temporal dependencies. Techniques such as Think-on-Graph [101], graph exploration agents [102], and KG-augmented QA [105] transform contextual encodings into graph spaces that support multi-hop reasoning, constraint propagation, and symbolic grounding. Compared to unstructured linguistic reasoning, KG reasoning benefits from relational consistency and structured memory, which are valuable in long-horizon tasks requiring stable world models, domain knowledge integration, or persistent state tracking. However, its performance heavily depends on accurate graph extraction; errors in mapping contextual information into graph form can severely constrain downstream reasoning.

4.4.4. Logical Symbolic Reasoning

Logical symbolic reasoning situates contextual inference in formal symbolic systems such as first-order logic, constraint satisfaction problems, and SAT/SMT solvers. Methods like Logic-LM [108], SatLM [97], solver-augmented CoT [110], and neuro-symbolic hybrid systems convert contextual inputs into logical formulas, constraints, or proof steps that can be processed by symbolic solvers with correctness guarantees. This paradigm is particularly useful in tasks requiring strict consistency, rule adherence, or formal verification. Within the contextual cognition loop, symbolic reasoning can validate or refine contextual encodings by enforcing invariants. However, the translation from natural language to logical form remains brittle, and small semantic errors may lead to unsatisfiable or incorrect symbolic encodings [180].

4.4.5. Latent Space Reasoning

Latent space reasoning refers to implicit reasoning processes occurring entirely within the model’s internal states, without explicit intermediate steps. Recent large reasoning models, implicit Chain-of-Thought frameworks, reinforcement-learned reasoning policies, and latent-memory systems exemplify this paradigm [72,111,112]. These models perform multi-step inference through internal computations such as attention routing and hidden-state transitions. Latent reasoning is efficient and avoids the verbosity and instability of explicit text-based reasoning. However, it sacrifices interpretability and controllability: contextual misalignment or reasoning errors become harder to diagnose, and ensuring safety or consistency in long-horizon latent reasoning remains an open challenge.

4.4.6. Multimodal Reasoning

Multimodal reasoning extends contextual inference to environments involving images, videos, GUI states, visual affordances, or embodied sensory inputs. Frameworks such as Multimodal Chain-of-Thought [115], MM-ReAct [116], VISPROG [100], and ViperGPT [99] integrate textual reasoning with perceptual grounding to bridge the gap between language and sensory data. In this paradigm, contextual information may originate from complex sensory observations, requiring spatial, semantic, and temporal integration. Multimodal reasoning enables situated decision-making, visual planning, and perception-informed action. Yet, it inherits uncertainty from perception pipelines: errors in visual grounding can cascade through the reasoning process, and aligning multimodal signals with textual context remains a significant challenge.

Despite rapid advances across these reasoning spaces, achieving stable, verifiable, and context-grounded reasoning in open environments remains difficult. A central problem is context grounding: reasoning steps must remain faithful to earlier contextual encodings, yet models frequently hallucinate premises, ignore context, or drift from task goals. Dynamic environments require continuous updating of reasoning states, while long-horizon tasks exacerbate inconsistencies across steps. Explicit reasoning offers transparency but is brittle; implicit reasoning offers efficiency but lacks interpretability; symbolic reasoning provides correctness but relies on fragile semantic parsing; multimodal reasoning compounds noise from perception; and graph- or program-based reasoning depends on accurate structured extraction. Addressing these challenges requires advances in context verification, reasoning control, cross-space consistency, and adaptive reasoning capable of operating reliably in real-world settings.

5. Building Contextual LLM Agents

In this section, we explore two primary construction mechanisms for contextual agents: runtime runtime and foundation LLM training, including their convergence in Figure 9. We contrast how foundation LLM training optimizes end-to-end policies, while runtime runtime structures cognitive processes. Together, these pathways demonstrate how the contextual lifecycle is managed and refined.

5.1. Agent Runtime

Unlike learning-based paradigms that implicitly optimize policies via end-to-end training [61,181], workflow-based agent runtime focuses on the explicit orchestration of cognitive architectures [17,27]. In this paradigm, the agent is governed by structured execution flows, which essentially serve as the control logic for contextual flow [85,86]. This modular design allows developers to decompose the complex lifecycle of contextual cognition into deterministic, interpretable steps. To systematically align with the agent’s cognitive lifecycle established in this survey, we categorize these orchestrated modules into four consecutive phases: contextual perception, interaction, representation, and reasoning [182].

5.1.1. Agent Runtime for Contextual Encoding

Contextual encoding governs how the agent structurally encodes both anticipated future states and historical experiences to guide current behavior. To explicitly decouple global planning from local execution, dedicated planners generate high-level, abstract guidance, termed "meta plans," which outline the trajectory of context evolution independent of specific environmental details [183,184]. This explicit foresight is critical for long-horizon tasks, preventing myopic behavior. Recently, to-do lists have emerged as dynamic closed-loop encodings that track the real-time progression of tasks from initiation to completion, ensuring planned workflows are verifiable and fully realized [185]. To bridge transient processing and lifelong learning [43], the workflow relies on hierarchical long-term memory (episodic, semantic, procedural) powered by vector databases. This encoding enables retrieval-augmented generation [186] to dynamically fetch relevant past experiences. Frameworks like Reflexion further convert transient feedback into persistent verbal reinforcement [26], allowing the agent to weave historical lessons into current contexts for continuous self-improvement and consistency across long-term interactions [8,49,187].

5.1.2. Agent Runtime for Contextual Perception

Contextual perception establishes the agent’s active awareness of its current environment, available capabilities, and the inherent gap between its current state and global objectives [188]. Rather than reacting blindly, this workflow optimizes the agent’s active workspace via short-term working memory, employing information density optimization to retain critical task states within the finite context window. This ensures the agent is always grounded in the most relevant aspects of its environment. Beyond environmental states, perception critically extends to tool awareness. To manage the complexity of heterogeneous tool ecosystems, the Model Context Protocol (MCP) serves as a standardized architecture [189]. MCP abstracts diverse data sources and tools into standardized primitives (resources, prompts, and tools), ensuring the agent remains universally aware of how to discover and connect to local or remote utilities without bespoke glue code [98]. This standardized perception mechanism is the prerequisite for any meaningful action.

5.1.3. Agent Runtime for Contextual Interaction

Contextual interaction functions as the interface where internal cognition is grounded in the external environment, enabling the agent to actively deploy its capabilities to modify the context [75]. Fundamental execution operations are realized through explicit function calling mechanisms [76]. This modularity allows developers to seamlessly transfer complex "action awareness" and tool-use trajectories, initially established by large models, down to smaller, more specialized models [190]. Furthermore, interaction encompasses a dynamic generate-evaluate-refine cycle to engage with environmental feedback [191]. When an action is executed, the workflow synthesizes multi-source feedback to reconcile discrepancies between the intended context (the plan) and the actual outcome [192]. Instead of immediately halting upon error, the agent actively interacts with this feedback to diagnose root causes and syntax errors from logic flaws. This process is supported by defensive layers that ensure these active contextual updates do not compromise overall integrity.

5.1.4. Agent Runtime for Contextual Reasoning

Contextual reasoning serves as the central computational engine, determining how the agent dynamically manipulates and processes represented information to derive conclusions. This workflow orchestrates reasoning across two orthogonal dimensions: depth and breadth. To enhance reasoning depth, agents employ test-time scaling strategies like Chain-of-Thought [35], engaging in a step-by-step dialogue with the current context to break down complex queries into solvable sub-problems via decomposition [193]. Additionally, structured thought paradigms like Tree of Thoughts [89] are utilized to simulate potential future contexts and reasoning paths. To enhance reasoning breadth, the workflow incorporates uncertainty quantification as a mechanism for contextual verification [194]. By utilizing techniques like self-consistency [88], the agent samples multiple diverse reasoning paths to assess the stability of its conclusions. This breadth-oriented mechanism acts as a cognitive brake: when uncertainty is high, it triggers defensive behaviors, such as asking for clarification, ensuring the reasoning process remains robust. Finally, the root causes diagnosed during the interaction phase are fed back into this reasoning engine as refined prompts, forcing the model to systematically regenerate corrected solutions.

5.2. Foundation LLM Training

While traditional reinforcement learning (e.g., RLHF) treats LLMs as passive, single-turn generators relying on static, user-provided contexts, agentic reinforcement learning shifts this focus by embedding the model as an interactive policy within a partially observable environment (POMDP). In this dynamic setting, context is not passively received but actively constructed: the agent executes actions and processes feedback to shape its own input distribution. Unlike workflow-based methods (§Section 5.1) that depend on human-engineered pipelines, Agentic RL pursues the end-to-end learning of contextual cognition, enabling the agent to autonomously optimize its entire cognitive lifecycle based on task rewards.

5.2.1. RL for Contextual Encoding

Contextual encoding focuses on how an agent structures acquired information into a usable internal state for downstream reasoning. Rather than treating the context window as a passive buffer, agentic RL frames memory management as an active decision process involving retrieval, maintenance, and compression [195]. While systems like Mem0 [132] demonstrate the value of structured memory architectures, recent RL approaches make the memory operations themselves learnable. For example, Memory-R1 optimizes a memory manager that decides distinct actions (ADD, UPDATE, DELETE) via end-to-end reinforcement to autonomously curate a concise knowledge bank. Furthermore, addressing long-horizon challenges, frameworks such as AgentFold [196] and Context-Folding [138] treat the context history as a flexible workspace, training the agent to proactively fold or compress past trajectory segments. By doing so, these methods transform encoding from a static storage problem into a policy-optimized resource management task.

5.2.2. RL for Contextual Perception

Contextual perception concerns how an agent actively filters vast, noisy environmental signals into a concise internal observation tailored for reasoning. Unlike passive data pipelines, RL-driven perception optimizes an active filtering policy to maximize the signal-to-noise ratio before reasoning begins. We structure this design space along three core strategies: (i) active sensing to bring relevant information into view, as seen in GUI agents learning to scroll or navigate apps to locate task-critical widgets [21,197,198]; (ii) attentional filtering to distill specific regions and suppress noise, demonstrated by visual agents using tools like cropping to isolate informative areas [130,199]; and (iii) perception budgeting to weigh the marginal gain of acquiring new information against the inherent interaction costs [179,200]. By mastering these behaviors, the agent transforms perception from a fixed front-end into a dynamic, context-shaping process.

5.2.3. RL for Contextual Interaction

Contextual interaction concerns how an agent sequences tool calls and environment actions to acquire useful context over time. Instead of following rigid, pre-defined pipelines (e.g., search-then-answer), agentic RL formulates information seeking as a dynamic interaction policy, deciding when to issue a query, how to refine search terms based on partial feedback, and when to terminate exploration. This transforms interaction into an optimizable trade-off between information gain and interaction steps. In web research, models like Search-R1 [133], R1-Searcher [201], and Tongyi DeepResearch [202] utilize outcome-based RL to learn iterative browsing strategies that autonomously determine search depth and specificity. Similarly, in software engineering, DeepSWE and SWE-RL [136] treat coding as a multi-step debugging loop. By using compiler feedback and test execution as rewards, these agents learn trial-and-repair policies, acquiring just enough high-quality context to solve tasks reliably without unnecessary exploration.

5.2.4. RL for Contextual Reasoning

Contextual reasoning concerns the optimization of the structure and control of the thought process itself. Beyond simply generating an answer, agentic RL aims to learn the optimal topology of reasoning, determining how many steps to take, when to branch, and how to interleave internal thought with external tool use. This shift from imitating fixed chain-of-thought templates to discovering robust reasoning patterns, such as strategic backtracking, maximizes correctness in complex environments [203]. By treating intermediate reasoning steps and tool invocations as actions, methods like SWiRL [141], ARTIST [142], and ToRL [139] reinforce locally useful sub-goals and coherent tool usage. Furthermore, RL enables meta-cognitive control over the planning process; frameworks like RLTR [140] and Learning-When-to-Plan [204] reward agents for deciding when to engage in explicit planning versus acting directly, thereby dynamically balancing computational expenditure with reasoning depth [205].

5.3. Convergence: RL-Optimized Agentic Workflows

While Agentic RL (§Section 5.2) typically trains monolithic policies and Workflow Orchestration (§Section 5.1) relies on static, human-designed logic, a rapidly emerging paradigm seeks to converge these approaches by injecting learnability into modular workflows. This hybrid direction retains the structural interpretability of engineered pipelines while leveraging reinforcement learning to optimize critical decision-making nodes, such as planners or routers, within the system.

Recent frameworks demonstrate two distinct pathways for this integration. AgentFlow [146] introduces module optimization in the flow, where a Planner is explicitly trained using trajectory-level feedback. By broadcasting outcomes to intermediate turns, it solves credit assignment in long-horizon tasks while keeping tool-use and verification modules frozen. Conversely, Agent-Lightning [206] proposes a framework-agnostic approach, decoupling reinforcement learning training from agent execution. By formulating any agentic chain as a Markov Decision Process through a unified data interface, it enables the selective optimization of specific components without modifying the underlying workflow code.

The core of this approach is integrating modular steps—like tool-calling and memory retrieval—into a unified reinforcement learning loop. By treating workflows as stochastic policies rather than fixed sequences, agents can adaptively explore reasoning paths to maximize long-term rewards. A prime example is Claw-R1 [207], an advanced framework that empowers general agents (like OpenClaw) through Agentic RL. It utilizes a middleware architecture to decouple agent execution from training, allowing models to learn from environmental feedback and optimize high-variance decision points without retraining the entire foundation. This targeted optimization ensures sample efficiency and maintains safety.

In summary, the transition from prompt engineering to flow engineering with reinforcement learning signifies the rise of trainable cognitive systems. In these systems, structural priors ensure safety and reliability while reinforcement learning continuously refines reasoning policies within those constraints. This white-box optimization combines symbolic structure with neural adaptability, paving the way for autonomous agents that self-evolve through environmental interaction while remaining fundamentally interpretable to human designers.

6. Benchmarks and Applications

This section surveys the evaluation landscape and practical frontiers of contextual agents. We first categorize benchmarks across encoding, interaction and reasoning dimensions to assess core competencies. Subsequently, we examine applications in science, deep research, and finance, illustrating the transition toward autonomous, full-cycle problem solving.

6.1. Datasets and Benchmarks

To examine the core abilities of contextual agents, existing benchmarks are organized into three dimensions, contextual encoding, interaction, and reasoning, each capturing a layer of an agent’s ability to engage with, internalize, and reason over context. Table 4 summarizes representative benchmarks, illustrating how current frameworks probe different facets of contextual intelligence.

Contextual encoding concerns an agent’s ability to build, maintain, and update internal models of its environment, memories, and evolving tasks, central to situational intelligence. BBEH [154] exposes the limits of an agent’s world-model consistency in cross-domain reasoning tasks, revealing how fragile internal encodings become under high cognitive load. Long-range memory formation is examined by LongMemEval [152], which stresses stability, selective forgetting, cross-turn coherence, and resilience to context drift during extended interactions. MemoryAgentBench [159] further decomposes the encoding problem in incremental multi-turn tasks, testing accurate recall, information accumulation, and integration across unfolding contexts. Extending beyond static memory, StreamBench [155] evaluates whether agents can continuously improve by updating prompts, memory, or retrieval mechanisms over streaming sequences, measuring an agent’s ability to construct encodings that evolve with experience rather than being fixed at inference time. These benchmarks capture how contextual encodings support situationally aware behavior, showing that while agents can form task-specific internal states, persistent and updateable encodings remain a major bottleneck in open-ended environments.

Evaluating contextual interaction focuses on how effectively an agent engages with humans, tools, and environments, reflecting its situational awareness and ability to act in real-world contexts. Benchmarks such as GAIA [147] and HLE [148] assess an agent’s competence in multi-step tasks involving intention understanding, tool-mediated actions, and open-world knowledge integration, highlighting whether an agent can follow human goals across long-horizon procedures. Human-aligned improvement is further examined by Uni-RLHF [149], which evaluates how agents update contextual understanding based on user feedback, a core requirement for adaptive human–AI collaboration. Tool-based interaction is captured by ToolLLM [98] and StableToolBench [150], which analyze an agent’s reliability in API calling, error recovery, and large-scale tool usage under realistic constraints. Meanwhile, AgentBench [153] extends evaluation into multi-environment settings, from operating systems and databases to web and embodied games, probing whether agents can ground their actions in dynamic environments with strict interfaces and partial observability. Together, these benchmarks portray contextual interaction as the foundation of situational intelligence, revealing both the strengths and fragilities of agents.

Contextual reasoning measures how effectively an agent leverages situational information to perform structured decision-making, long-horizon inference, and adaptive strategy formation. REALM-Bench [158] evaluates agents in planning and scheduling tasks that incorporate disturbances, multi-agent coordination, and logistical constraints, revealing their ability to re-plan under changing environments. FlowBench [156] examines workflow-guided planning by comparing text-, code-, and diagram-based representations, assessing how different forms of contextual knowledge shape multi-step reasoning and conversational planning. Reflection-Bench [151] evaluates epistemic agency, such as belief revision, counterfactual reasoning, prediction, and meta-reflection, probing whether agents can form reflective chains that regulate their own reasoning. LR2Bench [157] targets long-chain reflective reasoning, measuring multi-step thinking and the capacity to self-correct across extended trajectories. These benchmarks characterize contextual reasoning as the apex of situational intelligence: the ability not just to act or remember, but to deliberate, adapt strategies, revise beliefs, and construct long-horizon plans grounded in evolving context [208,209].

6.2. LLM Agent Applications

Agentic AI is transitioning toward autonomous, full-cycle problem solving, exemplified by systems like AI Co-Scientist [210] and Manus [211]. Figure 10 highlights this shift across deep research, software engineering, graphical user interfaces, and scientific discovery, where agents now integrate retrieval, planning, and execution into end-to-end workflows. This evolution marks the rise of contextual agents as collaborators capable of independent reasoning and action within complex environments [172].

Deep research agents aim to enable models to perform multi-hop retrieval, information integration, and in-depth reasoning across open web environments and massive document repositories. Industrial systems like Google’s NotebookLM accelerate this by grounding dynamic interactions in user-provided contexts, while academic frameworks such as OpenResearcher [166], ResearchAgent [167], and DeepResearcher [20] equip models with robust behaviors for literature processing, cross-validation, and reflection. Crucially, these capabilities extend beyond academic inquiry into complex commercial analysis, where systems like FinAgent [168] and FinCon [169] integrate multimodal perception, hierarchical memory, and multi-tool orchestration to maintain consistent decision-making. Overall, deep research agents are rapidly evolving from retrieval-augmented assistants into comprehensive analysts capable of autonomously synthesizing external knowledge across diverse real-world landscapes.

Coding agents represent a significant leap in converting natural language intent into functional software through iterative interaction with development environments. MetaGPT [85] models a complete software company by assigning specialized roles to multiple agents to streamline collaborative development, whereas SWE-agent [212] focuses on single-agent efficiency via an Agent-Computer Interface tailored for code editing and execution. Furthermore, autonomous frameworks like OpenHands [170] demonstrate the capability to handle end-to-end software engineering tasks, from environment setup to testing and debugging. By maintaining a continuous contextual understanding of the codebase and execution feedback, these agents significantly reduce human intervention in the development lifecycle.

GUI agents interact with digital ecosystems by perceiving visual interfaces and executing human-like actions, bridging the gap between natural language and operating systems. AppAgent [213] enables language models to operate smartphone applications through a simplified action space, learning UI navigation via exploration and human demonstration. In desktop environments, UFO [214] acts as a dual-agent framework for Windows OS, seamlessly operating across multiple applications to fulfill user requests, while WebVoyager [60] processes web layouts and visual elements to execute complex transactional workflows. These agents rely on sophisticated visual grounding to translate dynamic screen states into actionable external observations, expanding the reach of LLMs beyond text-based interfaces.

In scientific-agent systems, recent work shows a clear evolution from foundation models to multi-agent architectures capable of autonomous discovery. PaSa [161] and ChatCite [162] enhance literature discovery and reflective incremental writing, while Agent Laboratory [163] integrates data preparation, experimental execution, and manuscript writing into a reproducible end-to-end workflow. Beyond literature, NatureLM [160] constructs a unified sequence-based foundation model spanning diverse scientific domains, providing a backbone for systems like ProtAgents [164] and Bio AI Agent [165], which coordinate multi-agent reasoning across physical simulation, target identification, and molecular design. Overall, these systems reflect a growing trend in which contextual agents augment the full cycle of “search–understand–design–validate–decide,” driving scientific discovery toward increasingly autonomous collaboration.

6.3. Case Study: Contextual Cognition for OpenClaw

Personal AI assistants, such as OpenClaw, serve as a prototypical application for contextual cognition, where multi-turn communication requires dynamic state management across diverse messaging platforms. In this setting, the agent’s external observation space, comprising persistent memory and accessible skills, must be continuously internalized. Through contextual encoding, OpenClaw translates multimodal inputs from various message channels and user preferences into a structured internal representation. This encoded state forms the foundation for contextual perception, allowing the agent to actively monitor its environment, parse task contexts, and evaluate available plugins. Rather than treating context as a static prompt, these initial cognitive stages ensure the evolving personal state remains retrievable and actionable across multiple interaction sessions.

As shown in Figure 11, the operational lifecycle of OpenClaw is driven by a continuous cognitive loop. Moving beyond passive perception, the agent engages in contextual interaction by mapping its perceived environment to deliberate internal states, like intent recognition and action planning. This interactive phase utilizes execution logs and API feedback to orchestrate workflows dynamically across platforms. Finally, the system employs contextual reasoning to synthesize these interactions into robust decision-making, enabling critical functions such as state updating and error recovery. By integrating encoding, perception, interaction, and reasoning, OpenClaw transforms a fragmented cross-platform environment into a cohesive cognitive architecture, elevating the agent from a response generator to a resilient system capable of multi-step task completion.

7. Future Research Directions

The transition from static module optimization to dynamic contextual cognition presents significant opportunities. We identify six critical directions to enhance the adaptability and reliability of LLM agents: evolving always-on runtimes, natively aligning models for continuous interaction, advancing dynamic state management. Finally, broadening applications into expert domains and pioneering dynamic evaluation frameworks will be essential.

7.1. Evolving Agentic Runtimes

The emergence of tools like Claude Code highlights a shift toward persistent, agent-centric execution environments, yet current systems remain transitional. Future agentic runtimes must evolve beyond static sandboxes into dynamic, lifelong operating systems that inherently support contextual cognition. This requires infrastructures capable of continuous, asynchronous state synchronization, where the agent seamlessly aligns its evolving internal state with real-time external observations. Developing these human-like, always-on runtimes will enable agents to proactively monitor environments, manage long-term background processes, and maintain situational awareness across extended interaction lifecycles.

7.2. Aligning LLM for Contextual Cognition.

Currently, most large language models are optimized for single-turn generation rather than continuous environmental interaction. To truly realize contextual cognition, the underlying foundation models must be natively aligned with agentic behaviors. This involves shifting the training focus from static text completion to optimizing interaction policies within partially observable environments. Open-source reinforcement learning frameworks tailored for agentic AI, provide a critical pathway for this evolution. By integrating reward signals derived directly from environmental feedback, these frameworks enable models to autonomously construct and refine their working context, bridging the gap between passive reasoning and grounded action.

7.3. Advanced Contextual State Management

As interactions become increasingly complex, maintaining a coherent internal state over long horizons presents a significant challenge. Future research must address how agents autonomously manage their memory architectures—transitioning from passive vector stores to active, hierarchical state management. This involves learning optimal policies for encoding, compressing, and retrieving episodic and procedural experiences. Effective state management will allow agents to dynamically fold historical contextuality into real-time decision-making, ensuring continuous self-improvement while mitigating the risks of context overload and information degradation.

7.4. Expanding Contextual Encodings

For agents to interact robustly with the physical and digital world, the external observation layer must become highly digitized and semanticized. Future development requires the creation of richer toolsets capable of translating unstructured, multimodal signals into formal, closed-loop representations. By expanding the agent’s perceptual bandwidth—through advanced APIs, sensory inputs, and structural filters—ambiguous environmental feedback can be converted into precise, expressible operational states. This strict digitization ensures that the dynamic contextuality remains verifiable and actionable throughout the reasoning cycle.

7.5. Broadening Agent Applications

As contextual capabilities mature, agentic applications will rapidly expand beyond constrained coding or web-navigation tasks into highly open-ended, expert-level domains. Future systems will drive complex, long-horizon workflows, such as synthesizing comprehensive commercial analyses, autonomously tracing and forecasting scientific evolution by constructing structured trend trees, and orchestrating massive multi-agent ecosystems. In these advanced applications, contextuality will not just be maintained by a single entity, but shared, negotiated, and dynamically updated among diverse agents to solve cross-disciplinary challenges.

7.6. Evaluating Dynamic Contextual Interactions.

The dynamic and adaptive nature of contextual cognition necessitates a fundamental shift in how agentic systems are evaluated. Traditional static benchmarks, which focus on final output accuracy, are insufficient for assessing the quality of multi-step, closed-loop interactions. Future evaluation frameworks must measure the efficiency of contextual perception, the robustness of the interaction trajectory, and the agent’s ability to recover from environmental shifts or tool failures. Developing dynamic, tool-augmented testing environments that quantify the trade-offs between information gain and interaction costs will be critical for accurately measuring true agentic intelligence.

8. Conclusion

In this survey, we challenge the conventional modular view of LLM-based agents by establishing a unified foundation centered on contextual cognition. We argue that the emergence of agentic intelligence stems not from the mere organization of diverse modules, but from how an agent manages and interacts with contextuality: the dynamic integration of external observations and internal states. To operationalize this insight, we propose a comprehensive framework comprising contextual encoding, perception, interaction, and reasoning. This framework serves as the lens to systematically review current agent construction methods, encompassing runtime orchestration and foundation LLM training. By revisiting corresponding benchmarks and complex applications, we highlight the necessity of shifting focus from static modules to dynamic, contextualized processes. We conclude that overcoming the open challenges rooted in this cognitive bottleneck is essential for future research, providing a roadmap to drive the development of robust, real-world agentic systems.