A project called GenericAgent on GitHub has a blunt description: "Self-evolving agent: grows skill tree from 3.3K-line seed, achieving full system control with 6x less token consumption." 10,221 stars, 577 added today alone. 585 commits, latest one an hour ago.
Numbers first, then what it actually does.
Core Idea: Agents Should Not Rely on Human-Fed Prompts — They Should Grow Their Own Abilities
Most agent frameworks work like this: developers write a tool list, define prompt templates, set up workflows, and the agent runs inside that box. The agent's capability ceiling is whatever the developer stuffed into it.
GenericAgent flips it: it starts from a 3,300-line seed code and builds a skill tree on its own. The tree is not pre-defined — it grows through interaction with the system. When it encounters a new scenario, it decides what capability it needs and generates the corresponding skill node.
The claimed benefit is 6x less token consumption. The logic holds up: traditional approaches carry full tool descriptions and context every time, while a skill tree only loads the branches relevant to the current task, naturally saving tokens.
Looking at the Repo
A few details worth noting:
Very active. 585 commits, latest update an hour ago. 39 open issues, 20 PRs — community engagement is solid. Author lsdefine is committing almost daily.
Chinese community DNA. The README has Feishu display handling (replace alarming warning with neutral "(no text output)" in feishu display), and the docs directory has WeChat group QR code updates. This is not a pure English project targeting overseas communities — it is rooted in the Chinese developer ecosystem.
Clean module structure. The repo is split into memory, plugins, frontends, and reflect. The reflect directory just got a lightweight goal mode reflect workflow added yesterday, showing the project is actively expanding its capability boundaries.
Where Does 6x Token Savings Come From
This number needs a question mark. There is no complete benchmark report (at least I did not find third-party reproduction results in the README or issues). But the logic chain is clear:
- Traditional: every Agent call loads all tool descriptions (dozens to hundreds of tools)
- Skill tree: only load the skill branches relevant to the current goal (maybe a few nodes)
- Self-evolution means unused skills get pruned, further shrinking context
If this logic holds in real workloads, 6x is plausible. But run it against your own scenarios — skill tree branch density varies significantly across different task types.
Worth Trying?
Yes, with two caveats:
First, your use case needs clearly separable "skills." If your Agent always does the same thing, the skill tree does not add much value. If it needs to switch across task types (coding, database queries, report generation), then skill tree path selection actually matters.
Second, you are comfortable with a Chinese-first ecosystem. Documentation and community are primarily in Chinese. If you need English-first support, you may want to wait.
Bottom line: self-evolving agents are not a new concept, but GenericAgent tells a coherent story by tying skill trees to token efficiency, and the code is actually running. Installing it costs you nothing.
Main sources: