OpenBMB/PilotDeck

Task-oriented AI Agent productivity platform — redefining operational boundaries and memory evolution, one WorkSpace at a time.

     

English | 简体中文
Website · Live Demo · Tutorial · Quick Start · Highlights · Use Cases · Community

---

News 🔥

• [2026.10.15] PilotDeck 2.0 is here! Get started with one-click installation and visual configuration, and keep long-running tasks on track, even across 2,000 interaction messages! New high-quality Word / Excel / PPT Skills deliver office-ready results with a single click. Visit pilotdeck.openbmb.cn to try it out and contribute.
• [2026.05.28] PilotDeck is now open source! Visit our official website at pilotdeck.openbmb.cn. We welcome contributions, feedback, and stars from the community.

---

💡 About PilotDeck

PilotDeck is an open-source agent operating system designed around the concept of "WorkSpace". It is jointly developed and open-sourced by Tsinghua University THUNLP, ModelBest, OpenBMB, and AI9Stars. Targeting general-purpose, multi-task scenarios, PilotDeck is built to be a true productivity tool for the Agent era.

A wave of excellent AI Agent harnesses has emerged in recent years, each with its own focus: Claude Code / Cursor / Trae Solo brought model reasoning deep into the programming IDE; Claude Cowork introduced the notion of project-level isolation to desktop-side knowledge work; WorkBuddy connected agents to IM ecosystems such as WeCom and Feishu so AI is one message away.

When we shift the lens from "one-shot programming" or "immediate Q&A" to long-running, multi-project productivity work, however, several questions remain open:

• When many projects run in parallel, can memory be white-box and traceable? When the AI gets something wrong, can you pinpoint which memory entry caused it and edit it directly — without starting a new chat from scratch?
• Can token cost be tracked per task, so that running agents in the background actually becomes economically viable?
• Can tasks of different difficulty automatically be matched to different models, instead of burning the flagship model on trivial calls?
• When you step away from the keyboard, can the work keep moving? Can the agent proactively discover what's worth doing, report progress, and land results as files on disk?

PilotDeck is an incremental exploration around exactly these questions. It uses the WorkSpace as the fundamental unit — completely isolating files, memory and skills per project — and pairs it with three pillar capabilities: White-box Memory, Smart Routing and Always-on. The entire system natively supports the Model Context Protocol (MCP) and behaves consistently across front-ends (Web / CLI / IM).

✨ Key Highlights

WorkSpace-Level Isolation & Accretion Every project gets its own file system, memory store and skill set. Parallel work no longer interferes with itself, retrieval has a bounded scope, and skills accrete naturally as each task grows — no more global context pollution.	Traceable White-box Memory Memory generation, extraction, storage and retrieval are visible end-to-end. When the AI mis-remembers, you can pinpoint and fix the offending entry. Built-in Dream Mode consolidates memory in idle windows, and supports one-click rollback.
Smart Routing & Cost Optimization Task difficulty is auto-detected; complex calls go to flagship models (e.g. Claude 3.5 Sonnet / GPT-4o), simple ones drop to lighter models. Through on-device / cloud co-orchestration and precise matching, token spend shrinks dramatically without sacrificing quality.	Always-on Background Execution PilotDeck breaks the "you ask, it answers" loop: after you sign off, the agent keeps discovering candidate tasks, running long-horizon monitors, and finally lands deliverables as local files with a summary report waiting for you.

📊 Real-world Numbers

The three pillar capabilities have shown clear advantages in production-grade workflows:

1. Smart Routing — ~70% cost savings on social-media workloads

In Xiaohongshu-style social-media operations, enabling Smart Routing automatically demotes simple polishing / layout tasks to a sub-agent (e.g. Sonnet 4.5) and only invokes Opus 4.5 at planning checkpoints:

Setup	Model configuration	Cost	Multiplier
Smart Routing ON	Opus 4.5 (main) + Sonnet 4.5 (sub)	$2.83	1.1×
Smart Routing OFF	All Opus 4.5 (main + sub)	$12.58	5.0×
Monolithic	Single Opus 4.5 long-react (estimated)	$12.20	4.8×

2. Smart Routing — 1/6 the cost while beating frontier models on hard tasks

The research team benchmarked 7 complex tasks (multilingual podcast push, multi-source data reports, domain-specific literature review, codebase architecture docs, etc.). The "strong main + light sub" routing setup matches or beats the frontier single-model setup at a fraction of the cost:

Setting	Score	Cost
MiniMax-M2.7 single-agent	37.1	$1.90
Claude Sonnet 4.6 single-agent	69.1	$18.36
Sonnet 4.6 (main) + MiniMax-M2.7 (sub)	70.6	$3.15

3. White-box Memory — layout & tone never bleed across projects

In black-box agents, mixing tasks in a shared context pool inevitably pollutes memory. PilotDeck's WorkSpace-scoped white-box memory addresses this end-to-end:

