# CountBot: a Chinese-first AI agent hub that runs on your own machine

> CountBot is a Python AI agent framework and runtime hub aimed at Chinese-speaking users, wiring LLMs, chat channels, teams and tools into one locally hosted process. It is MIT-licensed, the last push was on 2026-09-04, and the README states the author will not keep updating it in the short term.

**countbot-ai/CountBot** — 更适配中文用户的轻量开源AI Agent | 国产大模型Coding plan支持 | 兼容OpenClaw Skills生态| 已接入微信ClawBot/微博龙虾/飞书/钉钉/QQ/小智AI/Telegram/deepseek-v4。

- Repository: https://github.com/countbot-ai/CountBot
- Website: https://countbot.cn
- Stars: 782 · Forks: 102
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/countbot-ai-countbot

## What CountBot is, and the gap it tries to fill

CountBot describes itself as a lightweight AI agent framework and runtime hub for Chinese users. The README frames the project as a complement to OpenClaw: OpenClaw proved the local-execution, autonomous-agent path, and CountBot aims at the gaps around it, which the README lists as Chinese-language adaptation, lightweight deployment, ease of extension, and security governance. That is a positioning statement, not a benchmark, but it does explain the shape of the codebase. The repository is Python, MIT-licensed, and organized around a backend/ package with a frontend/ web UI, plus start_app.py, start_desktop.py and start_dev.py as entry points. The intended user is someone who wants an assistant reachable from WeChat, Feishu, DingTalk, QQ, Telegram or a browser, running on their own hardware, configured by conversation and a web panel rather than by writing agent code. The README also lists a desktop build for Windows, macOS and Linux distributed through GitHub and Gitee releases, which suggests the project expects non-developers among its users. That ambition has a cost, and the README is upfront about it in the project status section: the author will not keep updating CountBot in the short term, and it is now mainly intended for learning, research and secondary development. Anyone evaluating it should read that line before anything else.

## Agent loop, teams and the layered config model

The core is a ReAct-style agent loop: reason, call a tool, feed the result back, iterate, with control over when to stop. Around that loop the README describes three collaboration modes for Agent Teams, named pipeline, graph and council. Those names appear in the v0.3.0 release notes as the first systematic landing of multi-agent collaboration, and v0.5.0 is where the team model matured to support role division, context handoff and team-level orchestration. The configuration model is the part worth understanding before you commit. It is layered: global defaults, then role-level, then team-level, then session runtime config, with team-level model overrides on top. v0.4.0 introduced session-level config so different conversations can use different models and prompts. That layering is the mechanism that makes multi-channel deployment possible, because one workspace can serve several channels and several bots, each with its own persona and model, without duplicating the process. The trade-off is that when a setting does not take effect, you have four places to look. The README points to a separate configuration manual rather than documenting the precedence order inline, so plan on reading that page before debugging anything.

## Installing CountBot from source and starting the server

The README gives two installation routes: source and a packaged desktop build. The source route is the one you can inspect. Clone the repository, install the pinned requirements, and run the start script. Note that the README offers an Aliyun PyPI mirror for users on mainland Chinese networks, and a Gitee mirror for the clone itself if GitHub is slow.

```bash
git clone https://github.com/countbot-ai/CountBot.git
cd CountBot
pip install -r requirements.txt
python start_app.py
```

After the process starts, the README says the app opens at http://127.0.0.1:8000 by default. The listening address and port can be overridden with two environment variables, and the README states the precedence explicitly: COUNTBOT_HOST and COUNTBOT_PORT take priority over the defaults. On Windows PowerShell the example looks like this.

```powershell
$env:COUNTBOT_HOST = '0.0.0.0'
$env:COUNTBOT_PORT = '8001'
python start_app.py
```

For development the README shows running the ASGI app directly with uvicorn and autoreload, which is the faster loop if you are modifying backend code.

```bash
uvicorn backend.app:app --reload --host 0.0.0.0 --port 8000
```

What you should see is a web UI at the address you configured. The README does not document what the first-run screen asks for, so expect to consult the quick-start guide at countbot.cn before you have a working assistant. The requirements file also matters here: mcp, jieba and numpy are listed as optional and commented out, and the file states that MCP is off by default and that jieba falls back to single-character tokenization and numpy falls back to pure-Python cosine similarity if you skip them. Only uncomment what you need.

## Channels, tools and the external coding-tool bridge

The channel matrix is the most concrete thing CountBot offers. The README lists WeChat via ClawBot, Weibo, Feishu, DingTalk, WeCom, QQ, Xiaozhi AI and Telegram, with QQ, DingTalk, Feishu and Telegram backed by real SDK dependencies in requirements.txt (qq-botpy, dingtalk-stream, lark-oapi, python-telegram-bot). v0.6.0 added multi-account WeChat ClawBot binding. On the tool side the README lists file operations, Shell, web access, screenshots, memory, workflows and media sending. The unusual piece is the external execution bridge added in v0.6.0: Claude Code, Codex and OpenCode can be attached either as tools that the agent calls, or as agents that themselves connect to IM channels. That second mode is worth pausing on, because it inverts the usual arrangement. Instead of CountBot driving a coding tool, the coding tool becomes the conversational front end and CountBot supplies the channel plumbing. The README does not explain how state is shared between the two directions, so if you depend on that bridge, read the backend code rather than the docs. Two other mechanisms from the release notes are worth knowing: v0.9.0 added API key rotation with failover across multiple keys, and a Wiki knowledge base using BM25 full-text search with LRU caching. Both are described in release notes, not in the README proper.

