chengos

Visual AI workflows and agent runtime

Build, publish, and deploy intelligent workflows across web, mobile, messaging, and terminal clients.

Website · Live Demo · Overview · Screenshots · Quick start · Windows / ARM · Docs · 中文介绍

---

Overview

ChengOS is a visual platform for building, running, and publishing AI workflows and agents. It combines a Rust workflow engine, a browser-based workflow editor, multi-channel chat applications, a terminal client, and a unified deployment toolkit.

This repository provides the deployment scripts, infrastructure configuration, built application assets, and runtime resources needed to operate ChengOS in development or production.

Live demo

Service	URL
Visual workflow editor and administration	demo-ui.chengrouter.com
Published applications and chat	demo-app.chengrouter.com

Use the following shared demo account for both services:

• Email: demo@chengrouter.com
• Password: demo123456

What you can build

• Visual AI and automation workflows with reusable nodes and subflows.
• ReAct agents that can discover and invoke tools, MCP servers, and Skills.
• Web, mobile, embedded, and messaging-channel chat applications.
• Local document, spreadsheet, RAG, and multimodal processing pipelines.
• Terminal-based agents that connect to a local or remote ChengOS server.

Screenshots

Applications and Skills	Workflow management

Visual workflow editor	Messaging-channel integrations

Deployment console

Terminal client

Connect to a workspace	Chat with an agent

Architecture

ChengOS uses a client-server architecture. The Rust backend exposes REST and WebSocket interfaces to the visual editor, application gateway, and terminal client.

                         ┌───────────────────────────────────┐
                         │    Backend service (chengflow)    │
                         │    Rust DAG engine / REST & WS    │
                         └─────────────────┬─────────────────┘
                                           │
             ┌─────────────────────────────┼─────────────────────────────┐
             ▼                             ▼                             ▼
┌────────────────────────┐   ┌────────────────────────┐   ┌────────────────────────┐
│ Visual editor & admin  │   │ App and chat gateway   │   │ Terminal client        │
│ chengflow-ui           │   │ chengflow-app          │   │ cheng CLI              │
│ React Flow canvas      │   │ Web / H5 / PWA         │   │ Local or remote server │
└────────────────────────┘   └────────────────────────┘   └────────────────────────┘

Component	Technology	Responsibility
chengflow / cheng-api	Rust	DAG execution, REST and WebSocket APIs, sandboxing, credentials, multi-tenancy, vector retrieval, and scheduling.
chengflow-ui / cheng-ui	React + TypeScript + Vite	Visual workflow editing, administration, MCP configuration, Skills, and local document workspaces.
chengflow-app / cheng-app	React + TypeScript + Vite	Published applications, embedded chat, responsive H5/PWA interfaces, and channel routing.
cheng CLI (chengctl)	Rust	Local or cross-device terminal chat, workflow execution, and agent interaction.
deploy/	Shell + Docker Compose	Installation, configuration, lifecycle management, updates, and deployment resources.

Key features

Visual workflows and agents

Build workflows on a React Flow canvas, configure nodes through a properties panel, test them interactively, and publish them as applications. ReAct agents support multi-step tool use, while subflows and batch subflows enable composition and parallel processing.

Native MCP support

• Connect to MCP servers over Stdio, SSE, or HTTP through tools/mcp_hub.
• Discover tools, prompts, and resources dynamically from workflows and agents.
• Manage connections in the web UI or inject preset configuration through environment settings.

Multi-format Skill import

The built-in Skill importer can create runnable Skill packages from natural-language requirements, web pages or API documentation, Git repositories, standard SKILL.md files, and ZIP packages. Imported Skills pass through parsing, validation, review, safe writing, and hot reload.

Credential isolation

Secrets are stored in the backend credential vault rather than embedded in workflows, Skills, or scripts. Tools and Skills receive credentials only at execution time, keeping raw values out of LLM prompt context. Sandboxing and user_id isolation provide additional boundaries.

Local documents, spreadsheets, and RAG

ChengOS includes local Word (.docx) and spreadsheet (.xlsx or grid) workspaces. Agents can read, format, update, and generate content through document and table nodes without requiring a third-party online office suite. RAG nodes cover chunking, indexing, retrieval, and vector search.

Multiple chat entry points