Dimension	Current AI Agents (black-box)	PilotDeck (white-box)
Visibility	You can't see what the AI remembers, only what it outputs	View every memory entry: what was stored, when, and which WorkSpace
Control	Once written, memory can't be edited or removed	Edit / delete entries, pin critical decisions so they don't drift
Traceability	When it goes wrong, you can't find the root cause	Generation → extraction → storage → retrieval, all auditable
Isolation	One shared pool — projects bleed into each other	Scoped per WorkSpace; A's memory never reaches B
Reversible	After compression, the original is gone	Dream-mode supports one-click rollback to the prior state

---

🖥️ UI & Demo

PilotDeck ships an out-of-the-box Web UI with full WorkSpace management, white-box memory editing, and visualization of multi-agent collaboration.

Use Cases

All demos below are generated entirely by edge-side models via PilotDeck's Smart Routing — no cloud-side frontier model required.

Work Document Generation

"Survey the Chinese LLM application market and turn it into a formal HTML white paper."

Process	Result

Mini-Game Development

"Walk me through building an iOS AR mini-game Ball Finder in Vibe Coding mode."

Process	Result

AI Engineering Platform Development

"Build a low-code embedding fine-tuning platform from scratch."

Process	Result

Audio-Video Editing & Social Media Operations

"Push this English podcast to a global audience in Chinese / Japanese / French / Korean / Spanish / Arabic."

Process	Result (with audio)
	https://github.com/user-attachments/assets/a7245467-ee3c-4939-a055-c56576ac56d1

---

📦 Installation & Quick Start

We provide one-line installers for macOS / Linux and Windows PowerShell, plus a source-based workflow for developers.

Option A: One-line install (recommended, macOS / Linux)

curl -fsSL https://raw.githubusercontent.com/OpenBMB/PilotDeck/main/install.sh | bash

The script checks/uses the supported Node.js 22 runtime (22.13+ and <23, required for the built-in SQLite runtime), clones the repo, installs dependencies, and builds the frontend. On Linux it can install missing system packages when sudo and a supported package manager are available. On macOS, make sure Xcode Command Line Tools and a Python with distutils are usable before running the installer. Once it finishes:

If Node.js or npm package downloads are slow or unreliable on your network, set reachable mirrors before running the installer:

curl -fsSL https://raw.githubusercontent.com/OpenBMB/PilotDeck/main/install.sh | \
  PILOTDECK_NODE_DIST_MIRROR=https://npmmirror.com/mirrors/node \
  NPM_CONFIG_REGISTRY=https://registry.npmmirror.com bash

You can also keep the official Node.js host as the primary source and opt in to one or more trusted fallback mirrors with PILOTDECK_NODE_DIST_FALLBACK_MIRRORS.

pilotdeck            # starts the server at http://localhost:3001
pilotdeck status     # check runtime status

To open PilotDeck again later on macOS / Linux, run pilotdeck in a terminal and open the printed URL in your browser. If your shell has not picked up the PATH update yet, open a new terminal or source your shell profile first.

pilotdeck
then open http://localhost:3001, or the URL printed by the command

Option A2: One-line install (Windows PowerShell)

Run PowerShell as a normal user, then execute:

powershell -ExecutionPolicy Bypass -c "irm https://raw.githubusercontent.com/OpenBMB/PilotDeck/main/install.ps1 | iex"

The PowerShell installer uses Windows-native paths under %USERPROFILE%\.pilotdeck, checks Node.js 22.13+ with node:sqlite, installs missing prerequisites with winget when available, builds PilotDeck, and creates a pilotdeck.cmd launcher in %USERPROFILE%\.pilotdeck\bin. Git LFS media assets are optional for the core app; if Git LFS is unavailable or times out, the installer continues without demo videos/GIFs.

After installation, the script starts PilotDeck and prints the UI URL, usually http://localhost:3001. It does not automatically open a browser, so copy that URL into your browser to finish onboarding (provider + API key). You can also open it from PowerShell:

Start-Process http://localhost:3001

If this is your first install, open a new PowerShell window after the script updates your user PATH, then run:

pilotdeck            # starts the server at http://localhost:3001
pilotdeck status     # check runtime status

To open PilotDeck again later, run pilotdeck from a new PowerShell window, then open the printed URL in your browser. If pilotdeck is not yet on PATH, run the launcher directly:

& "$HOME\.pilotdeck\bin\pilotdeck.cmd"

Windows PowerShell FAQ

npm.ps1 cannot be loaded because running scripts is disabled

This can still happen when you run development commands such as npm run dev directly in Windows PowerShell for the first time. PowerShell may resolve npm to npm.ps1, and the default execution policy can block that shim.

Fix it once for the current user, then reopen PowerShell:

Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned

If you do not want to change the user policy, run the cmd shim explicitly instead:

npm.cmd run dev

Native dependency build errors (node-gyp, MSBuild, or Python not found)

The installer normally uses prebuilt packages for native dependencies such as node-pty, better-sqlite3, bcrypt, and sharp. On a fresh Windows machine, if npm cannot download a matching prebuild and falls back to compiling from source, install Visual Studio Build Tools with the C++ workload and Python, then rerun the installer.

GitHub returns 429: Too Many Requests while downloading install.ps1

GitHub may rate-limit repeated raw.githubusercontent.com requests from shared networks. Wait a few minutes and rerun the one-line command, or download install.ps1 from the repository and run it locally with powershell -ExecutionPolicy Bypass -File .\install.ps1.

