countbot

中文 | English

What Is CountBot

CountBot is a lightweight, low-footprint AI assistant that runs on your server and stays up. A modest machine is enough to host it. Once it is bound to the chat tools you already use, you can call it directly from Lark, WeCom, WeChat or QQ, or work with it through the web interface.

Unlike a plain chat bot, CountBot can actually execute work. It reads and writes files, runs commands, searches the web, takes screenshots and sends media. Beyond that, you can wrap your recurring routines into skills, let it run on a schedule, and have the results delivered to the channel you choose.

Key points below.

• Entry points are the IM tools you already use, including Lark, WeCom, WeChat, QQ, DingTalk, Telegram and Weibo, plus ServerChan for push-only delivery
• Recurring routines can be wrapped into skills, triggered by a single instruction or run automatically by the scheduler
• Scheduled tasks combine with proactive greetings to push digests, reminders and summaries on plan
• Long-term memory keeps context across sessions, so earlier instructions do not have to be repeated
• 22 model providers are built in, and models can be assigned per session or per task

Skills

The skill system is the core mechanism of CountBot.

A lot of daily work follows fixed procedures. Compiling a competitive digest every week, summarizing new content from a few sites every day, cleaning spreadsheets by a fixed rule. You have done these many times and know the steps by heart, yet still run them by hand each time.

Skills fix that. Write the procedure once, and afterwards a single instruction triggers it, or the scheduler runs it automatically.

Writing one is not hard. Describe when to use it and how it works, and that is enough. If you are not sure where to start, the built-in skill-creator walks you through the whole process, from clarifying the goal to validating the result. Finished skills can be enabled, disabled and configured from the panel, or installed from the SkillsHub.

Multi-Agent Teams

For more complex work, a single agent tends to lose track of things. Agent Teams let you group several roles, each owning one part, working in stages or in parallel.

Three orchestration modes are available.

pipeline runs stages in sequence, where the output of one stage becomes the input of the next. It suits tasks with a clear order of steps.

graph lets you declare dependencies between roles first, then runs everything without unmet dependencies in parallel. It suits tasks with branches and a final merge. If the dependencies form a cycle, the system reports an error instead of looping.

council has each member produce an independent result from their own perspective, then review each other, and finally consolidate. It suits judgment calls that need several angles weighed.

Once a team exists, send /team <team name> <task> in a session to invoke it, or mention the team name with @.

A team can carry its own model configuration. When configured, execution inside the team uses the team configuration; otherwise it inherits the model of the current session.

Session-Level Model Configuration

Changing models used to mean editing the global default, which affected every session. Now it can be switched inside a session.

A model picker sits next to the chat input. The selection applies only to the current session and leaves the global default untouched. Right beside it, the reasoning effort for that session can be adjusted, with the available levels determined by the model.

Switching the level on the same model is enough to cover different scenarios. Long tasks get a higher level, quick questions drop back to a lower one, without repeated trips to the settings page.

Order of precedence is as follows. The model selected in a session applies to that session; if a team has its own model configured, execution inside the team follows the team configuration; when neither is configured, the global default applies.

What It Can Do For You

Supported Channels

All two-way channels share the same session model. A session processes one turn at a time, so concurrent messages from multiple entry points do not interfere with each other.

Supported Models

22 providers are built in, covering mainstream Chinese and international models, along with OpenAI-compatible custom endpoints and local inference.

openrouter   anthropic   openai      deepseek   moonshot   zhipu
groq         mistral     cohere      together   qwen       hunyuan
ernie        doubao      yi          baichuan   minimax    vllm
ollama       lm_studio   custom_openai          custom_anthropic

The request protocol is determined by the provider setting or by user selection.

A single provider can hold multiple models, fetched from the upstream /models endpoint or entered manually. Each model records its context window, image input capability, reasoning levels and related metadata. The global default, session level and scheduled task level can each designate which model to use.

Core Capabilities

Latest Updates

• v1.0.0 · 2026-10-24

  • Reworked the provider system: model lists per provider, the OpenAI Responses protocol and explicit protocol selection, with existing configuration migrated automatically
  • Added reasoning levels: available levels declared per model, customizable, and assignable per session or scheduled task
  • Added model switching in the chat input: per-session model and level without touching the global default
  • Split context compaction into a standalone module (pruning, boundary, summarization, assembly) with a manual compaction entry in the session list
  • Reworked memory into an assertion store: three lifecycle tiers, inferred content kept in cold storage only, plus a migration script
  • Added the ServerChan push channel, with the session target field omitted for push-only channels on the scheduled task page
  • Scheduled tasks now support a per-task model and reasoning level
  • Enabled SQLite WAL and busy_timeout to reduce write lock waits under long-lived connections
  • Completed usage accounting with cache hits and reasoning tokens, and filtered invisible upstream output to avoid rendering empty reasoning blocks
  • Added a queued state for subagents, making cancellation propagation and terminal state convergence more reliable
  • Messages now render interleaved in the order text and tool calls actually occur
  • Front-end interface reworked and optimized for a better overall experience

• v0.9.0

  • Added MCP client module with multi-server connections, health checks, and tool discovery. Disabled by default, designed for advanced users with personalized needs
  • Added Wiki knowledge base module with BM25 full-text search, batch retrieval, relevance filtering, and LRU cache
  • New MCP and Wiki management panels with component modularization and i18n support
  • New WebSocket status broadcast module for real-time MCP connection state sync to frontend
  • Improved context management and heartbeat mechanism, simplified greeting logic to reduce LLM calls
  • Refined tool registration and initialization flow for better startup consistency
  • Added API Key rotation with automatic failover and multi-key support
  • Improved send_media tool compatibility for web mode, supports image preview and file download in Web UI