What ChengOS Is

Applies to: ChengOS v0.1.0+ ｜ Last verified: 2026-08-12 ｜ Source: root README.md, deploy/README.md

ChengOS is a visual platform for building, running, and publishing AI workflows and agents. You assemble typed nodes on a canvas into a directed graph, and the platform runs that graph on a Rust engine — then exposes the result as a chat interface, a published app, a scheduled job, an API endpoint, or a terminal session, without you rebuilding anything.

What it is, concretely

Five pieces ship together:

Piece	What it is
`cheng-api`	The Rust backend: DAG execution engine, REST + WebSocket API, node library, credential vault, scheduler, vector retrieval
`cheng-ui`	The browser workflow editor and admin console, built on React Flow
`cheng-app`	The chat gateway: embeddable web widget, responsive H5/PWA, and messaging-channel routing
`cheng` CLI	A terminal client that connects to a local or remote server, in the style of Claude Code or Codex
`deploy/`	One script, `chengos.sh`, that installs and operates all of the above

What you can build with it

Visual AI and automation workflows from reusable nodes and subflows.
ReAct agents that discover and invoke tools, MCP servers, and Skills.
Chat applications for web, mobile, embedded widgets, and messaging channels.
Local document, spreadsheet, RAG, and multimodal processing pipelines.
Terminal agents that operate against a local or remote ChengOS server.

What makes it different

Credentials never reach the model. API keys, tokens, and passwords live in an encrypted vault. Nodes hold a reference; the real secret is injected server-side at the moment a network call or shell command is actually made. Even an autonomous agent choosing its own tool calls never sees a key in its prompt context, which closes off prompt-injection as a route to credential theft.

Documents and spreadsheets are local. There is a built-in canvas for rich text/.docx and spreadsheets/.xlsx. You do not connect Google Sheets or Feishu to let an agent edit a table — the data stays in the workspace sandbox.

MCP is native, in both directions. ChengOS consumes external MCP servers over stdio, SSE, and HTTP, and also exposes workflows as MCP servers. An agent discovers external tools, prompts, and resources automatically.

Node forms are generated, not written. A node declares its inputs as a JSON Schema with x-* UI hints; the editor turns that into a form. Change a node's inputs on the backend and the property panel follows, with no frontend work.

The engine is Rust. The DAG is planned statically into stages, then scheduled concurrently with a semaphore-bounded task pool, streaming progress over WebSocket.

How the pieces talk

                      ┌───────────────────────────────┐
                      │   Backend core (cheng-api)    │
                      │  Rust DAG engine / REST + WS  │
                      └───────────────┬───────────────┘
                                      │
        ┌─────────────────────────────┼─────────────────────────────┐
        ▼                             ▼                             ▼
┌────────────────┐           ┌────────────────┐           ┌────────────────┐
│ Visual editor  │           │  Chat gateway  │           │  Terminal CLI  │
│  (cheng-ui)    │           │  (cheng-app)   │           │    (cheng)     │
│ React Flow     │           │ Widget / H5    │           │ Local / remote │
└────────────────┘           └────────────────┘           └────────────────┘

Every client is an ordinary consumer of the same REST + WebSocket API. There is no privileged internal channel — see the REST API overview.

Licensing

ChengOS is currently free to use but not open source. You may use it at no cost for personal and commercial office automation; the source is not published. The stated plan is a free Community Edition (the current release, with core office-automation features) and a paid Enterprise Edition adding team collaboration, permission management, and dashboards.

Business and enterprise enquiries: [email protected].

Where to go next

Core concepts — the vocabulary, in one page.
System overview — the components and deployment shapes.
Install ChengOS — get it running.
Your first workflow — build something.