Feima Pilot Deck

Accelerating intent into execution.

Feima Pilot Deck is an AI-native command center for software architects structured around the SUM (Sovereign-Utility Matrix). It brings your entire development context — cloud services, sandboxes, and AI agents — under a single sovereign interface.

Phase 1 — The Sovereign Foundation establishes the three non-negotiable architectural pillars on which every subsequent phase is built.

The codebase targets two deployment surfaces simultaneously: a Web/Linux Server for SaaS/multi-tenant scenarios, and a Desktop Sidecar embedded in Tauri. One TypeScript/Node.js codebase, zero platform forks. The Engine detects its runtime context and adapts transport and lifecycle accordingly.

Every capability is exposed through a typed, versioned API before any UI is built. The UI is a thin, replaceable client over the Engine's API surface. This ensures headless automation, testing, and third-party integrations are first-class concerns.

The Core Engine is a registry of modules — nothing is hardcoded. Even the Terminal is a plugin registered against the Core Engine. This ensures every capability can be swapped, extended, or removed without touching core logic.

• The Engine exposes a uniform plugin API.
• Built-in capabilities (Terminal, File Browser, AI Chat) are implemented as first-party plugins through that same API.
• Third-party plugins are equal citizens.

Data residency is non-negotiable. Local context, embeddings, and session state never leave the machine unless explicitly routed to a user-approved cloud provider. Credentials live in the OS keychain, not application state.

Every command execution is routed through a sandbox Provider. The Engine acts as a Provider Switcher — it never executes code directly.

Providers are plugins. Swapping from Docker to E2B (or any future provider) requires no changes to the commands or agents running on top.

On Desktop, the Core Engine runs as a Sidecar process managed by Tauri. The Rust shell handles windowing, OS integration, and sidecar lifecycle; the Engine handles all business logic. This isolates the TypeScript runtime from the UI process and enables Engine updates independent of the shell.

All Engine-to-UI communication uses oRPC for type-safe, structured data transmission. RPC boundaries are explicit, versioned, and generate client types from server definitions. No implicit REST mappings, no drift between backend and frontend contracts.

We do not commit to a single transport protocol. The architecture supports multiple protocols where each is the best fit:

State is stored where it makes sense, not centralized for convenience:

┌─────────────────────────────────────────────────────┐
│                   React UI Layer                    │
│         (Component-driven, TypeScript-first)        │
└─────────────────────┬───────────────────────────────┘
                      │  Tauri IPC (type-safe commands)
┌─────────────────────▼───────────────────────────────┐
│              Tauri Core (Rust)                      │
│  • Window management & OS integration               │
│  • Credential vault (OS keychain bridge)            │
│  • Sidecar process lifecycle management             │
└─────────────────────┬───────────────────────────────┘
                      │  stdio / JSON-RPC
┌─────────────────────▼───────────────────────────────┐
│        Core Engine (TypeScript / Node.js)           │
│  • Plugin registry (all capabilities are plugins)   │
│  • Provider switcher (Docker ↔ E2B ↔ custom)        │
│  • AI agent orchestration                           │
│  • Local embedding & context indexing               │
└──────────┬──────────────────────┬───────────────────┘
           │                      │
┌──────────▼──────┐    ┌──────────▼──────┐
│  Docker Plugin  │    │   E2B Plugin     │
│  (Local / OCI)  │    │  (Cloud / API)   │
└─────────────────┘    └─────────────────┘

Setup instructions coming soon. The project is in active early development.

Contribution guidelines will be published alongside the first public release.

MIT.