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

1. Problem Statement

The paper identifies two fundamental bottlenecks limiting the performance of long-horizon Large Language Model (LLM) agents:

• Context Explosion: As agents interact with environments, prompts accumulate tool definitions, retrieved memories, and raw feedback. This growth exceeds the model's effective attention window (which is significantly smaller than the nominal token limit), leading to positional bias, attention dilution, and hallucinations. The core issue is not the length of the context, but the density of decision-relevant information within it.
• Ineffective Experience Accumulation: Current agents often treat tasks as stateless episodes. Valuable knowledge (user preferences, tool behaviors, successful strategies) gained during execution is lost once the context window expires or the session ends. This forces agents to "rediscover" solutions repeatedly, leading to linear token costs with no return on investment.

Existing frameworks fail to address these issues because they rely on monolithic prompt assembly, raw log storage, and lack feedback-driven refinement mechanisms.

2. Core Philosophy: Contextual Information Density Maximization

The authors propose that agent performance is determined not by context length, but by Contextual Information Density. The system must maximize the ratio of decision-relevant information to total context tokens. This is achieved by balancing two primary constraints:

1. Completeness: All information necessary for the current decision must be present.
2. Conciseness: Irrelevant and redundant information must be eliminated.
   Naturalness is a secondary constraint to ensure the compressed representation remains semantically legible.

3. Methodology: The GenericAgent (GA) Architecture

GA is a self-evolving agent system built around four interconnected components designed to maintain high information density:

A. Minimal Atomic Tool Set

Instead of a large inventory of specialized tools, GA uses a minimal set of 9 atomic primitives (e.g., file_read, file_patch, code_run, web_scan, web_execute_js).

• Principle: Tools are designed as irreducible primitives. Complex behaviors are achieved through composition rather than enumeration.
• Benefit: Reduces prompt overhead (tool schemas) and decision complexity (action space), preventing low-value interface information from occupying the context budget.

B. Hierarchical On-Demand Memory

GA organizes memory into a four-layer architecture to prevent context bloat:

• L1 (Index Layer): Always-on, lightweight pointers to knowledge categories (e.g., "SOPs exist for X").
• L2 (Fact Layer): Verified, stable factual knowledge.
• L3 (SOP Layer): Reusable procedural knowledge (workflows, debugging strategies).
• L4 (Raw Archive): Historical session logs for traceability, not active context.
• Mechanism: Only the L1 index is injected by default. Deeper layers (L2/L3) are retrieved on-demand via tool calls only when specific knowledge is required, keeping the active context lean.

C. Self-Evolution Pipeline

GA transforms raw interaction trajectories into reusable assets through a reflection-driven process:

• Consolidation: Successful execution traces are compressed into Standard Operating Procedures (SOPs) and executable code.
• Filtering: A "No Execution, No Memory" rule ensures only verified, successful paths are promoted to long-term memory (L2/L3). Failed attempts are discarded to prevent memory pollution.
• Evolution: Over time, the agent's knowledge base shifts from verbose natural language instructions to compact, executable logic, reducing the need for reasoning in future similar tasks.

D. Context Truncation and Compression

To manage long-horizon execution within a strict budget (targeting <30k tokens):

• Tool-Output Truncation: Limits the size of individual tool return values (head-tail policy).
• Tag-Level Compression: Removes redundant XML tags and reasoning traces from older messages.
• Message Eviction: Removes the oldest messages when the budget is exceeded, but preserves a Working-Memory Anchor (a compressed summary of recent turns and key constraints) injected into every new prompt to maintain continuity.

4. Key Contributions

1. Theoretical Framework: Reframes agent design from "context length" to "information density," identifying the structural tension between completeness and conciseness.
2. System Architecture: Introduces a minimalist, self-evolving agent (GA) that achieves high performance with a tiny codebase (~3,300 lines) and a minimal toolset.
3. Emergent Capabilities: Demonstrates that complex behaviors like Subagent Dispatch (parallel task execution) and Reflect Mode (autonomous watchdog/scheduled tasks) emerge naturally from the CLI-based architecture without needing dedicated subsystems.
4. Autonomous Exploration: GA can autonomously generate and execute exploration tasks to expand its own skill tree, using a weighted scoring system (Breadth, Depth, Utility, Innovation) to decide what to learn next.

5. Experimental Results

GA was evaluated against leading agents (Claude Code, OpenClaw, CodeX) across five dimensions:

• Task Completion & Token Efficiency:

  • GA achieved 100% accuracy on SOP-Bench and Lifelong AgentBench, matching or exceeding baselines.
  • Token Savings: GA used significantly fewer tokens (e.g., 222k input tokens vs. 1.43M for OpenClaw on Lifelong AgentBench) while maintaining higher success rates.
  • Efficiency Ratio: GA achieved the highest efficiency (Accuracy per Million Tokens) across all benchmarks.

• Tool-Use Efficiency:

  • Despite having only 9 tools (vs. 53+ in Claude Code), GA solved complex long-horizon tasks (PDF generation, SQL, research) with 100% success, using 35% of the tokens required by Claude Code.
  • Tool usage distribution showed GA's active loop is highly concentrated, avoiding the "long-tail" overhead of unused tools in other systems.

• Memory Effectiveness:

  • Continuous Improvement: GA's token consumption dropped by ~50% and runtime by ~35% over repeated runs as experience was distilled into SOPs.
  • Fact Retention: Outperformed embedding-based retrieval systems (Mem0, A-MEM) on multi-hop and temporal reasoning tasks without using external vector databases.
  • Context Control: Even after installing 20 skills, GA's prompt length remained ~2,300 tokens, whereas baselines exploded to >40,000 tokens.

• Self-Evolution:

  • In a 9-round evolution study, GA reduced total token consumption by 89.6% (from 222k to 23k) and runtime by 78% as it transitioned from trial-and-error to codified SOP execution.
  • Cross-task benchmarks showed consistent token savings (61–92%) across diverse tasks, proving the generalizability of the evolution mechanism.

• Web Browsing:

  • GA outperformed OpenClaw on WebCanvas, BrowseComp-ZH, and custom real-world tasks, achieving higher scores with 2.9x to 3.9x fewer tokens. This was attributed to its ability to compress raw HTML/DOM into high-density semantic observations.

6. Significance and Conclusion

The paper argues that lower token consumption correlates with better task performance in long-horizon settings, as high token usage often indicates context management failures (redundancy, hallucination) rather than deeper reasoning.

Key Takeaways:

• Minimalism is Powerful: A small, composable toolset and a minimalist architecture enable emergent capabilities (subagents, autonomous exploration) that complex frameworks struggle to implement efficiently.
• Self-Evolution is Viable: Agents can autonomously convert raw experience into executable code and SOPs, creating a compounding return on investment for repeated tasks.
• Design Shift: Future agent design should prioritize information density and active context management over simply increasing context window sizes or adding more tools.

GenericAgent demonstrates that by strictly optimizing for the quality of information within the context window, agents can achieve superior performance, stability, and cost-efficiency in real-world, long-horizon environments.