PilotDeck – Tsinghua and ModelBest's Open-Source Agent Operating System

1. What Is PilotDeck

PilotDeck is a next-generation agent operating system jointly open-sourced by Tsinghua University's NLP Lab (THUNLP), ModelBest, OpenBMB, and AI9stars. Centered on the WorkSpace paradigm, it establishes independent filesystems, memory storage, and skill sets per project—enabling multi-task parallelism and physical isolation. The system innovates with white-box memory, intelligent routing for dynamic model allocation, and a 24-hour Always-on persistent task engine. Verified cost savings exceed 70% while supporting edge-cloud collaboration and automatic on-device model deployment—evolving AI from one-shot dialogue toys into sustainable productivity tools.

Image source: Official article

Technical positioning and domain: PilotDeck belongs to the agent operating system (Agent OS) space, positioned as AI agent infrastructure for complex multi-task scenarios. Unlike traditional Agent frameworks (AutoGPT, LangChain Agents), PilotDeck redefines Agent resource management at the OS level—providing independent runtime environments per project, analogous to containerization's contribution to application isolation.

Development background: Jointly developed by THUNLP and ModelBest and partners. THUNLP has deep NLP and knowledge graph expertise; ModelBest focuses on on-device models and agent systems. Motivation: existing Agent frameworks lack task isolation, memory management, and cost control—aiming for an enterprise-grade, long-running, scalable, auditable Agent platform.

Core value: PilotDeck solves three core Agent runtime pain points: multi-project resource isolation (preventing memory pollution and skill conflicts), transparent memory management (white-box traceable and rollback-capable), and cost optimization (intelligent routing auto-allocating edge/cloud models). Verified data shows 70%+ cost reduction versus traditional approaches in typical multi-task scenarios, with 40%+ task completion rate improvement.

Technical characteristics: WorkSpace three-layer architecture (dedicated filesystem, memory storage, skill set) enables project-level physical isolation. Intelligent routing identifies task complexity and dynamically schedules models. Always-on engine gives Agents initiative to discover unfinished work and continue autonomously. Edge-cloud collaboration supports automatic on-device model deployment (e.g., VoxCPM for speech) with lifecycle management—no manual Ollama configuration.

2. Key Features

• WorkSpace pods: Independent living space per project with dedicated filesystem, memory storage, and skill set. Inspired by OS process isolation—data, memory, and skills do not interfere across projects—fundamentally solving resource conflicts in multi-Agent collaboration.

• White-box memory: Full-chain visibility, control, and traceability. Users view every memory operation in the Web console, pinpoint erroneous memories, and correct or delete with one click. Task-scoped Dream auto-consolidation prevents memory pollution and improves long-term task consistency.

• Intelligent routing: Auto-identifies task difficulty and dynamically allocates models. Simple tasks use lightweight on-device models (MiniCPM series); complex tasks use top cloud models (GPT-4, Claude 3). Built-in cost-effectiveness algorithm maximizes savings while preserving output quality—verified 70%+ API cost reduction.

• Always-on persistent tasks: Agents proactively scan project state, discover todos, execute actions, and generate output files. One instruction can run hours or days in background without repeated manual triggers—suitable for long-cycle content creation and model training.

• Edge-cloud collaboration: On-device models as sub-Agents for specific tasks with automatic deployment (e.g., VoxCPM speech models). System manages download, loading, and lifecycle—true plug-and-play hybrid inference without manual Ollama setup.

• Cross-project knowledge transfer: Skills evolve with task progress; controlled knowledge migration and reuse across WorkSpaces. Export skill packs (data pipelines, code templates) from one project and import into another—accelerating new projects and avoiding duplicate work.

3. How to Use

1. Environment requirements: macOS (Intel or Apple Silicon) and Linux (Ubuntu 20.04+, CentOS 7+). Python 3.10+; at least 8GB RAM (16GB recommended). On-device auto-deployment requires NVIDIA GPU (CUDA 11.8+) or Apple MPS.

2. One-click install: Run official curl command in terminal, e.g.: curl -sSL https://raw.githubusercontent.com/OpenBMB/PilotDeck/main/install.sh | bash. Install script downloads dependencies, configures environment variables, and sets system services.

3. Start service: Run pilotdeck to start backend. Default listen http://localhost:3001; open in browser for Web console. First start initializes database and default WorkSpace template.

4. Create WorkSpace: In Web UI click "New WorkSpace," enter project name (e.g., "Game Development"), description, and file boundaries (allowed directory paths). System auto-creates dedicated filesystem and memory storage.

5. Configure skills: In WorkSpace settings, install skill packs from built-in marketplace—code generation, data analysis, document writing, etc. Agent auto-learns skills and accumulates project-specific capabilities during task execution.

