Content
# Tool List
<img src="docs/branding/ruyi-mark.svg" alt="Ruyi" width="72" align="right" />
> **Ruyi — an offline-first, Windows-native, all-in-one AI workbench that non-programmers can use safely.**
[](./LICENSE)
[](https://github.com/wangzhe04/ruyi-workbench-oss/actions/workflows/e2e.yml)
[](./THIRD-PARTY-NOTICES.md)
[](./dev-harness)
[](./ruyi-workbench/app/server.js)
A Windows machine + any available model endpoint (any OpenAI compatible API or private Claude CLI) = a **local AI workbench that can really help you**: read and write files, run scripts, control the desktop and Office, dispatch a team of agents to collaborate on research - every step is auditable, revocable, and transparent in terms of cost, **works online or offline**.
<picture>
<source media="(prefers-color-scheme: light)" srcset="docs/screenshots/hero-light.png" />
<img src="docs/screenshots/hero-dark.png" alt="Ruyi main interface: conversation-driven native tools, answers with table conclusions, file changes can be reverted with one click" />
</picture>
<sub>▲ Real workflow: let AI read a CSV file in the workspace → analyze and generate a report file → provide structured conclusions in the conversation; each tool call has a card, each file change can be reverted, and each round of consumption has an account.</sub>
**Quick Jump**: [What is Ruyi](#what-is-ruyi) · [Comparison with similar software](#comparison-with-similar-software) · [Interface Tour](#interface-tour) · [Core Capabilities](#core-capabilities) · [Function Details](#function-details) · [Quick Start](#quick-start) · [Advanced Guide](#advanced-guide) · [English](#english)
---
## What is Ruyi
**Ruyi** is a clean-room implementation of a Windows-native AI workbench: upgrading "model conversation" to "model doing things for you". It's not just another chat shell, nor a programming CLI for developers only - it's for **two types of users on the same machine**: non-programmers who want to organize files, summarize reports, write weekly reports, and operate Office, and advanced users who want to run scripts, review code, and conduct multi-agent research.
Three numbers describe its shape:
| | |
|---|---|
| **1 file** | The backend is a single file `server.js` (about 14,000 lines), **zero npm dependencies**, using only Node built-in modules - `node server.js` runs directly, no need for `npm install`, making it the lowest-cost solution for government and enterprise internal networks |
| **39+3 native tools · 99 desktop tools** | 39 resident native tools (+3 on-demand registration), plus optional desktop control components ACC (screenshot/OCR/UIA/keyboard/mouse/window/Office/PDF, 99 tools in total) |
| **8 templates · 9 roles · 100+ offline e2e** | Built-in 8 multi-agent workflow templates and 9 node roles; each feature is delivered through a closed-loop process of "implementation → multi-perspective verification → repair → independent regression", with over 100 offline e2e tests |
> Originally named **Win Claude Workbench**, renamed to **Ruyi** from v0.8 - removing "Claude" is a legal consideration (trademark risk + old prompts may cause provider models to claim "I am Claude", leading to identity confusion). "Ruyi" means "as you wish" and "like you want", with a icon of a blue and white cloud.
## Comparison with Similar Software
There are three types of AI tools on the market: cloud-based conversation applications (web/client chat shells), programming CLI agents (terminal tools for developers), and cloud-based automation agents (tasks hosted on others' servers). Ruyi occupies a unique position - **local, hands-on, revocable, and usable by non-programmers**:
| Dimension | Cloud-based Conversation Applications | Programming CLI Agents | Cloud-based Automation Agents | **Ruyi** |
|---|---|---|---|---|
| Running Location | Vendor's server | Local terminal | Vendor's sandbox | **Local machine, data stays on-premises** |
| No internet / internal network deployment | ✗ | Partial (models still require online access) | ✗ | **✓ Endpoint can point to internal network models** |
| Control of local desktop/Office | Limited | Weak (mainly code-based) | In cloud-based virtual machines | **✓ 99 tools directly control local machine, pure text models can be used (OCR+UIA text localization, no visual model dependency)** |
| Can mistakes be reverted? | No concept of reverting | Rely on git | Difficult | **✓ File checkpoints + conversation tracing, paired delivery, with permission pop-ups showing "reversible"** |
| Multi-agent collaboration | None/black box | Available but mostly command-line output | Black box | **✓ DAG graph editor + real-time collaboration monitoring canvas** |
| Cost transparency | Subscription-based | Partial | Subscription-based | **✓ Accounting in multiple currencies, with sub-agents/compression fully accounted for, no hidden costs** |
| Usable by non-programmers | ✓ (but limited to chatting) | ✗ | ✓ (but uncontrollable) | **✓ Simple/professional dual modes, one-click task cards** |
| Deployment/audit cost | — | Requires Node/Python ecosystem | — | **Single file, zero dependencies, offline zip extraction and usage** |
Five unique features that are hard to find elsewhere:
1. **Operation-level revocation** - file checkpoints + conversation tracing **paired delivery**, with revocability directly reflected in permission pop-ups (see screenshot below). Most computer-use products lack OS-level revocation, which is a significant safety differentiator.
2. **Pure text models can control desktop** - OCR + UIA text grounding, no visual model dependency. Limited internal networks often only have text models, which directly determine usability limits (visual enhancements, not prerequisites).
3. **Internal network deployment priority + zero dependencies and auditable** - single-file backend, zero npm dependencies, frontend without frameworks or builds, fully offline capable; smallest security team audit surface.
4. **Chinese priority + bilingual support** - default Chinese experience, with optional switching to simplified Chinese, English, or system language; settings, provider cards, permission/ability pop-ups, model menus, output, shortcuts, command panels, and skill libraries are all rendered with language resources. Built-in skills and one-click tasks are localized with the interface language, while user/project custom content maintains the original author text. Code writers and non-code writers share the same shell, with dual-mode switching.
5. **Dual engines, no locking** - arbitrary OpenAI compatible endpoints (DeepSeek / Tongyi Qianwen / Zhipu GLM / internal vLLM·Ollama) or internal Claude CLI, switchable at any time, with context continuity across engines.
## Interface Tour
| | |
|---|---|
|  |  |
| **Workbench canvas**: real-time collaboration graph of multi-agent workflows - who's running, where, and what's stuck; right column shows node details, task pool approval, and agent mailbox | **Workflow graph editor**: drag nodes, connect arrows, and assign colors by role; inspector can assign engines/models/tools/quality gates to each node |
|  |  |
| **Permission approval**: execution-level operation pop-up confirmation, with "this operation cannot be automatically reverted" clearly stated; can be rejected or automatically approved within the session | **Usage and cost**: input/output tokens, conversation rounds (including workflow sub-agent rounds), split by engine/service provider/session; honest accounting |
|  |  |
| **Simple mode**: one-click task cards for non-programmer personas - archive/rename/merge Excel/OCR/PDF summary/write weekly reports...; developer tabs are automatically hidden | **Model providers**: enter Base URL + key to access any OpenAI compatible endpoint; keys stored locally, with interface masking; configurable pricing for cost estimation |
<details>
<summary><b>More screenshots (file panel / checkpoints / audit / skill library / memory / onboarding…)</b></summary>
| | |
|---|---|
|  |  |
| **First launch**: select a working folder to start; automatically detect local Claude CLI and available engines | **File tab**: workspace file tree + single-click preview; AI can only see files within the workspace |
|  |  |
| **Change tab**: file changes listed for each round, with single-line reversion or entire round rollback | **Audit timeline**: each round, tool call, and permission decision are recorded |
|  |  |
| **Skill library**: built-in/user/project/Playbook four-source skill registry, session-level enablement | **Workbench memory**: cross-session personal experience and project conventions, drafted and confirmed for entry, grouped by project |
|  | |
| **Workflow summary**: after running, each node conclusion is filled back into the conversation, with Explorer → Researcher → Critic → Synthesizer |
</details>
## Core Capabilities (v1.6.5)
| Capability | Description | Details |
|------|------|------|
| Dual-engine conversation | Switch between any OpenAI compatible endpoints and Claude CLI, with cross-engine context continuity | [§1](#1-dual-engine-arbitrary-model-endpoints-work-with-ruyi) |
| Native tool ring | 39 resident + 3 on-demand built-in tools: file/terminal/search/Git/networking/orchestration, with read/edit/exec three-level classification | [§2](#2-native-tool-ring-39--3-built-in-tools) |
| Multi-agent orchestration | DAG workflow, 8 templates, 9 roles, 5 quality gates, graph editor, real-time monitoring; AI actively orchestrates and selects models based on task difficulty | [§3](#3-multi-agent-orchestration-dag--quality-gates--graph-editor) |
| Long task autonomous advancement | Task ledger until-done drive; zero token waiting; optional hierarchical recovery; incremental monitoring (transmission volume reduction ≥80%) and operational metrics | [§3](#3-multi-agent-orchestration-dag--quality-gates--graph-editor) |
| Trust layer | File checkpoints + conversation tracing paired delivery; 5-level permission modes × tool three-level classification; full audit timeline | [§4](#4-trust-layer-checkpoints--tracing--permissions--audit) |
| Desktop / Office control | Screenshot/OCR/UIA/keyboard/mouse/window/Office/PDF (desktop control MCP, ACC v1.8.1, 99 tools, optional installation) | [§5](#5-desktop--office-control-acc-optional) |
| Skills / Memory / Playbook | Four-source skill registry + cross-session workbench memory + reusable task scripts, all gradually injected | [§6](#6-skills--memory--playbook) |
| Networking retrieval | 8 search backends, built-in backends with zero configuration; SSRF defense; crawling with offline caching | [§7](#7-networking-retrieval-and-web-crawling) |
| Cost / Usage dashboard | Accounting in multiple currencies, distinguishing official/third-party plans/usage-based; sub-agents and compression fully accounted for; monthly budget alerts | [§8](#8-usage-and-cost-dashboard-honest-accounting) |
| Bilingual interface | Support for following system, simplified Chinese, English; settings, dynamic pop-ups, skill library/one-click tasks/API errors are localizable | [Multi-language solution](docs/i18n/README.md) |
| Team mode | Shared task pool (sub-agent proposals → approval → materialization), agent mailbox, directed node insertion | [§3](#3-multi-agent-orchestration-dag--quality-gates--graph-editor) |
| Hierarchical UI | Simple/professional dual modes, light/dark dual themes, blue and white porcelain visual system | [§9](#9-hierarchical-ui-simple-professional-dual-modes) |
> Each feature is delivered through a closed-loop process of "implementation → multi-perspective verification → repair → independent regression", with over 100 offline e2e tests. Iteration records are available in [optimization roadmap](docs/OPTIMIZATION-ROADMAP.md).
## Function Details
### 1. Dual Engine: Arbitrary Model Endpoints Work with Ruyi
- **OpenAI compatible engine (native)**: direct HTTP + SSE streaming, with complete native tool cycle. Four preset groups: **DeepSeek / Tongyi Qianwen DashScope / Zhipu GLM / custom** (internal vLLM, Ollama, one-api gateway are all supported). Multiple providers coexist, with top-bar one-click model switching.
- **Claude CLI engine (optional)**: point to the local Claude CLI to use it alongside; workbench automatically generates MCP configuration, feeding your tools and bridge tools to CLI; also supports other Anthropic compatible endpoints like Ark.
- **Intelligent on-demand tool prompting**: default loading of relevant tool packages based on tasks; if lacking capabilities, AI searches and incrementally loads; OpenAI compatible engines join specific schema in the next tool cycle, while Claude CLI uses hierarchical proxy calls to hide tools. Simple questions no longer carry the entire set of ~140 tools; settings → advanced allows switching back to "all resident" compatibility mode. [Design and native A/B](ruyi-workbench/docs/TOOL-LOADING_CN.md)
- **Cross-engine continuation**: within a session, switching from DeepSeek to Claude (or vice versa), history is automatically grafted, maintaining context.
- **Reliable interactive questioning**: Claude CLI and OpenAI compatible engines share the `request_user_input` pop-up channel; selection is confirmed and delivered only after workbench confirmation; background sessions are immediately prompted.
- **Context power meter**: top-bar displays used/upper limit tokens (automatically detects context window, supports manual locking); exceeding threshold automatically compresses (evaporation → summary), or manual `compress`.
- **Capability matrix**: visual (image viewing), reasoning chain, tool calls, and other capabilities are detected/annotated by endpoint; missing capabilities are directly reported on UI.
- **Plan mode**: questions are prefixed with `PLAN:`, requiring approval before execution (provider engine real process, not prompt decoration).
### 2. Native Tool Ring: 40 + 3 Built-in Tools
All implemented using Node built-in modules (zero dependencies), with risk-based three-level classification: **read**(read-only, automatic approval) / **edit**(write, checkpointing, revocable) / **exec**(execution, highest risk, sequential confirmation):
| Category | Tools |
|---|---|
| Terminal / Execution (7) | `powershell_run` · persistent terminal sessions `shell_start/send/poll/kill/list` · `script_run`(PS/Python/Node temporary scripts) |
| File (12) | `file_read/write/edit/delete/move/copy` · `file_list/search/glob` · `archive_zip/unzip`(Zip-Slip prevention) · `http_download` |
| Desktop handover (4) | `browser_open` · `office_open` · `desktop_screenshot` · `keyboard_send_keys` |
| Project intelligence (6) | `project_snapshot` · `dependency_inventory` · `code_review_scan` · `frontend_audit` · `claude_md_audit` · `docs_search`(all offline scanners) |
| Git (4) | `git_status/diff/log`(read-only) · `git_commit` |
| Networking (3) | `web_search` · `web_fetch`(SSRF defense + offline caching) · `http_request`(local/internal API debugging) |
| Planning / Orchestration (4) | `request_user_input`(reliable user input collection) · `todo_write`(driven UI step bar) · `spawn_agent`(isolated sub-round) · `orchestrate_agents`(start DAG workflow) |
| On-demand registration (3) | `skill_read`(skill full-text retrieval) · `propose_task`(task pool proposal) · `send_to_agent`(agent mailbox) |
External MCP tools (desktop control, drop-in connectors) will **bridge** into this cycle, using the same hierarchical approval.
### 3. Multi-Agent Orchestration: DAG + Quality Gates + Graphical Editor
A phrase like "Conduct an in-depth study of competitor pricing" will prompt Ruyi to dispatch a team of specialized sub-agents and draw a real-time collaboration diagram on the **Workbench Canvas** (see the screenshot above).
**8 Built-in Templates** (with default node counts, all customizable in the editor):
| Template | Shape | Applicable Scenarios |
|---|---|---|
| In-depth Research → Verification → Summary | Deconstruction → Parallel Retrieval with Dual Lenses → Counterfactual Verification → Summary with References (5 nodes) | Research requiring reliable, traceable conclusions |
| Code Audit | Map → Parallel Verification (Correctness, Security, Quality) → Verification → P1/P2/P3 Scheduling (6 nodes) | Handling unfamiliar codebases, pre-launch check-ups |
| Implementation → Review → Fix → Testing | Review failure leads to fix, then independent verification (4 nodes) | Development tasks with clear acceptance criteria |
| Bug Localization | Reproduction → Dual Hypothesis → Verification → Root Cause Fix (5 nodes) | Systematic troubleshooting of stubborn bugs |
| Requirements → Multiple Solutions → Selection → Landing Checklist | Parallel solution generation → Weighted evaluation → Executable checklist (6 nodes) | Technical selection, architecture decisions |
| Document Generation | Outline → Parallel Writing → Fact-checking → Finalization (5 nodes) | Writing long documents from scratch |
| Data Insights | Exploration → Solution → Mainline/Cross-analysis → Verification → Insights (6 nodes) | Data analysis and reporting |
| Debate → Adjudication | Parallel debate → Cross-examination → Adjudication (3 nodes) | Decision-making with controversy |
**9 Node Roles** (each with hints, tool faces, budget, and color schemes): Explorer · Worker · Reviewer · Verifier · Planner · Researcher · Critic · Synthesizer · Analyst.
**Orchestration Primitives**: Node-level engine/model assignment (e.g., "Use a fast model for retrieval and a strong model for verification") · Dependency edges · Conditional execution · Loops · Failure strategies · Resource leases · Git worktree isolation · Structured output schema · **5 Quality Gates** (review/verify/vote quorum/cross-review/dedupe, where vote and dedupe are deterministic algorithms).
**AI-driven Orchestration + Model Selection by Difficulty**: When the conversation involves intents like "research/audit/troubleshooting/selection/write document", both engines receive template lists, intent-template mappings, and **available model capability lists** (grouped by engine, with speed/ balanced/strong tiers). Models can initiate `orchestrate_agents` and **autonomously assign models based on task difficulty**: simple/large-scale tasks use fast models for cost savings and speed, while core reasoning/comprehensive/quality gate tasks use strong models for quality assurance. Users can also enable "automatic model tiering by tool level".
**"Agent Team" Dialog**: When users explicitly prefer multi-agent collaboration, they can enable it before sending the message. The system will match predefined workflows or design a minimal DAG/parallel sub-tasks if no suitable template is found. The preference is reset after use, with safeguards to prevent over-orchestration.
**Team Mode v2**: Running sub-agents can **propose additional tasks**, which users can approve and add to the DAG. Nodes can communicate with each other using `send_to_agent` for one-way asynchronous messaging. Users can also **intervene in specific nodes** and provide directional input before the next model call.
**Long-running Task Progression (hours, resumable)**: The system ensures transparent and controllable progress, with **milestones**, **wait mechanisms**, and **recoverable interruptions**.
- **Task Ledger**: Breaks down goals into verifiable milestones, with optional `until-done` auto-progression. Continuous lack of progress leads to stagnation, and budget exhaustion leads to archival pause.
- **Non-token-consuming wait**: `wait_for` can wait for specified times, file appearances, process existence, or URL reachability. Waiting nodes do not occupy concurrent slots or call models.
- **Recovery with side-effect grading**: Each step's state is atomically recorded, and upon restart, interrupted points are honestly marked. **No blind replay of irreversible side effects**.
### 4. Trust Layer: Checkpointing / Rollback / Permissions / Auditing
The premise of "letting AI take action" is "being able to recover from mistakes":
- **File Checkpointing**: Each write operation creates a checkpoint log with the previous state.
- **Conversation Rollback**: Sessions can be rolled back to any previous turn, with optional file modification rollback.
- **5 Permission Modes × Tool Tiers**: Default "ask for every step", with additional modes like acceptance, planning, full automation, and skip confirmation.
- **Authorization**: Users can issue temporary authorization with limited scope (file paths, command prefixes, network permissions, duration).
- **Audit Timeline**: Each round, tool call, and permission decision are logged in NDJSON.
### 5. Desktop / Office Control (ACC, Optional)
The `mcp/ai-computer-control/` package is a **desktop control MCP** (v1.8.1, Python ≥3.12, 99 tools) bundled with the release.
### 6. Skills / Memory / Playbook
- **Skill Library**: Four-source registry with built-in toolkit, user library, project library, and Playbook integration.
- **Workbench Memory**: Cross-session personal experience and project conventions.
- **Playbook**: Save successful tasks as scripts, with AI-generated steps and parameters.
### 7. Internet Retrieval and Web Scraping
- `web_search` supports **8 backends**: built-in, SearXNG, Bing, Brave, Tavily, and custom options.
- `web_fetch` extracts text and metadata from web pages.
### 8. Usage and Cost Dashboard: Honest Accounting
- **Multi-currency accounting**: Accurate cost tracking and equivalent estimation.
- **Third-party Coding Plan support**: Distinguishes between actual and estimated costs.
### 9. Tiered UI: Simple / Professional Modes
- **Simple Mode** (default): One-click task cards and simplified interface.
- **Professional Mode**: Advanced features and detailed settings.
## Quick Start (Five-minute Setup)
**Prerequisites**: Windows 10/11 + Node.js ≥ 20.
```powershell
git clone https://github.com/wangzhe04/ruyi-workbench-oss.git
cd ruyi-workbench-oss\ruyi-workbench
node .\app\server.js serve --open
```
The Workbench will open in your browser.
## Advanced Operation Guide
<details>
<summary><b>Run a Multi-Agent Template / Custom Workflow</b></summary>
- **Quick Run**: Select a template from the "Agent Workflow" tab and run it.
- **Graphical Editing**: Open the editor, load a template or create a new one, and customize it.
</details>
<details>
<summary><b>Install Desktop Control (ACC)</b></summary>
Two installation options are available.
```powershell
# Option 1: Offline package installation
.\mcp\ai-computer-control\install.bat
# Option 2: pip installation
pip install -r mcp\ai-computer-control\requirements_offline.txt
```
</details>
<details>
<summary><b>Offline / Restricted Network Deployment</b></summary>
Package and deploy the Workbench.
```powershell
cd ruyi-workbench
powershell -ExecutionPolicy Bypass -File .\tools\package-offline.ps1 -SkipExeBuild -Variant 'offline-slim'
```
</details>
<details>
<summary><b>Connect More MCP Connectors</b></summary>
Add MCP connectors.
```powershell
# Create a folder for the MCP connector
# Write a ruyi-mcp.json file
# Restart the Workbench
```
</details>
<details>
<summary><b>Common CLI Commands and Troubleshooting</b></summary>
```powershell
node .\app\server.js doctor # Health check
node .\app\server.js mcp-config # MCP configuration
node .\app\server.js install # Register Workbench MCP with Claude CLI
node .\app\server.js mcp # Run MCP server
```
</details>
## Directory Structure
```
.
├── .github/ Windows e2e CI, Issue forms, and PR templates
├── ruyi-workbench/ Ruyi Workbench (Node backend + native JS three-column UI + self-contained MCP server)
│ ├── app/server.js Main service (zero npm runtime dependencies); dual-engine + native tool loop + MCP stdio bridge
│ ├── app/public/ index.html / app.js / styles.css (native JS, no framework, no build)
│ ├── docs/ Architecture documentation + manuals (USER-GUIDE / ADMIN-GUIDE)
│ └── tools/ Offline packaging / overlay upgrade / development scaffolding
├── mcp/
│ ├── ai-computer-control/ Built-in desktop control MCP (99 tools: screenshot/OCR/UIA/keyboard/mouse/window/Office/PDF)
│ └── README.md Drop-in connector (folder plug-and-play) documentation
├── dev-harness/ Verification scaffolding (100+ offline e2e, Node direct run)
├── docs/
│ ├── screenshots/ README interface screenshots (demo instance capture)
│ ├── branding/ Brand icons (blue-and-white ruyi cloud pattern SVG)
│ └── OPTIMIZATION-ROADMAP.md Iteration records and acceptance criteria (§0–§28)
├── LICENSE Apache-2.0 (including ai-computer-control)
├── THIRD-PARTY-NOTICES.md Third-party component and license list
├── CHANGELOG.md Bilingual release notes
├── CONTRIBUTING.md Contribution guide (including five hard constraints)
├── CODE_OF_CONDUCT.md Community code of conduct
├── SUPPORT.md Usage support and issue triage
└── SECURITY.md Security strategy and threat model
```
## Testing
All e2e tests can run offline, directly with Node, without packaging:
```powershell
node dev-harness\plan-mode.e2e.js # Single test
node dev-harness\repo-hygiene.e2e.js # Compliance regression
node dev-harness\meta-guard.e2e.js # Gatekeeper digital/authentication routing coverage
```
Each file header comment specifies the asserted boundary; the last line `... E2E: ALL PASS` is the pass criterion. Tests are run serially (port fixed, parallel runs would collide).
**Live tests that require setup** (not in offline regression list):
| e2e | Requires |
|---|---|
| `deepseek-live` / `deepseek-tools` | Actual DeepSeek API key (passed as command-line argument) |
| `desktop-bridge-live` / `desktop-mcp-smoke` | Python environment with installed ACC dependencies (related assertions skipped if dependencies are missing) |
## Security and Privacy
- Service listens only on `127.0.0.1` + page token; host whitelist resists DNS-rebinding; not exposed externally.
- All write operations are checked against checkpoint logs and can be rolled back one by one; execution-level operations are never persisted.
- Online tools have SSRF defense (rejects private network/loopback); data directory sensitive files are mutually rejected by file tools; API response key masks.
- Zero telemetry: no data reported; the only outbound traffic is to your configured model endpoint and search backend.
- Threat model and known boundaries are detailed in [`SECURITY.md`](./SECURITY.md).
## Branding and Compatibility Identifiers
To avoid disrupting existing connections, the following **existing compatibility identifiers are intentionally kept unchanged**: MCP server id `win-claude-workbench`, default data directory `~/.win-claude-workbench`, environment variable `WIN_CLAUDE_WORKBENCH_HOME` (`RUYI_HOME` takes priority, old variable still recognized).
## Clean-room Declaration
This project is a **clean-room independent implementation**: **does not contain** Anthropic leaked source code, **does not distribute** official Claude CLI (users prepare and register on their own machines), **does not replicate** third-party plugin source code. The license obligations of the bundled frontend static libraries (marked / highlight.js and themes) are listed in [`THIRD-PARTY-NOTICES.md`](./THIRD-PARTY-NOTICES.md).
> The interface screenshots in this README are taken from a local demo instance: the model endpoint is a scripted demo service (content is preset), and the key is a placeholder fake value; interface, tool cards, checkpoints, workflow runs, and usage accounting are all real functional captures.
## Contributing to Open Source
- Before submitting fixes, features, or documentation, please read [`CONTRIBUTING.md`](./CONTRIBUTING.md) for offline, clean-room, Windows compatibility, and e2e constraints.
- Bug and feature suggestions should use the repository's GitHub Issue form; see [`SUPPORT.md`](./SUPPORT.md) for issue and reproduction material organization.
- Current and historical version change summaries are in [`CHANGELOG.md`](./CHANGELOG.md).
- Please comply with [`CODE_OF_CONDUCT.md`](./CODE_OF_CONDUCT.md) to keep discussions friendly, focused, and collaborative.
- **Do not disclose unpatched security issues** in public issues, PRs, or discussions; report privately according to [`SECURITY.md`](./SECURITY.md).
## Licensing
[Apache-2.0](./LICENSE) (including `ai-computer-control`) · Third-party components see [`THIRD-PARTY-NOTICES.md`](./THIRD-PARTY-NOTICES.md) · Copyright 2026 Ruyi Workbench contributors.
## English
**Ruyi** is an offline-first, Windows-native, all-in-one AI workbench you can drive from any model endpoint — any OpenAI-compatible API *or* an on-prem Claude CLI. One Windows machine plus one reachable model = a local workbench that actually **does the work**: reads/writes files, runs scripts, drives the desktop and Office, and dispatches a team of sub-agents — every step auditable, reversible, and honestly metered. **Works with or without an internet connection.**
> Formerly **Win Claude Workbench**, renamed to **Ruyi** at v0.8 (trademark caution for open-sourcing, plus an old system prompt that made provider models misidentify as "I am Claude"). *Ruyi* means "as you wish"; the mark is a blue-and-white *ruyi* cloud motif.
### Why Ruyi (five differentiators)
1. **Operation-grade undo/rewind** — file checkpoints and conversation rewind ship as a pair; reversibility surfaces right on the permission prompt. OS-level undo is largely absent from most computer-use products.
2. **Text-only models can still drive the desktop** — OCR + UIA text grounding, no vision model required. Air-gapped networks often have text-only models; vision is an enhancement, not a prerequisite.
3. **Air-gap first, auditable, zero runtime deps** — a single `server.js` with **zero npm runtime dependencies** (Node built-ins only), framework-less vanilla-JS frontend, offline zip deployment. Minimal audit surface for enterprise/government review.
4. **Chinese-first with English support, built for non-programmers** — the interface defaults to Chinese and can follow the system language or switch to Simplified Chinese or English. Settings, Provider cards, safety/capability popovers, model menus, artifacts, shortcuts, the command palette, the skill library, and stable API errors are localized. Built-in skills and quick tasks follow the UI language, while user and project-authored content remains in its original language; simple/pro UI is shared by coders and non-coding knowledge workers.
5. **Dual engine, no lock-in** — any OpenAI-compatible endpoint (DeepSeek / Qwen / GLM / on-prem vLLM·Ollama) or an on-prem Claude CLI, switchable mid-session with cross-engine context continuation.
### Capabilities (v1.6.5)
Dual-engine chat with reliable `request_user_input` prompts (delivery-acknowledged across Claude CLI and OpenAI-compatible providers) · a native tool loop of 40 resident + 3 conditional built-in tools (read/edit/exec tiers) · desktop/Office control (screenshot / OCR / UIA / keyboard-mouse / window / Office / PDF — bundled ACC MCP v1.8.1, 99 tools, optional) · multi-agent orchestration (DAG workflows, **8 built-in templates**, **9 node roles**, **5 quality-gate modes**, graphical editor, live monitor canvas, intent-triggered auto-orchestration, plus a one-turn **Agent team** composer toggle shared by both drivers) · **team mode** (shared task pool with propose→approve→materialize, agent mailbox, directed steering of a running node) · trust layer (file checkpoints + conversation rewind as a pair, 5 permission modes × 3 tool tiers, full audit timeline) · Skills registry (four sources, progressive injection across both engines) · cross-session workbench memory (draft-then-confirm) · Playbooks · web search (8 backends incl. a zero-config built-in) with SSRF defenses · honest cost/usage dashboard (per-currency, sub-agents and compaction all metered) · tiered simple/pro UI with dark/light themes · localization runtime and dual catalogs for Simplified Chinese and English. Each feature ships through an implement → adversarial multi-agent review → fix → regression loop with 100+ offline e2e.
### Detailed documentation
| Topic | English | 中文 |
|---|---|---|
| Everyday operation | [User Guide](ruyi-workbench/docs/manuals/USER-GUIDE_EN.md) | [用户手册](ruyi-workbench/docs/manuals/USER-GUIDE_CN.md) |
| Deployment, engines, security, and regression | [Administrator Guide](ruyi-workbench/docs/manuals/ADMIN-GUIDE_EN.md) | [管理员手册](ruyi-workbench/docs/manuals/ADMIN-GUIDE_CN.md) |
| Offline package | [Offline Deployment](ruyi-workbench/docs/OFFLINE_DEPLOYMENT_EN.md) | [离线部署说明](ruyi-workbench/docs/OFFLINE_DEPLOYMENT_CN.md) |
| Runtime design | [Architecture](ruyi-workbench/docs/ARCHITECTURE_EN.md) | [架构说明](ruyi-workbench/docs/ARCHITECTURE_CN.md) |
| Clean-room rationale | [Source Review](ruyi-workbench/docs/SOURCE_REVIEW_EN.md) | [源码审阅结论](ruyi-workbench/docs/SOURCE_REVIEW_CN.md) |
| UI language contract | [Localization Guide](docs/i18n/README_EN.md) | [多语言兼容方案](docs/i18n/README.md) |
The complete bilingual documentation index is available in [docs/README.md](docs/README.md).
### Quick start
**Prerequisites:** Windows 10/11 + [Node.js](https://nodejs.org/) **≥ 20**. Zero npm runtime deps — no `npm install` needed.
```powershell
cd ruyi-workbench
node .\app\server.js serve --open
```
First launch walks you through picking a workspace folder and configuring a provider (DeepSeek preset recommended; on-prem vLLM/Ollama work too). The on-prem Claude CLI engine is optional and coexists with providers. Data dir defaults to `~/.win-claude-workbench`; override with `RUYI_HOME`.
### Desktop control (optional)
`mcp/ai-computer-control/` is a bundled **desktop-control MCP** (99 tools, ACC v1.8.1, requires **Python ≥3.12** for source installs). The verified full offline release includes CPython 3.12, a wheel-only dependency cache, and matching Chromium, so the target needs neither Python nor network access. Optional dependencies degrade gracefully in source installs.
At startup the workbench verifies that a candidate Python can import ACC. It recognizes both the release's `python_embed` runtime and the installer's `%LOCALAPPDATA%\ai-computer-control\runtime\python\python.exe`, while retaining the legacy `venv` fallback. `-IncludeAcc` now requires a checksummed, pre-hydrated payload; add `-BuildAccOffline` to build it on the connected packaging machine.
### Tests
All e2e run offline via `node dev-harness\<name>.e2e.js` (no packages to install). Run them **serially** — ports are fixed. Live tests (`deepseek-live`, `desktop-bridge-live`, …) require your own key / Python and are skipped by default.
### Security
Binds `127.0.0.1` + a page token; Host allowlist against DNS rebinding; every write goes through a rollback-able checkpoint journal; networked tools carry SSRF defenses; sensitive data-dir files are hard-denied to file tools; API responses mask secrets; zero telemetry. See [`SECURITY.md`](./SECURITY.md).
### Community
- Read [`CONTRIBUTING.md`](./CONTRIBUTING.md) before sending a fix, feature, or documentation update—the offline, clean-room, Windows-compatibility, and e2e constraints are non-negotiable.
- Use the repository's GitHub Issue forms for bugs and feature ideas; [`SUPPORT.md`](./SUPPORT.md) explains where to ask usage questions and what to include in a report.
- See [`CHANGELOG.md`](./CHANGELOG.md) for current and historical release highlights.
- Participate under the [`CODE_OF_CONDUCT.md`](./CODE_OF_CONDUCT.md).
- **Do not disclose unfixed vulnerabilities in public issues, PRs, or discussions.** Report them privately as described in [`SECURITY.md`](./SECURITY.md).
> Screenshots in this README were taken from a local demo instance: the model endpoint is a scripted local stub (canned content) with a placeholder API key; the UI, tool cards, checkpoints, workflow runs and usage accounting are the real features in action.
### License
[Apache-2.0](./LICENSE) (includes `ai-computer-control`). Third-party components are listed in [`THIRD-PARTY-NOTICES.md`](./THIRD-PARTY-NOTICES.md). Copyright 2026 Ruyi Workbench contributors.
Connection Info
You Might Also Like
No recommendations available