Adaptive Context Management

• Adaptive Context Management is a set of mechanisms for acquiring, representing, restructuring, caching, and routing context to adapt to dynamic states and resource constraints.
• ACM is applied in wireless networks, mobile middleware, and LLM-based dialogue systems to optimize context utilization and mitigate issues like state drift and contextual inertia.
• ACM approaches balance trade-offs between fidelity, recoverability, and compression, enabling cost-efficient adaptations and improved performance under bounded capacity.

Searching arXiv for the cited ACM papers to ground the article in current arXiv records. Adaptive Context Management (ACM) denotes a family of mechanisms for acquiring, representing, restructuring, caching, routing, compressing, and recovering context so that a system can continue to act correctly under changing state, limited resources, and bounded context capacity. In classical context-aware computing, ACM concerns the management of environmental, user, hardware, temporal, geographic, and network information for adaptation in wireless, mobile, and service-oriented systems (Giadom et al., 2014, 0909.2090, Sen et al., 2010). In recent LLM research, ACM refers to explicit control of dialogue history, evidence, tool traces, and working memory in order to mitigate contextual inertia, state drift, proactive interference, long-context degradation, and context contamination during long-horizon reasoning (Shen et al., 9 Jan 2026, Li et al., 6 Aug 2025, Yi et al., 29 May 2026, Yang et al., 22 Jan 2026).

1. Conceptual foundations and representations

Early context-aware computing literature treated context as the situation in which an application executes. One formulation characterizes context-awareness as “The capacity for a mobile application and/or a user to discover and react to situations modifications,” while another characterizes execution context as grouping “all entities and external situations that influence on the quality of service/performances (qualitative & quantitative) as the user perceives them” (0909.2090). The same literature proposed a three-layered taxonomy of context. The first layer enumerates types of context—Environmental, User, Hardware, Temporal, and Geographic. The second layer covers context management services—Service, Storage, Quality, Reflexivity, and Localization. The third layer covers context management tools—Composition, Migration, Adaptation, and Polymorphism (0909.2090).

A complementary representation appears in context-aware connectivity management, where all context information is represented as a 4-tuple, <entity name, feature, value, time>, and where raw context is distinguished from derived high-level context (Sen et al., 2010). This distinction between acquisition, storage, abstraction, and decision recurs throughout ACM research. Classical platforms also separate local and remote context, or distinguish context-dependent from context-independent functionality, so that adaptation can be localized to the parts of the system that actually vary with context (0909.2090, Magableh, 2019).

In LLM-oriented ACM, the object being managed is no longer only sensor or network state; it is also the interaction history itself. ACR formalizes the standard response problem as

$$a_t = \arg\max_{a \in \mathcal{V}^*} P_\theta(a\mid H_t, u_t)$$

and reframes ACM as finding a refactored history $\tilde{H}_t$ such that $P_\theta(a^*_t|\tilde{H}_t, u_t)$ is maximized (Shen et al., 9 Jan 2026). This redefinition is significant because it makes context management an explicit computational object rather than a passive side effect of longer prompts or larger memory stores.

2. Architectural lineages in wireless, mobile, and service-oriented systems

In wireless networking, ACM first appeared as an architectural problem: how context information reaches the centre of decision making under mobility, volatility, and limited resources. A comparative treatment identifies four main context management strategies—Centralized, Hierarchical, Distributed, and Hybrid—and links each to different adaptation properties (Giadom et al., 2014). Centralized management uses a single control point and supports rapid decision-making if resources are sufficient, but its adaptation is limited by bottlenecks and by low extensibility and flexibility. Hierarchical management partitions the network into domains with domain managers and a “Manager of Managers” above them; it supports scalability, reduced bandwidth, and dynamic reconfiguration through dynamically loaded Network Management Procedures. Distributed management uses peer-to-peer managers with no single points of failure and supports high modularity, scalability, and reliability. Hybrid management combines hierarchical aggregation with distributed peer-to-peer communication and is rated “Very Good” on autonomy, extensibility, and flexibility in the paper’s comparison table (Giadom et al., 2014).

Mobile middleware work generalized these ideas from network management to software adaptation. COSM-middleware, based on Context Oriented Software Development, decomposes software into context-dependent and context-independent functionalities and uses context-oriented components with multiple layers, each associated with a specific runtime condition (Magableh, 2019). Its adaptation engine includes a Context Manager, Component Manager, Policy Manager, Decomposition Manager, Adaptation Manager, and Verification Manager. Adaptation is policy-driven through Decision-Policy Language (DPL), context binding is implemented with the Observer Pattern, and runtime composition uses delegation, decorator, bundle, invocation, adapter, and chain of responsibility patterns (Magableh, 2019). The same architectural idea reappears in ACAS, where context management is decoupled from service logic and runtime adaptation is woven by the Aspect Adaptations Weaver (A2W), which treats service adaptations as aspects (Hafiddi et al., 2012).