6. Issue instructions: Enter natural-language tasks in dialogue (e.g., "Develop a Zelda-style 3D open-world game"). Agent auto-plans steps, invokes skills, executes code, and generates output files. View thinking process, execution logs, and intermediate results in "Memory View" with manual intervention support.

7. Notes: For long-running tasks (model training), enable "Always-on" in WorkSpace settings and prevent system sleep. First on-device model load may take time—pre-download common models for cache.

4. Pros and Cons

5. Comparison with Similar Tools

Selection advice: For enterprises needing multi-project parallelism, strict data isolation, and cost control (game dev, content creation, model training), PilotDeck is the best choice—WorkSpace isolation and intelligent routing boost efficiency and cut costs. Research teams wanting rapid multi-Agent collaboration may prefer CrewAI's flexible role orchestration—but lack isolation and white-box memory. Personal experiments and small projects: AutoGPT's simple loop is faster to start but cannot handle long-term tasks and complex dependencies.

6. Editor's Take

PilotDeck makes highly innovative contributions to agent operating systems. WorkSpace design draws on containerization and OS process isolation—elevating Agent resource management to system level—a key problem most Agent frameworks overlook. White-box memory solves the "black-box trust" problem in AI deployment—users debug Agent thinking like debugging code—invaluable for enterprise compliance and audit. Practically, intelligent routing's 70% cost savings and Always-on engine efficiency gains are validated in real projects (e.g., interactive 3D game in one day). Primary audience: professional developer teams running long-term, multi-project workloads, and enterprises embedding AI deep into business processes. As on-device models improve (ModelBest's MiniCPM series), edge-cloud collaboration advantage will grow—potential standard component of next-gen AI infrastructure. Documentation and community ecosystem remain weaknesses needing continued investment. —deductions for learning curve and documentation; core innovation and results are industry-leading.

7. Application Scenarios

• Game development: Single WorkSpace instruction "Develop a Zelda-style 3D open-world game"—Agent auto-plans scenes, writes code, generates assets. Verified: interactive prototype with terrain, physics, NPC dialogue in one day—dramatically shortening game dev cycles.

• Multilingual podcast generation: With VoxCPM speech model in WorkSpace and podcast skill pack, enter topic to auto-generate multilingual podcast content in 30 languages. Agent handles script, synthesis, editing—output ready-to-publish audio.

• Mobile app development: Rapid lightweight app prototypes such as gyroscope mini-games. Agent invokes code generation skills, writes HTML5/JavaScript and packages—browser testing for PMs to validate ideas quickly.

• AI model training: Automate training pipelines. Configure training scripts and datasets in WorkSpace—Agent handles environment setup, training start, loss monitoring, checkpoint resume—long-cycle background runs with progress tracking.

• Long-cycle content creation: Industry white papers, screenplay writing—complex documents needing continuous iteration and memory accumulation. Agent remembers writing style, references, and revision feedback—auto-advances chapters daily with periodic user review.

8. FAQ

Q: What is the main difference between PilotDeck and AutoGPT?
A: PilotDeck is OS-level Agent platform with WorkSpace isolation, white-box memory, intelligent routing. AutoGPT is single-Agent loop framework lacking task isolation and long-term memory management. PilotDeck suits enterprise multi-project parallelism; AutoGPT suits personal experiments.

Q: Does it support private deployment? What hardware is needed?
A: Full private deployment—all data stored locally. Recommended: 16GB RAM, 4-core CPU; on-device auto-deployment needs NVIDIA GPU (8GB+ VRAM) or Apple MPS. Pure CPU mode works but on-device inference is significantly slower.

Q: How do I customize skill packs?
A: Skill packs are Python modules following PilotDeck plugin spec. Write code in WorkSpace "Skill Development" UI defining input/output interfaces, package and upload to local skill market. Official docs provide guides and examples.

Q: Does white-box memory affect performance?
A: White-box records detailed metadata on each operation, but async write and compressed storage make impact negligible—task completion time increases <5% in testing, far less than audit value gained.

Q: Does Always-on support recovery after network disconnection?
A: Yes. WorkSpace periodically saves task snapshots. After network interruption or system restart, Agent resumes from latest snapshot without starting over—provided task does not depend on external real-time data.

Q: What is the intelligent routing model selection strategy?
A: Routing uses task complexity scoring—analyzing task description, historical execution data, and current model performance. Simple tasks (summarization, code formatting) use on-device MiniCPM; complex tasks (multi-step reasoning, code generation) use cloud GPT-4 or Claude 3. Manual override available in WorkSpace settings.

9. Project Links

• Official site: https://pilotdeck.openbmb.cn/pilotdeck.github.io/
• GitHub repository: https://github.com/OpenBMB/PilotDeck
• HuggingFace models: https://huggingface.co/OpenBMB (MiniCPM on-device model series)
• Technical paper: Not yet published; see ModelBest official blog https://blog.openbmb.cn/