DEV Community

sun young
sun young

Posted on

OpenBot: A Chinese Translation of the Open-Source AI Coworker Template

#aiopensourcchineseagentse

What OpenBot is

OpenBot is an open-source platform for running AI assistants on infrastructure you control. The official one-line description is:

Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.

The shape is familiar — think ChatGPT, Claude, or Grok — but the deployment model is not. Every component runs inside your own environment, and every part of it can be modified. Agents connect through the AG-UI protocol, so you can bring an agent built on a framework or one you wrote by hand.

Each bot gets its own computer: a real browser with separate login credentials and separate files, limited to the tools you grant it. Actions pass through a gateway decision before execution and are recorded afterward.

The original project is CopilotKit/OpenBot:

  • Stars: 6438
  • Primary language: TypeScript
  • License: MIT
  • Topics: ag-ui, agent-governance, ai-agents, browser-automation, copilotkit

What the Chinese version adds

The Chinese translation lives at yangshun2005/OpenBot-cn. It was translated on 2026-10-14 and is a fresh repository, so it has no stars of its own yet — the 6438 figure above belongs to the original project only.

The value here is straightforward: the original README is long, and a large part of it is operational detail — environment variables, setup scripts, self-hosting caveats. For Chinese-speaking developers, reading that in a second language adds friction before you have written a single line of code. The translated repository addresses that in two ways.

The translated README body

The main body is a faithful Chinese translation of the original documentation. It covers the same material: the architecture, the AG-UI integration, the per-bot computer model, the gateway decision flow, and the sign-in configuration. Where the original says something, the translation says the same thing.

A separate quick-start guide

On top of the translation, the repository adds a section labeled 「中文快速上手」 (Chinese quick start). This is explicitly marked as supplementary material, not part of the original documentation. Its stated purpose is to let you get the project running without reading the entire README first.

That distinction matters. Translated documentation and an onboarding guide are different artifacts with different failure modes. Mixing them without labeling is how translation projects become unreliable. This one keeps them separate.

The quick-start section covers four things the original spreads across a longer document:

  • What problem it solves. OpenBot is for the case where you want an AI assistant but your data and tools must stay in your own environment. The translation is explicit that this is a template, not a product — there is no hosted version, and you clone the repository and modify it.
  • The shortest path to running it. Dependency installation, connecting a hosted Intelligence project, filling in required values, and starting the stack.
  • Environment requirements. Operating system, dependencies, and version constraints.
  • Common pitfalls. The things that break a first run.

Getting it running

The quick-start path in the translated repository is short. First, create your environment file and install dependencies:

cp .env.example .env
bun install
Enter fullscreen mode Exit fullscreen mode

Then connect a hosted Intelligence project:

npx --yes copilotkit@latest login
npx --yes copilotkit@latest project select
bun scripts/setup-learning.ts
Enter fullscreen mode Exit fullscreen mode

Fill in the remaining required values. The proof-of-concept bot uses OpenAI, so you need OPENAI_API_KEY. If you are self-hosting Intelligence, there is additional configuration. To generate a custom encryption key:

openssl rand -base64 32
Enter fullscreen mode Exit fullscreen mode

Then start the stack:

bash scripts/start.sh
Enter fullscreen mode Exit fullscreen mode

To stop it, use scripts/stop.sh. Adding --keep-computers preserves the bots' computers.

Environment requirements

The requirements are worth reading before you clone, because a few of them are non-obvious.

  • Operating system. The README is written for laptops. The preview version that runs Intelligence locally targets macOS with Docker Desktop.
  • Hardware. The source material does not specify hardware requirements. Minimum deployment specifications are referenced in docs/deployment.md, which the source material does not expand on.
  • Dependencies:
    • Docker, for PostgreSQL and the bundled bots
    • Bun 1.3+ for the application and API server. The packageManager field in package.json is bun@1.4.3.
    • A CopilotKit Intelligence project and license. There is a free plan, and self-hosting is also possible.
    • A model key. The proof-of-concept bot uses OpenAI; the LangGraph bot can use OpenAI, Anthropic, or Google.
  • Version constraints. Bun 1.3+. The Dockerfile pins Playwright at 1.62.1, which must stay consistent with agent-computer/package.json.

On network conditions in mainland China, the source material says nothing about mirrors or download acceleration. If that is your situation, treat it as an open question rather than something the documentation answers.

The pitfalls that actually matter

The translated quick-start calls out four issues. They are worth repeating because each one will cost you time if you miss it.

This is an Alpha-stage template, not a product

There is no hosted version to sign up for. Every workspace in the repository is private and none of it is published as a package you can depend on. You clone it and adapt it. The examples under examples/ are tenant packages you are expected to replace with your own coworkers, channels, and skills.

The original README states this plainly: everything described is a starting point, not a finished thing operated by someone else on your behalf.

Single-user mode is on by default

In .env.example, OPENBOT_SINGLE_USER=true treats every request as an administrator. A fresh clone is accessible without OAuth. That is convenient for local development and unacceptable the moment anyone else can reach the deployment.

The documentation is direct about this: sign-in must be configured before others can access the deployment. This is not a hardening step you do later.

You need external keys and a project

A CopilotKit Intelligence project and license are required, along with a model key such as OPENAI_API_KEY. If you self-host Intelligence, you must set INTELLIGENCE_GATEWAY_WS_URL manually, and a missing INTELLIGENCE_API_KEY will cause startup to fail.

Local Intelligence is a preview

Running Intelligence locally targets macOS with Docker Desktop only. The local license is valid for 30 days. It is not a production installation. Self-hosted setup also requires Chrome or Edge to be installed first.

Why a translation is worth maintaining

OpenBot's documentation is not short, and most of its length is operational. Setup scripts, environment variables, self-hosting caveats, version pins — this is the material where a misread line costs you an afternoon.

Translation projects tend to fail in one of two ways. Either the translation drifts from the source and nobody notices, or the translator adds interpretation without marking it, so readers cannot tell what the upstream project actually claims. The OpenBot-cn repository handles the second problem by construction: the translated README body is labeled as a translation, and the quick-start guide is labeled as supplementary. If a translation is inaccurate, the repository asks for an Issue or PR.

For a project at this stage — Alpha, actively developed, with rough edges and bugs expected — that structure is the right one. Upstream will change. A translation that makes its own additions visible can track those changes. One that blends them in cannot.

Who this is for

If you are a Chinese-speaking developer evaluating OpenBot, the translated repository removes the reading barrier before you commit to a clone. You can understand the architecture, the AG-UI integration model, and the per-bot computer design in your first language, then run the setup commands, which are identical to the original.

If you are not, the original repository is the place to start. The Chinese version is a translation of it, not a fork with different behavior.

Either way, the honest framing is the one the documentation itself uses: this is a template you clone and reshape, in Alpha, running on your own machine. The 6438 stars on the original are a signal that other people found the problem worth solving. Whether it fits yours is a question only you can answer, and the quickest way to answer it is to run the four commands above.

Chinese documentation: https://github.com/yangshun2005/OpenBot-cn

Top comments (0)