hello-generic-agent: a Chinese-language guide to the Generic Agent design

This repository holds the guide, not the agent

The first thing to establish is what the repository is. The top level of the tree contains a .github directory, a .gitignore, a README, a docs directory, a package.json and a package-lock.json, and nothing that looks like an agent runtime. The project description calls it a usage guide for the Generic Agent, and the README points readers to the Generic Agent main repository at github.com/lsdefine/GenericAgent for the actual software. So this is a companion text, and the interesting question is what it documents and how. The scope is ambitious for a first release: a three-part structure covering application guidance, underlying principles and practical cases, and the tag list shows two releases, v1.0.0 and v1.0.2, both dated 2026-05-06. The last push to the repository was on 2026-05-12, and the repository is not archived. The README marks the whole thing as a beta public test with a note that the main body of the tutorial is complete while details are still being refined.

Three parts, thirteen chapters and five worked cases

The table of contents is the clearest statement of intent. The application guide runs from installation and environment setup through environment configuration, API key setup and starting the GUI or the command line, then browser capability through a tmwd_cdp_bridge plugin, then a first hour covering the interface, OCR and vision, a messaging CLI, file search and multi-turn conversation, then the memory and skill system, then chat platform integration for WeChat, Feishu, DingTalk, QQ, Telegram and WeCom, and finally advanced techniques covering autonomous action mode, scheduled tasks, Reflect mode, sub-agents and Plan mode. The principles part then takes apart the design, with chapters on context information density maximisation as the first principle, the system architecture with a unified agent loop and two execution modes, the minimal atomic tool set, the layered memory architecture, context truncation and compression, self-evolution, and emergent capabilities. The cases part applies it, with worked scenarios around sending messages on social apps, reading a trending list with a logged-in browser, building a social profile summary, downloading video for offline viewing, and semantic classification of a Bilibili favourites folder. Every chapter in the listing is marked as complete, which is a claim about the tutorial's coverage and not about the agent's behaviour.

The stated numbers are claims to test, not results to quote

A documentation project can state performance figures about the thing it documents, and this one does, which means a reader has to sort those figures from claims the guide is making. The target audience section says the token usage efficiency of the agent is 10x to 30x that of Openclaw, and that given a day it can evolve into a personal assistant. The chapter descriptions make more specific claims: the minimal atomic tool set covers five capability categories with nine atomic tools and consumes only 35% of the tokens Claude Code does, the context compression pipeline holds context under 30k tokens, and the three-stage self-evolution path from natural language to SOP to code execution saves 89.6% of tokens. The chapter on emergent capabilities says that combining three simple primitives produces sub-agents, watchdog behaviour and scheduled tasks. None of these figures come with a methodology, a benchmark script or a machine description in the repository, so they should be read as the guide's characterisation of the design and its own testing, not as independent measurement. If token cost is your reason to look at the agent, verify it yourself with a workload you already understand.

The site is built with VitePress and MathJax

The publishing tooling is small and conventional. The package.json declares a VitePress build with a MathJax 3 markdown plugin and an image viewer plugin, and exposes four scripts.

  "scripts": {
    "docs:dev": "vitepress dev docs",
    "docs:build": "vitepress build docs",
    "docs:preview": "vitepress preview docs",
    "export:pdf": "node scripts/export-pdf.mjs"
  },

The dev script serves the docs directory locally with hot reload, the build script produces the static site, the preview script serves the built output, and the export script runs a Node script to produce a PDF. The dependency versions show where this sits in time: VitePress is pinned at an alpha version, 2.0.0-alpha.15, and the MathJax plugin at 4.3.2, which is a reasonable signal that the site is built on a pre-release of the documentation framework. The published site lives at a GitHub Pages address, and the README points to it as the way to read without downloading anything. The PDF export is worth noting for a Chinese-language guide, since a printable version is more useful for study than a web page for many readers, and the script path in the package file is the one place the repository reveals how that is produced.

The memory model is the part worth reading first

If you only read one chapter, the principles part is where the durable value is. The layered memory chapter describes four layers running from an L1 index through L2 facts to L3 standard operating procedures and an L4 archive, together with an on-demand loading strategy, and the memory and skill chapter in the application part covers the same four layers, skill distillation, and skill search and migration. Skill distillation is the idea that a procedure the agent has performed successfully can be compressed into a reusable artifact, and it connects directly to the self-evolution chapter, which describes a three-stage path where a natural language instruction becomes an SOP and then an executable script. That progression is the mechanism behind the token savings the guide claims, because a distilled procedure replaces a long chain of reasoning with a short reference. The context compression chapter is the counterpart, describing a four-level compression pipeline that keeps the working context bounded. Taken together, these three chapters describe an agent that spends its context budget deliberately, which is the design philosophy the whole document is organised around, and it is the part that transfers even if you never install the agent.

What this guide is not, and who it leaves out

There are clear gaps, and the honest reading of them matters more than the marketing tone. The documentation is written in Chinese, with a language badge in the README marking it as such, so an English-only reader cannot use it as-is. The cases section is where the ethics and legality are thinnest, since it covers scraping a logged-in social session, distilling a personality profile from published posts, and downloading video streams for offline viewing using a logged-in browser, and none of those chapters come with a note about terms of service, account risk or personal data handling. The project is also explicitly a beta, with the README inviting issues about the parts still being refined. The audience section names developers and hobbyists who are still comparing self-evolving agents and who are frustrated by high token consumption, which tells you the intended reader is someone with prior agent experience rather than a newcomer. Nothing in the guide explains licensing of the agent itself, and the guide's own licence, CC BY-NC-SA 4.0, permits reuse of the documentation with attribution for non-commercial purposes, which is a constraint worth reading before you fork the text.

A curated guide versus reading the upstream repository

The alternative to a guide like this is to read the agent's own repository and its documentation directly, or to work from the design ideas as described in blog posts and discussions. The difference in approach is curation and ordering. A guide can impose a sequence, in this case install and use first, then principles, then cases, and it can name the specific concepts a reader would otherwise assemble from scattered sources, such as the four memory layers with their on-demand loading, the two execution modes, and the distinction between the minimal atomic tool set and the higher-level behaviour that emerges from combining primitives. A guide can also point at real worked situations with concrete instructions, such as the five-step flow of activating a window, searching a contact, verifying the conversation, sending text or images or files and verifying the result. The cost is staleness and opacity. A guide can lag the software it documents, and this one carries two releases from a single day with no follow-up tagged since, and its numbers cannot be reproduced from the repository alone. If you want to know exactly how the agent behaves today, read the code; if you want the shape of the ideas explained in a structured way, this is a reasonable starting point for a Chinese-reading audience.

Editorial conclusion

Adopt this guide if you read Chinese and want a structured walkthrough of the Generic Agent, particularly its memory layering, context compression and self-evolution ideas, or if you want the VitePress tooling as a starting point for your own tutorial site. Skip it if you need English documentation or if you are looking for the agent implementation itself, which lives in a separate main repository. Verify first which Generic Agent release the text describes, since the guide is marked as a beta public test and both tagged releases date to 2026-05-06, and note that the documentation itself is licensed CC BY-NC-SA 4.0.

Frequently asked questions

Official sources

1. datawhalechina/hello-generic-agent on GitHub
2. Issues
3. Project website
4. README
5. Releases