GenericAgent: A Token-Efficient Self-Evolving LLM Agent via Contextual Information Density Maximization (V1.0)

Abstract: Long-horizon LLM agents are fundamentally limited by context. As interactions become longer, tool descriptions, retrieved memories, and raw environmental feedback accumulate and push out the information needed for decision-making. At the same time, useful experience gained from tasks is often lost across episodes. We argue that long-horizon performance is determined not by context length, but by how much decision-relevant information is maintained within a finite context budget. We present GenericAgent (GA), a general-purpose, self-evolving LLM agent system built around a single principle: context information density maximization. GA implements this through four closely connected components: a minimal atomic tool set that keeps the interface simple, a hierarchical on-demand memory that only shows a small high-level view by default, a self-evolution mechanism that turns verified past trajectories into reusable SOPs and executable code, and a context truncation and compression layer that maintains information density during long executions. Across task completion, tool use efficiency, memory effectiveness, self-evolution, and web browsing, GA consistently outperforms leading agent systems while using significantly fewer tokens and interactions, and it continues to evolve over time. Project: https://github.com/lsdefine/GenericAgent

• The paper presents a novel GA framework utilizing a minimal atomic tool set and hierarchical memory to maximize contextual information density.
• It employs layered context compression and reflection-driven self-evolution to ensure sublinear prompt growth and improved efficiency.
• Empirical results confirm GA’s superior performance with lower token consumption, achieving task completion at a fraction of traditional methods' costs.

GenericAgent: Maximizing Token Efficiency and Self-Evolution in LLM Agents

Motivation and Systemic Constraints

LLM agents face systemic context management challenges when deployed for long-horizon tasks. As agents interact with environments—accumulating tool schemas, intermediate results, and memory traces—context length grows linearly while effective model attention does not, leading to degraded reasoning, loss of task-critical evidence, and increased hallucination propensity due to attention dilution and finite effective context window (Liu et al., 2023) [an2024doeseffectivecontextlength]. The primary structural constraint is information density: maximal preservation of decision-relevant knowledge within the limited context available at each inference step, rather than expansion of raw prompt size. "GenericAgent: A Token-Efficient Self-Evolving LLM Agent via Contextual Information Density Maximization" (2604.17091) formalizes this as the core design principle and develops an integrated, model-agnostic agent framework, GA, which directly operationalizes it via architectural minimality, hierarchical and compressed memory, a reflection-driven self-evolution engine, and a highly controlled tool interface.

Figure 1: Completeness and conciseness define the core trade-off in context design, with GA balancing both for effective context representations.

Architectural Overview

GA’s agentic process is characterized by a tight agent loop which, at each timestep, constructs the execution context from the current task and hierarchical memory, delegates actions to external tools, records structured feedback, and continuously compresses and filters memory content.

Figure 2: GA’s framework showing the unified agent loop and the interaction of minimal tools, hierarchical memory, self-evolution, and browser-aware extraction.

Four foundational mechanisms instantiate the information density maximization objective:

• Minimal atomic tool set: Reduces decision and interface overhead, enabling compositional behavior through a core set of primitives (e.g., file operations, code execution, web interaction) rather than a proliferation of specialized tools.
• Hierarchical memory: Segments memory into always-on (index), fact, procedural (SOP), and archival layers, with on-demand retrieval from deep layers minimizing prompt bloat during active execution.
• Self-evolution via reflection: Distills traces of verified successful trajectories into compressed SOPs and executable code, guaranteeing that only stable, transferable strategies persist across tasks.
• Context truncation and compression: Multi-stage pipeline (truncation, tag-level compression, message eviction, anchor prompts) ensures that context grows sublinearly with task interaction count.

Tool Minimality and Compositionality

GA’s tool design enforces strict atomicity and compositional generalization. The action space includes only nine atomic tools covering reading, writing, patching, code execution, browser operations, memory updating, and user intervention. Each tool is responsible for an irreducible primitive capability, and more complex behaviors are composed rather than encoded as additional tools or plugins. This strategy contrasts directly with tool-rich agents such as Claude Code and OpenClaw, which expose upwards of 18–53 tools at the source level, but whose actual agent behavior is dominated by high-frequency primitives (as shown below).

Figure 3: Tool usage is highly concentrated, justifying the focus on a small atomic tool set as implemented in GA.

Empirically, GA achieves strong coverage of realistic long-horizon workflows by composing these primitives with negligible loss of generality, yet with marked reductions in token and interaction overhead.