A related line of work framed ACM as dynamic architecture refinement. In distributed group communication support applications, four monitored parameters—available bandwidth, data communication priority, energy level, and available memory for processing—jointly determine the choice of configuration (0812.3716). Their weighted combination is written as

$$GR = \frac{a \cdot ER + \beta \cdot MR + \gamma \cdot BR + \mu \cdot LR}{a + \beta + \gamma + \mu},$$

with the link rate defined as $newLR = \min(GR_A, GR_B)$ (0812.3716). In context-aware end-to-end connectivity management, policies are represented as $P = (TC, RC, EI)$, and channel selection proceeds through policy traverse, cost matrix computation, and channel selection while accounting for user QoS parameters and switching costs (Sen et al., 2010). Across these systems, ACM is fundamentally about selective abstraction and selective actuation, not merely about sensing.

3. Caching, freshness, and distributed context infrastructures

A major branch of ACM research treats context as a volatile data product whose delivery quality depends on organization, lookup, caching, and refresh. A context data management system for wide-area context-aware computing encapsulates context sources into physical spaces belonging to context spaces and organizes them as peers in semantic overlay networks (Xue et al., 2020). Query processing is declarative and SQL-based, schema integration is handled by a name-based schema matching algorithm, and reasoning can occur at intra-space, intra-domain, and inter-domain levels (Xue et al., 2020). This is ACM at the data plane: adaptive organization of heterogeneous context sources so that applications can discover and retrieve fresh context efficiently.

The survey literature formalizes Adaptive Context Caching (ACC) as “The decision about what context to cache in near real-time to achieve cost efficiency goal(s) measured by Quality of Service (QoS) and Quality of Context (QoC) parameters,” with the additional requirement of using minimal necessary resources and ensuring minimum loss to quality of cached context (Weerasinghe et al., 2022). The survey identifies nine core functional requirements, including near real-time processing, logical coherence, cost-awareness, elasticity, resilience, gracefulness, reliability, non-intrusiveness, and query affinity (Weerasinghe et al., 2022). This formulation is important because it moves ACM from heuristic buffering to an explicitly multi-objective optimization problem.

Reinforcement-learning-based adaptive context caching makes this formulation operational. One line introduces selective context cache admissions without prior knowledge of context or query load, heuristic models for expected performance, and a time-aware continuous cache action space (Weerasinghe et al., 2022). Two agents are described: a value function estimating actor-critic agent and a policy search agent using deep deterministic policy gradient. The DDPGAgn achieved up to 60.2% improvement in cost efficiency over the redirector mode, while also improving response time and hit rate under scalable cache settings (Weerasinghe et al., 2022).

DCMF extends this logic with explicit freshness management inside a Context Management Platform. Its Context Evaluation Engine computes a utility score

$U(CI_i) = \sum_{j=1}^{m} w_j \cdot u_j(CI_i),$

a Probability of Access

$$\text{PoA}(CI_i) = \alpha \cdot \frac{h(CI_i)}{\sum_{k=1}^{n} h(CI_k)} + (1 - \alpha) \cdot \frac{q(CI_i)}{N},$$

and the Context Management Module computes Context Freshness as

$CF(CI_i) = e^{-\lambda \cdot \Delta t_i}$

before combining evidence with a hybrid Dempster-Shafer approach to decide whether to cache, evict, or refresh context items (Manchanda et al., 25 Apr 2025). On real-world smart city data, DCMF achieves a 12.5% higher cache hit rate and reduces cache expiry by up to 60% compared to the m-CAC technique (Manchanda et al., 25 Apr 2025). In this part of the ACM literature, adaptation is measured less by reasoning accuracy than by QoS, QoC, latency, freshness, and cost efficiency.

4. Active and adaptive ACM in dialogue, conversational QA, and RAG