• Embedded chat in the workflow editor for testing and iteration.
• Web, H5, PWA, and messaging channels such as WhatsApp, Telegram, Slack, WeCom, DingTalk, and ChengApp.
• A lightweight terminal client for local development and remote servers.

Quick start

Windows desktop (recommended on Windows x64)

Download the ChengFlow Desktop .msi from GitHub Releases and run it. The desktop app embeds its own database and services, so no server setup is required. The first launch initializes the local database and can take a minute or two.

For Windows ARM64 PCs and ARM64 OpenWrt routers, see the Windows and ARM64 guide.

Server deployment

Launch the interactive bilingual management console:

./chengos.sh

The console can install, start, stop, restart, update, inspect, or uninstall modules. It can also install the CLI independently, create system command shortcuts, and switch between English and Chinese.

Native deployment

Run the API and static web applications directly on the host:

./chengos.sh install --mode native --db-install-mode managed-process --with api,ui,app,cli
./chengos.sh start
./chengos.sh status

Database installation modes:

• managed-process (default): runs PostgreSQL, Valkey, and Qdrant as unprivileged processes without root access.
• system-service: installs databases as systemd services through the system package manager and requires sudo.

Docker Compose deployment

./chengos.sh install --mode docker --with api,ui,app,cli
./chengos.sh start
./chengos.sh stop

Pin an exact release instead of latest — all four ChengOS images resolve their tag from one CHENGOS_VERSION value in .env:

# deploy/.env
CHENGOS_VERSION=0.1.0

latest is a first-install convenience only. It is not a reproducible production version and is never an update or rollback target.

Versions, updates, and rollback

./chengos.sh status     # installed version, running version, latest stable, health
./chengos.sh update     # upgrade-only; checksum + signature verified, auto-restore on failure
./chengos.sh rollback   # restore the previous release

Full release, artifact-verification, update, and rollback procedures — including when a database migration makes automatic rollback unsafe — are documented in the Release Operations Guide.

Standalone CLI and remote access

Install only the cheng terminal client:

./chengos.sh cli

Choose a local connection to http://127.0.0.1:19225, or enter the URL of a remote ChengOS server. Once configured, start the client from any terminal:

cheng

Workflow toolset

Category	Representative tools
Code and shell	tools/code_shell, tools/code_python, tools/code_js
Files and workspace	tools/read_file, tools/write_file, tools/edit_file, tools/patch_file, tools/search_files, backup and rollback tools
Web and remote access	tools/http, tools/browser, tools/web, tools/mail, tools/ssh, tools/fetch_repository
AI and multimodal	ai/llm, ai/llm_branch, agent/react_agent, image/audio/video generation, ASR, OCR, and translation
Documents and data	document/*, table/apply_record_ops, table/query, rag/document_indexer, rag/retriever, rag/chunker
Orchestration	tools/schedule, tools/mcp_hub, tools/skills_hub, tools/skill, tools/subflow, tools/batch_subflow, utils/approver

Deployment layout

deploy/
├── chengos.sh              # Bilingual installer and management console
├── generate-env.sh         # Unified environment generator
├── .env.example            # Environment template
├── app/                    # Built cheng-app assets
├── ui/                     # Built cheng-ui assets
├── bin/                    # API, CLI, and proxy binaries
├── config/                 # Shared configuration, presets, and i18n overrides
├── infra/                  # PostgreSQL, Valkey, and Qdrant infrastructure
├── skills/                 # Built-in Skills and Skill importer
├── workflow-templates/     # Bundled workflow templates
├── models/                 # Optional local AI/OCR models
├── runtime/                # Managed runtime dependencies and state
├── logs/                   # Service logs
├── workspace/              # Workflow sandbox files
├── workflows/              # Workflow runtime data
├── workspaces/             # Workspace runtime data
├── hybrid/                 # Native deployment scripts
├── docker/                 # Docker Compose deployment files
└── distributed/            # Multi-node deployment examples

Default ports

Service	Port	Environment variable	Purpose
API backend (cheng-api)	19225	PORT=19225	REST and WebSocket API
Main UI (cheng-ui)	8080	UI_PORT=8080	Visual editor and administration
Chat app (cheng-app)	5055	APP_PORT=5055	Published applications and mobile H5 UI
PostgreSQL	5432	POSTGRES_PORT=5432	Relational database
Valkey	6379	REDIS_PORT=6379	Cache and rate limiting