## Where CountBot is the wrong choice

The project status section is the honest limitation and it is not a technical one: the README states CountBot will not be continuously updated by the author in the short term, and that it is currently intended for learning, research and secondary development. That changes what you are buying. If you need a dependency with a responsive maintainer, this is not it. There is a second, more structural limitation. CountBot is a hub, which means it is only as useful as the pieces you connect to it. A fresh install with no LLM key, no channel credentials and no skills configured is a web UI and a process, not an assistant. The README's own framing, connecting models, channels, teams and tools, describes work you have to do before the framework pays off. Third, the documentation is primarily Chinese and lives on countbot.cn rather than in the repository. The README links seven separate doc pages for quick start, configuration, deployment, remote access, auth, API reference and releases, and it does not inline the configuration precedence rules or the first-run flow. If your team cannot read Chinese, you are working from the English README and the source. Finally, the optional dependencies are genuinely optional in a way that changes behavior silently: skipping jieba degrades Wiki search to single-character tokenization, and the README notes scrapling is roughly 100MB and falls back to plain httpx when absent. Neither failure announces itself.

## How CountBot differs from OpenClaw and from hosted assistant platforms

The README names OpenClaw directly and positions CountBot as complementary rather than competing: OpenClaw validated local execution and autonomous agents, CountBot targets Chinese-language adaptation, lighter deployment, easier extension and governance on top of that. The practical difference is the channel and configuration surface. OpenClaw users typically work closer to the code and the agent definition; CountBot puts a web UI over roles, teams, skills, tools and channels, and layers configuration at global, role, team and session scope. If your team writes Python anyway and wants the smallest possible surface, the OpenClaw-style approach is less machinery. If you want a non-developer to bind a Feishu bot to a specific persona without touching a config file, CountBot's layering is the point. The other comparison is against hosted assistant platforms, where the trade is inverted: you give up local file and Shell access, but you also give up the install, the channel credentials and the upgrade treadmill. CountBot is for people who specifically want the agent to reach their filesystem and their internal chat tools, and who accept the operational work that follows. The MIT license removes most legal friction for forking, which matters given the maintenance statement, but the license text itself is the authority and this is not legal advice.

## Upgrade path and what the release history implies

Releases are tagged on GitHub, with v0.9.1 on 2026-08-11, v0.9.0 on 2026-05-05 and v0.8.3 on 2026-04-25, and the last push to the repository was on 2026-09-04. The README's own changelog reaches back to the initial open-source release on 2026-02-21, which means the project went from first public commit to v0.9.x in roughly six months. That pace explains both the feature list and the shape of the release notes: v0.8.0 and v0.7.0 are dominated by bug fixes and issue triage rather than new surface area, and v0.8.0 explicitly mentions unifying the startup host and port environment variables and documenting COUNTBOT_HOST and COUNTBOT_PORT. In other words, the configuration story was still settling as recently as the v0.8.0 line. If you upgrade across several minor versions, expect config keys to have moved, and read the release notes for each version you skip rather than jumping straight to the latest tag. The requirements file pins uvicorn to exactly 0.32.0 while most other dependencies use minimum bounds, so a fresh install today may pull newer versions of fastapi, pydantic or the channel SDKs than the release was written against. Nothing here describes a migration tool or a rollback procedure, and the README does not document rollback.

## Conclusion

Adopt CountBot if you want a locally hosted agent hub whose channels, roles and tools are configured through a web UI rather than a Python API, and if you are comfortable reading Chinese documentation. Do not adopt it if you need a maintained dependency you can file bugs against: the README states the author will not keep updating the project in the short term, so treat it as a base for study or for a fork you maintain yourself. Before committing, verify three things on your own machine: that pip install -r requirements.txt resolves on your Python version, that the channel SDKs you need (qq-botpy, dingtalk-stream, lark-oapi, python-telegram-bot) authenticate with your accounts, and that the /setup/<random> remote initialization flow is reachable and expires as documented.

## FAQ

### What is CountBot?

CountBot is an open source AI agent framework and runtime hub aimed at Chinese-speaking users, MIT-licensed and written in Python. The README describes it as connecting LLM providers, IM channels such as WeChat, Feishu, DingTalk and Telegram, agent teams, tools and a local workspace into one locally deployed process.

### How do I install and start CountBot?

Clone the repository, run pip install -r requirements.txt, then run python start_app.py. The README states the app opens at http://127.0.0.1:8000 by default, and that COUNTBOT_HOST and COUNTBOT_PORT override the listening address and port. Packaged desktop builds for Windows, macOS and Linux are also published on GitHub and Gitee releases.

### Is CountBot still maintained?

The README's project status section states that CountBot will not be continuously updated by the author in the short term, and that it is currently intended for learning, research and secondary development. The last push to the repository was on 2026-09-04.

### Which chat platforms can CountBot connect to?

The README lists WeChat via ClawBot, Weibo, Feishu, DingTalk, WeCom, QQ, Xiaozhi AI and Telegram, plus a web UI. QQ, DingTalk, Feishu and Telegram have corresponding SDK dependencies in requirements.txt, and v0.6.0 added support for binding multiple WeChat ClawBot accounts.

## Sources

- [countbot-ai/CountBot on GitHub](https://github.com/countbot-ai/CountBot)
- [License: MIT](https://github.com/countbot-ai/CountBot/blob/main/LICENSE)
- [Project website](https://countbot.cn)
- [README](https://github.com/countbot-ai/CountBot/blob/main/README.md)
- [Releases](https://github.com/countbot-ai/CountBot/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/countbot-ai-countbot