LLM-era ACM begins from the claim that context failure is not solved by longer windows alone. ACR identifies two specific failure modes in multi-turn dialogue: contextual inertia, the tendency to stick with logical errors or irrelevant details introduced earlier, and state drift, the gradual divergence between the model’s state representation and the true underlying task state (Shen et al., 9 Jan 2026). Its architecture decouples context management from reasoning through a Router and a Refactorer, and it supplies a library of context refactoring operators: state abstraction, noise filtering, fact rectification, path pruning, cognitive boosting, key anchoring, and an identity operator (Shen et al., 9 Jan 2026). The training regime is teacher-guided and self-evolving rather than RL-based. Empirically, ACR reduces average tokens per turn from 1678 to 278.54 and reports 35.10 EM on HotpotQA versus 21.70 for SFT and 27.40 for DIoR, while using only about 3.8k trajectories (Shen et al., 9 Jan 2026).

Conversational question answering work uses a different decomposition. An ACM framework for ConvQA introduces a Context Manager (CM) Module, a Summarization (SM) Module, and an Entity Extraction (EE) Module, coordinated by Dynamic Context Window Adjustment (DCWA) (Perera et al., 22 Sep 2025). The context state is built from unmodified context, summarized context, and entity-extracted context:

$$C_n = Context_B + Q_n + EEC(\sum_{j=1}^{m-1} T_j) + SMC(\sum_{k=m}^{p-1} T_k) + UNC(\sum_{i=p}^{n-1} T_i).$$

In the reported experiments, all metrics improve over a pipeline baseline across RoBERTa, BERT-Large, mDeBERTa-v3, Llama-2-7b, Mistral-7B, and phi-2, with phi-2 showing +10.78 F1 and +12.90 ROUGE-1 (Perera et al., 22 Sep 2025).

RAG systems expose another ACM problem: scaling inefficiency and context contamination in multi-hop reasoning. SPARC-RAG addresses this by introducing specialized agents with a shared global context, explicit control of sequential and parallel scaling, and explicit regulation of exiting decisions based on answer correctness and evidence grounding (Yang et al., 22 Jan 2026). Its core memory operations are written as

$\tilde{H}_t$0

within branches and

$\tilde{H}_t$1

across branches (Yang et al., 22 Jan 2026). Across single- and multi-hop QA benchmarks, SPARC-RAG yields an average +6.2 F1 improvement under lower inference cost (Yang et al., 22 Jan 2026).

Sculptor formulates the same problem as Active Context Management rather than adaptive compression. It equips LLMs with tools for context fragmentation, summary/hide/restore, and intelligent search (Li et al., 6 Aug 2025). The framework is explicitly motivated by proactive interference and the “lost in the middle” effect. Reported gains include an increase on PI-LLM from 76.63 to 82.17 for GPT-4.1 and, on NeedleBench Multi-Needle Reasoning, an increase for Claude-4-Sonnet from 67.0 to 94.0 overall at 128K context (Li et al., 6 Aug 2025). The recurrent theme is that ACM becomes a first-class control layer over the model’s working context.

5. Long-horizon agents, budgeted trajectories, and frozen-agent managers

Long-horizon web and research agents make ACM an online control problem over growing trajectories. AgentSwing introduces a probabilistic framework that decomposes long-horizon success into search efficiency $\tilde{H}_t$2 and terminal precision $\tilde{H}_t$3, with

$\tilde{H}_t$4

Its method is state-aware adaptive parallel context management routing: at each trigger point, multiple candidate context management strategies are expanded in parallel, rolled out for a small $\tilde{H}_t$5-step lookahead, and then routed based on downstream promise (Feng et al., 29 Mar 2026). Across different backbones and benchmarks, AgentSwing often matches or exceeds static strategies with up to $\tilde{H}_t$6 fewer interaction turns (Feng et al., 29 Mar 2026).

AdaCoM adopts a different stance: context management should be learned by an external LLM managing the context of a frozen agent through structured modification actions and end-to-end reinforcement learning (Yi et al., 29 May 2026). The manager can delete, rewrite, merge, assign roles, justify, or perform a no-op on selected messages. The paper’s central empirical finding is a Fidelity-Reliability Trade-off: agents with higher vanilla ReAct performance benefit from higher-fidelity context preservation, whereas lower-performing agents require more aggressive compression to stay within a reliable reasoning regime (Yi et al., 29 May 2026). On BrowseComp-Plus, AdaCoM reports an average mean@3 increase of 39%, a best-ever relative gain of 95% improvement for Kimi, and cross-agent transfer improvements in 23/28 pairs with an average cross-agent gain of 25.0% (Yi et al., 29 May 2026).

BACM formalizes the same setting explicitly as a sequential decision problem under a context budget. Its budget-aware state is

$\tilde{H}_t$7

and the manager chooses a refinement action before appending the new observation so that

$\tilde{H}_t$8