Option B: From source (for developers)

Need platform-specific dependency installation commands? See the Source Installation Guide.

1. Clone and install dependencies

By default, skip large Git LFS demo media to keep the source install lightweight. If you need the demo videos/GIFs later, run git lfs pull after cloning.

GIT_LFS_SKIP_SMUDGE=1 git clone https://github.com/OpenBMB/PilotDeck.git
cd PilotDeck
node --version          # must be v22.13.0 or newer, and below v23
corepack enable         # enables the pinned pnpm version from package.json
corepack pnpm install --frozen-lockfile --filter pilotdeck --filter pilotdeck-ui

PilotDeck uses the committed pnpm-lock.yaml for reproducible source installs. The filters keep Electron packaging dependencies out of Web-only installs. Prefer the corepack pnpm ... command above instead of npm install; on macOS, this also avoids unnecessary native rebuild fallbacks when matching prebuilt packages are available.

2. Configure a model provider

PilotDeck reads ~/.pilotdeck/pilotdeck.yaml. You can create it manually, or just open the Web UI and configure providers visually in onboarding. Supported protocols include OpenAI, Anthropic, native Google Gemini, DeepSeek, Qwen, Kimi, MiniMax and other OpenAI-compatible endpoints.

If the config file is missing, PilotDeck starts the Web UI without the Gateway and opens onboarding. Saving a valid provider, API key, and model writes the config and starts the Gateway automatically.

schemaVersion: 1
agent:
  model: deepseek/deepseek-v4-pro
model:
  providers:
    deepseek:
      protocol: openai
      url: https://api.deepseek.com/v1
      apiKey: sk-your-api-key

Native Gemini can be configured with protocol: google:

schemaVersion: 1
agent:
  model: google/gemini-3.1-pro-preview
model:
  providers:
    google:
      protocol: google
      url: https://generativelanguage.googleapis.com
      apiKey: ${GEMINI_API_KEY}
      models:
        gemini-3.1-pro-preview: {}

Local Ollama models can be configured without an API key. PilotDeck uses Ollama's OpenAI-compatible /v1/chat/completions endpoint:

ollama serve
ollama pull qwen3:0.6b

schemaVersion: 1
agent:
  model: ollama/qwen3:0.6b
model:
  providers:
    ollama:
      protocol: openai
      url: http://localhost:11434/v1
      models:
        qwen3:0.6b: {}

3. Start the services

cd ui && npm run dev     # dev mode (HMR), visit http://localhost:5173
or
cd ui && npm run start   # production mode, visit http://localhost:3001

Option C: Docker Compose

If Docker is installed, you can start PilotDeck with:

docker compose up -d --build

For full Docker configuration, see README_DOCKER.md.

---

🛠️ Extension Protocol

PilotDeck has an open plugin architecture with a strict boundary between the open-source core and plugin customization. Extending the system is a plugin.json away:

• MCP Servers — first-class integration with any Model Context Protocol server.
• Tools & Skills — register custom tools, or pull community skills via ClawHub.
• Lifecycle Hooks — intercept PreToolUse, UserPromptSubmit, and other critical lifecycle events.
• Custom Memory — plug in your own memory store provider.

---

🤝 Contributing

Thanks to everyone who has contributed code, feedback, and ideas. New contributors are warmly welcome — let's build the next-gen agent OS together.

Workflow: Fork → feature branch → PR.

---

💬 Community

• For bugs and feature requests, please open a GitHub Issue.
• Join our community channels:

WeChat Community	Feishu Community	Discord Community

---

🙏 Acknowledgements

We thank Agent OS pioneers such as OpenClaw, Claude Code, Codex, Cursor, and Hermes for their explorations that helped shape this field.

PilotDeck builds upon the following outstanding open-source projects:

• ClawXRouter — Intelligent model routing
• ClawXMemory — Agent memory system
• Claude Code UI — Web UI reference
• Claude Code Router — Model routing reference
• UltraRAG — RAG framework
• Anthropic Skills — Agent skill framework and built-in skills (skill-creator)
• Vercel Labs Skills — find-skills skill
• frontend-slides — Create beautiful slides on the web using a coding agent's frontend skills
• Karpathy Guidelines — LLM coding behavioral guidelines
• Vite — Frontend build tool
• React — UI framework
• Tailwind CSS — Utility-first CSS framework
• shadcn/ui — Accessible component primitives for React

---

🏢 Joint Development

PilotDeck is jointly developed by Tsinghua University THUNLP, ModelBest, OpenBMB and AI9Stars.

---

⭐ Support Us

If PilotDeck has been helpful in your work or research, please consider giving us a Star on GitHub!

---

📝 Citation

@misc{pilotdeck2026,
  author       = {PilotDeck Team},
  title        = {PilotDeck: A WorkSpace-Centric Open-Source Agent Operating System},
  howpublished = {\url{https://github.com/OpenBMB/PilotDeck}},
  year         = {2026},
  note         = {Accessed: 2026-05-29}
}

📄 License

This project is licensed under the GNU Affero General Public License v3.0.