PilotDeck: Open-Source Agent OS Solves Memory, Cost & Offline Execution with 70% Savings

Introduction

While researching AI adoption for their team, the author encountered three recurring pain points with current AI agents: switching tools causes memory loss (context from Claude Code doesn't transfer to Cursor), costs are uncontrolled (simple queries and complex architecture tasks incur similar expenses), and agents stop working when the user goes offline (no persistent long-task monitoring or result persistence). PilotDeck, an open-source "Agent Operating System" jointly developed by Tsinghua THUNLP and MiniCPM (面壁智能) with 4.8k GitHub stars, addresses all three issues through WorkSpace isolation, white-box memory, smart routing, and always-on execution.

Three Pain-Point Solutions

1. WorkSpace-Level Isolation: Multi-Project Without Cross-Contamination

Each project gets an independent file system, memory, and skill set. Running ten projects in parallel keeps Project A's context from leaking into Project B. Traditional black-box agents share a single memory pool, causing "cross-contamination" — e.g., a casual social-media tone leaking into a formal executive report. PilotDeck confines retrieval scope to the current WorkSpace, eliminating this at the root.

2. White-Box Memory: Audit, Edit, and Roll Back Every Memory Entry

Most agents treat memory as a black box — you only see the conclusion, not the underlying entries. PilotDeck exposes the full memory lifecycle: generation, extraction, storage, and retrieval. If the AI records a wrong fact, you can locate that specific memory entry, edit or delete it, and avoid restarting the session. A built-in Dream Mode consolidates memories during idle time, and a one-click rollback restores the pre-Dream state.

3. Smart Routing + Always-On Execution: Cut Costs, Remove Babysitting

Smart routing automatically classifies task difficulty — complex tasks go to flagship models, simple calls descend to lightweight models. The README provides benchmark data for a batch of social-media operations tasks:

Configuration                              Cost    Multiple
Smart routing ON (Opus 4.5 primary + Sonnet 4.5 secondary)   $2.83   1.1×
Smart routing OFF (all Opus 4.5)                              $12.58  5.0×
Single-model long-thinking (estimated)                        $12.20  4.8×

Enabling smart routing reduced cost from $12.58 to $2.83 — a ~70% saving . In another benchmark of 7 complex tasks, the "strong primary + light secondary" combo achieved higher scores at 1/6 the cost of a single flagship model. Routing uses four tiers (Simple, Medium, Complex, Reasoning) with Medium as default, driven by a judgment model.

Always-on execution breaks the "you ask, I answer" loop. After you go offline, the agent continues discovering candidate tasks, running long-running monitors, and writing results to local files with a report waiting for your review. The workflow: periodic check → discover task → prepare workspace copy → execute in copy → generate report → human review → apply; sleep when no tasks.

Why It Dares Call Itself an "Operating System"

Typical agent tools hard-code "model + tools" into a single loop. PilotDeck introduces a true layered architecture:

Interaction Layer : CLI, TUI, Web UI, Electron desktop, Feishu/WeChat IM — five entry points sharing one backend for consistent experience.

Gateway Layer : Unified request handling, routing judgment, session localization, context assembly.

Capability Layer : WorkSpace, Memory, Smart Routing, Always-on all exposed as pluggable modules.

It builds on existing open-source components rather than reinventing: smart routing uses OpenBMB's ClawXRouter , memory system uses ClawXMemory , RAG uses UltraRAG . Extensibility via a single plugin.json connects MCP Servers, Tools & Skills, Lifecycle Hooks, and custom Memory modules with clean boundaries.

Installation & Configuration

One-command install (macOS/Linux):

curl -fsSL https://raw.githubusercontent.com/OpenBMB/PilotDeck/main/install.sh | bash
pilotdeck          # start, visit http://localhost:3001

Windows via PowerShell:

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

Or Docker Compose: docker compose up -d --build After installation, configure model providers in the Web UI. Supported: OpenAI, Anthropic, Gemini, DeepSeek, Qwen, Kimi, MiniMax, and local Ollama.

Enterprise Adoption: Turning Agents into Infrastructure

1. Team Transformation Approach

Upgrade agents from "personal chat toys" to "team knowledge-work infrastructure" by nailing three pillars: multi-project isolation, auditable memory, traceable costs. PilotDeck's WorkSpace + white-box memory + smart routing map directly to these, making it a solid foundation for mid/back-office teams starting agent transformation.

2. Batch Deployment

Docker Compose launches services uniformly; pilotdeck.yaml centralizes model pool and routing rules so the whole team shares one provider list and price table, preventing fragmented configs and cost sprawl.

3. Business System Integration

Native MCP connects existing toolchains; Lifecycle Hooks inject team logic at key points (e.g., permission checks in PreToolUse); Feishu/WeChat/Enterprise WeChat IM integration brings AI directly into work chats. All via plugin.json without touching the core.

4. Team Standards Customization

WorkSpace templates codify directory structure and skill libraries for new-hire readiness; white-box memory enables compliance audits (what decisions were recorded, can they be traced); model pricing panel computes cost per token in real time, turning "AI spend" into a measurable KPI.

Pros, Cons & Gotchas

Strengths : All three designs hit real pain points, not gimmicks; dual academic/engineering backing from Tsinghua and MiniCPM; v2.0 just released, ecosystem expanding.

Limitations :

AGPL-3.0 strong copyleft — the biggest trap. If PilotDeck is offered as an external SaaS, derivative code must be open-sourced. Internal use without external service typically doesn't trigger the network clause, but legal review is mandatory before commercial use.

Not a top-tier player yet — 4.8k stars; competitors like Claude Cowork and WorkBuddy occupy overlapping positions; community and ecosystem still early.

Value realization has a threshold — "auditable memory, traceable cost" aren't instant delights; teams must actually run long tasks across multiple projects to feel the benefit.

Common Issues :

Media assets use Git LFS; source install skips demo videos/GIFs by default — run git lfs pull manually.

Node version pinned to 22.13+ and <23 (due to bundled SQLite runtime); verify before upgrading Node.

Smart routing savings depend on task difficulty distribution — if all tasks are heavy, savings shrink; pilot on a small scope before rolling out.

Personal Take

Objectively, PilotDeck isn't a "wow on first install" tool. Its value lies in systematically embedding "long-term, multi-project, auditable, cost-controlled" capabilities into a single architecture . Tsinghua and MiniCPM's backing gives the design academic rigor; white-box memory and smart routing directly puncture the two vaguest areas of current agent tools. But the 4.8k-star scale, AGPL constraints, and overlap with Claude Cowork / WorkBuddy signal it's still in "worth watching" rather than "blindly adopt" territory.

For individuals, it's a sober choice for multi-project long tasks; for teams, it's a foundation worth serious evaluation before agentizing workflows. Whether it grows into a true "Agent OS" depends on how far the post-v2.0 ecosystem rolls.

GitHub repository: https://github.com/OpenBMB/PilotDeck