The action space consists of Null, Partial, and Full commit-block aggregation, and BACM-RL trains this policy with a curriculum of tightening budgets (Wu et al., 2 Apr 2026). On compositional multi-objective QA and long-horizon web browsing, BACM-RL achieves over $\tilde{H}_t$9 gains over strong baselines in high-complexity settings and remains strong as budgets shrink, where most methods exhibit a downward performance trend (Wu et al., 2 Apr 2026).

A deployment-oriented variant appears in on-device agents. There, ACM is instantiated as a dynamic memory system that distills history into a compressed, structured Context State Object (CSO), together with a minimalist serialization format for tool schemas and a just-in-time schema-passing mechanism (Vijayvargiya et al., 24 Sep 2025). The update cycle is

$P_\theta(a^*_t|\tilde{H}_t, u_t)$0

with separate LoRA adapters for execution and state tracking (Vijayvargiya et al., 24 Sep 2025). The framework reports more than a 6-fold reduction in initial system prompt context and a 10- to 25-fold reduction in context growth rate while matching or exceeding a conventional baseline (Vijayvargiya et al., 24 Sep 2025).

6. Reversibility, self-managed context, and recurrent design tensions

Recent ACM work increasingly treats irreversibility as a core limitation. ACE argues that truncation and summarization are inherently inflexible and irreversible, and introduces a two-layer architecture: a lossless message maintenance layer storing both raw and abstracted history, and a context orchestration layer that assigns each historical step an elastic type—raw, abstract, or drop—at every decision step (Liao et al., 30 Jun 2026). The prompt context is constructed as

$P_\theta(a^*_t|\tilde{H}_t, u_t)$1

where $P_\theta(a^*_t|\tilde{H}_t, u_t)$2 selects raw, abstracted, or omitted content according to the predicted elastic type (Liao et al., 30 Jun 2026). ACE is adapted to ReAct, DeepAgent, WebThinker, and MiroFlow without training or architectural modifications and consistently outperforms truncation and summarization baselines (Liao et al., 30 Jun 2026).

VISTA pushes the argument further by claiming that LLM agents are “proprioceptively blind” to their own context and that competent context management is already latent in capable models if the right interface is exposed (Xu et al., 29 Jun 2026). Its training-free, model-agnostic layer represents working memory as typed, addressable blocks, surfaces per-block token usage, recency, and access history in a runtime dashboard, and archives blocks as recoverable full-fidelity payloads (Xu et al., 29 Jun 2026). On LOCA-Bench, it improves Gemini-3-Flash from 22.7 to 50.7%, and ablations show that removing the dashboard drops accuracy from 50.7% to 37.3%, indicating that the dashboard matters beyond archive and recovery tools (Xu et al., 29 Jun 2026).

Across the literature, three tensions recur. First, more context is not necessarily better. ACR, Sculptor, SPARC-RAG, AgentSwing, and BACM all identify degradation caused by context accumulation rather than by mere lack of window length (Shen et al., 9 Jan 2026, Li et al., 6 Aug 2025, Yang et al., 22 Jan 2026, Feng et al., 29 Mar 2026, Wu et al., 2 Apr 2026). Second, ACM may be system-controlled, externally managed, or agent-visible. COSM, ACAS, and AdaCoM emphasize external policy or middleware control, whereas Sculptor, VISTA, and ACE emphasize explicit tools or state visible to the model itself (Magableh, 2019, Hafiddi et al., 2012, Yi et al., 29 May 2026, Li et al., 6 Aug 2025, Xu et al., 29 Jun 2026, Liao et al., 30 Jun 2026). Third, compression must be balanced against recoverability and fidelity. AdaCoM’s Fidelity-Reliability Trade-off, BACM’s budget-conditioned compression, ACE’s reversible raw/abstract/drop orchestration, and VISTA’s lossless archival all treat this balance as central rather than incidental (Yi et al., 29 May 2026, Wu et al., 2 Apr 2026, Liao et al., 30 Jun 2026, Xu et al., 29 Jun 2026).

This suggests that ACM is best understood not as a single algorithmic trick but as a general systems problem: deciding what context exists, how it is represented, which parts remain active, which are abstracted or cached, when they are refreshed or recovered, and how those choices are coupled to resource limits, task state, and adaptation objectives. In that broader sense, the ACM literature links early work on wireless and context-aware systems with current work on dialogue, RAG, web agents, and on-device models through a shared concern with selective context preservation under uncertainty and bounded capacity (Giadom et al., 2014, Weerasinghe et al., 2022, Shen et al., 9 Jan 2026, Yi et al., 29 May 2026).