GenericAgent: Why Information Density is the Secret to Self-Evolving AI
GenericAgent: A Token-Efficient Self-Evolving LLM Agent via Contextual Information Density Maximization (V1.0)
GenericAgent (GA) is a self-evolving LLM agent system designed for long-horizon tasks, achieving state-of-the-art performance on benchmarks like Lifelong AgentBench and SOP-Bench. It introduces a "Contextual Information Density Maximization" principle, outperforming systems like Claude Code and OpenClaw while using up to 89.6% fewer tokens through recursive experience distillation.
TL;DR
The Advantage AI Agent Lab (A3 Lab) has introduced GenericAgent (GA), a system that challenges the "bigger is better" dogma of LLM context windows. By focusing on Contextual Information Density Maximization, GA outperforms industry leaders like Claude Code by using significantly fewer tokens. It doesn't just remember tasks; it evolves, turning messy trial-and-error into lean, executable Python code.
The Problem: The "Fat" Context Trap
In long-horizon tasks, agents usually drown in their own history. Every tool description, retrieved memory, and environment observation competes for the LLM's limited "effective attention." This leads to:
- Positional Bias: The model forgets the middle of the prompt.
- Attention Dilution: Irrelevant logs distract from critical constraints.
- Token Bloat: Costs skyrocket while reasoning quality hits a ceiling.
Methodology: The Four Pillars of Density
GA is built on the philosophy that "Conciseness + Completeness = Performance." It implements this via 9 atomic tools and a sophisticated memory hierarchy.
1. Tool Minimality
Instead of 50+ specialized tools, GA uses 9 primitives (e.g., code_run, file_patch). Complex behavior is composed, not pre-defined. This keeps the initial prompt overhead minimal.
2. Hierarchical Memory (L1-L4)
GA categorizes memory into four layers:
- L1 (Index): Compact pointers (Always-on).
- L2/L3 (Facts/SOPs): Deep knowledge accessed only via tool calls.
- L4 (Archive): Raw logs for traceability, never injected into the active context.
3. Self-Evolution: From Words to Code
This is GA’s "Killer Feature." When GA solves a task, it doesn't just save the log. It runs a reflection loop:
- Natural Language SOP: Distills the success path.
- Codification: Transforms the SOP into a reusable Python script. In future runs, the agent simply executes the script, bypassing expensive reasoning cycles entirely.
Results: Efficiency is the New SOTA
The experiments prove that "less is more." On the Lifelong AgentBench, GA reached 100% accuracy while consuming roughly 15% of the tokens used by OpenClaw.
As shown in the charts, GA exhibits a clear efficiency convergence. While competitors' costs remain flat and high, GA's token consumption drops sharply as it "learns" and codifies its experience. In one GitHub research task, token usage plummeted from 222k to just 23k by the ninth run—a 89.6% reduction.
Critical Insight: The Minimalist Advantage
The paper makes a bold claim: Minimal architecture is a prerequisite for evolution. With only 3,300 lines of code, the entire GA system is readable by the LLM itself. This opens the door to a future where agents don't just solve tasks, but actually rewrite their own source code to optimize their underlying architecture.
Conclusion
GenericAgent proves that the bottleneck in AI agents isn't context length—it's representation. By treating context as a scarce resource to be optimized through distillation and codification, GA provides a blueprint for autonomous systems that actually get cheaper and faster the more we use them.
Takeaway: In the era of 1M+ context windows, the smartest agents will be the ones that choose to use the fewest tokens.