Hierarchical Memory, Compression, and Context Control

Central to preventing context explosion is a four-layer hierarchical memory with dynamic on-demand routing. The L1 index (always-on) provides high-information-density pointers; L2 (fact) and L3 (SOP) layers capture verified factual and procedural knowledge, updated via a validated commit mechanism; L4 archives raw session traces. Critically, only L1 and meta-memory are loaded by default, and L2/L3 materials are injected strictly on explicit retrieval. The architecture is organized such that memory accumulation does not map to prompt growth—a common point of failure in prior agent systems.

The context compression pipeline is essential for sustained operation over hundreds or thousands of turns. Layered strategies ensure that only the most recent or decision-relevant information survives:

• Tool outputs are truncated using head–tail selection.
• Tag-level message fragments are further compressed, eliminating redundant text.
• Old messages are evicted when cumulative context exceeds a strict threshold, with always-injected working-memory anchors maintaining task state.

These strategies collectively guarantee that the context budget remains tightly coupled to current decision needs.

Self-Evolution: Reflective Compression and Autonomy

GA’s self-evolution is not a passive result of history accumulation but an explicit process: after each task, validated sequences are compressed and elevated to reusable SOPs or direct code modules. The pipeline encodes strict rules: only successfully executed patterns are promoted (“No Execution, No Memory”), and speculative or failed trajectories are systematically discarded. Structural escalation for error recovery (localized retry → global strategy shift → human intervention) ensures robust convergence and guards against local minima or stagnation loops.

Through repeated execution (e.g., GitHub PR research tasks), GA is shown to transition from high-entropy, exploration-heavy behavior to low-cost, deterministic, and SOP-driven execution regimes—reducing both call count and per-call token overhead with each iteration.

Figure 4: Operation time and token cost show sharp convergence in GA across repeated sessions, unlike baselines.

This cross-task convergence holds robustly even on previously unseen tasks, with efficient SOP adaptation and systematic efficiency improvement across repeated runs.

Figure 5: Token consumption per task sharply declines for GA across repeated runs, unlike for OpenClaw.

Empirical Results

GA demonstrates superior or SOTA-level task completion and token efficiency across multiple demanding agent benchmarks, including SOP-Bench, Lifelong AgentBench, and RealFin-benchmark. Notably:

• Lifelong AgentBench: GA attains 100% task completion at only 27.7% of Claude Code’s token cost.
• SOP-Bench: GA obtains 100% accuracy, outperforming all tool-rich baselines on efficiency/accuracy trade-off.
• Web Browsing (WebCanvas, BrowseComp-ZH): GA sustains performance at 2.9x–3.9x lower token consumption than OpenClaw.

  Figure 6: GA achieves competitive or better normalized scores with dramatically lower token consumption on web tasks.

Hierarchical memory and strict context compression prevent context explosion even after extensive skill installation and history accumulation—post-usage prompt length is an order of magnitude less than OpenClaw and Claude Code.

Practical and Theoretical Implications

The findings in (2604.17091) have systemic implications:

• Context information density is a structural, model-agnostic constraint. All agent behaviors must be decomposed into interface, context management, and memory formation, with any further agent complexity actively degrading effective information density.
• Lower token usage correlates with higher agent quality in long-horizon tasks. Contrary to some beliefs, increased context does not translate into improved reasoning for LLM agents under realistic prompt windows.
• Self-evolving architectures with minimal primitives enable not just skill accumulation but the prospect of architectural self-improvement—a system implemented within a few thousand lines of code can, in principle, be navigable and editable by subagents, unlike legacy agent platforms of hundreds of thousands of lines.

Conclusion

GenericAgent advances LLM agent architectures by introducing a principled, empirically-verified approach to token-efficient, self-evolving, general-purpose agency. Key design commitments—atomic tool minimality, hierarchical information-dense memory, explicit self-evolution, and layered context compression—are shown to be incident to strong efficiency–performance trade-offs on diverse benchmarks and practical tasks. These results emphasize that the major limiting factor in LLM-based agentic systems is contextual information density, rather than sheer parameter scale, toolset richness, or prompt length.

Future research should explore self-improving agent architectures where skill, tool, and even core agent logic are themselves subject to reflective distillation and code-level evolution, under the same constraints of context density and operational verifiability. The open-source release of GA establishes a concrete platform for further systematic study.