Roadmap

Realistic 12-month plan for a solo developer working 30-40h/week. Each phase has a clear business objective before moving to the next. The search must be instant and reliable — nothing else matters until Phase 1 ships.

Market research completed (Feb 2026). Key insight: AI assistant market $3.35B (2025) → $24.53B (2034) at 24.8% CAGR. Rewind (dead), Raycast (Mac-only), Microsoft Recall (privacy backlash) all validate our direction. MCP ecosystem (10,000+ servers) ready for integration.

Vision update (Feb 2026): Ghost evolves from “search bar” to Agent OS — a local-first Universal Protocol Hub that speaks MCP + A2A + AG-UI + A2UI + WebMCP, connecting users to the entire AI agent ecosystem while keeping all data private. Not replacing the file explorer — sitting above the OS as its intelligence layer.

Protocol stack: MCP (tools) → A2A (agent-to-agent) → AG-UI (agent↔user runtime) → A2UI/MCP Apps (generative UI) → WebMCP (web agents)

Phase 0 — “Foundation” (Weeks 1-3)

Goal: Validate the stack works on your machine before writing UI.

Technical Deliverables

Tauri v2 shell setup
- Initialize project with create-tauri-app (React + TypeScript)
- Configure global shortcut plugin (tauri-plugin-global-shortcut)
- Configure filesystem plugin (tauri-plugin-fs)
- Verify <500ms cold start on Windows
- Test IPC bridge: Rust command → React render
Rust core engine scaffold
- Create module structure: indexer/, db/, embeddings/, search/
- Set up error handling with thiserror + anyhow
- Configure logging with tracing crate
SQLite + sqlite-vec + FTS5
- Integrate rusqlite with bundled SQLite
- Load sqlite-vec extension via sqlite3_auto_extension FFI
- Create schema: documents, chunks, chunks_fts (FTS5), chunks_vec (vec0 768-dim)
- Validate: hybrid query combines FTS5 keyword + vector KNN via RRF
- 16 unit tests passing
Ollama embedding pipeline
- HTTP client to Ollama API (/api/embeddings)
- Pull and test nomic-embed-text (768 dimensions)
- Batch embedding: process multiple chunks asynchronously
- Graceful degradation when Ollama is unavailable
Native AI embedding engine (Phase A — Universal)
- Replace hard Ollama dependency with native in-process inference
- Candle (HuggingFace Rust ML) for BERT model execution
- all-MiniLM-L6-v2 (384D, ~23MB) — runs on any CPU, no internet after first download
- Fallback chain: Native → Ollama → FTS5-only keyword search
- Hardware detection: CPU cores, AVX2/NEON SIMD, GPU (CUDA/Metal/Vulkan)
- Configurable vector dimensions (384 native, 768 Ollama)
- Frontend StatusBar shows active AI backend (Native/Ollama/Offline)
- Zero compilation warnings, all tests passing
File watcher
- Integrate notify crate for filesystem events
- Debounce rapid file changes via notify-debouncer-mini (500ms window)
- start_watcher Tauri command spawns background tokio task
- Automatic re-indexing on file change, de-indexing on file delete
Text extraction pipeline
- PDF extraction via lopdf
- DOCX extraction via zip crate (read word/document.xml from DOCX archive)
- XLSX extraction via calamine
- Plain text / Markdown passthrough
- Chunking strategy: 512 tokens with 64 token overlap
Search via IPC
- search_query Tauri command → hybrid FTS5 + vector results with RRF ranking
- Full pipeline validated: file → extract → chunk → embed → store → search
- Frontend calls via typed invoke() wrappers

Exit Criteria

bun run build compiles frontend with zero errors (181KB JS bundle)
cargo test passes all 215 tests
cargo check compiles with zero errors, zero warnings
Insert 100 real documents from your machine (manual validation pending)
RAM usage idle <50MB (benchmarking pending)

Phase 1 — “The Search Bar” (Weeks 4-10)

Goal: Launch FREE on Product Hunt, HN, Reddit. Target: 500-1000 real installations.

Technical Deliverables

Exit Criteria

Installers generated for Windows, macOS, Linux (~11MB)
500+ real installations within 60 days of launch
Search feels instant for keyword queries
Users return after day 7 (>30% retention)

Phase 1.5 — “Protocol Bridge” (Weeks 8-12)

Goal: Make Ghost a Universal Protocol Hub — both an MCP host AND client, with AG-UI runtime for interactive agent experiences. This is the competitive differentiator that no other desktop app offers.

Added after market research + protocol landscape analysis (Feb 2026). MCP ecosystem: 10,000+ servers. AG-UI: 12K+ GitHub stars, Rust SDK available. A2UI: Google-backed generative UI spec. A2A: 50+ launch partners, Linux Foundation. Being the first local desktop app to speak ALL agent protocols is a once-in-a-generation opportunity.

Technical Deliverables

MCP Server (Ghost as a tool for external AI clients)

MCP Server via rmcp crate (official Rust SDK, v0.16)
- HTTP Streamable transport via axum on localhost (configurable port 6774)
- MCP protocol v2024-11-05 compliance (latest rmcp)
- Tool: ghost_search — hybrid search across indexed files
- Tool: ghost_index_status — report indexing stats + watched dirs
- Tool: ghost_recent_files — list recently indexed files
- #[tool] / #[tool_handler] / #[tool_router] macros for clean definitions
- ServerHandler impl with GhostMcpServer struct
- Auto-starts on app launch when enabled
- Resource: expose indexed documents metadata
- Integration tested with Claude Desktop and Cursor

MCP Client (Ghost connects to external MCP servers)

MCP Client Host via rmcp
- Configuration: mcp_servers array in settings.json
- Transport support: stdio (TokioChildProcess) + HTTP Streamable (StreamableHttpClientTransport)
- Tool discovery: fetch and cache tool schemas from connected servers
- Tool invocation: call_tool() with JSON arguments
- Dynamic tool loading: add/remove servers without restart (8 Tauri commands)
- Auto-connect to enabled servers on app startup
- Settings UI: MCP tab with server management (add, connect, disconnect, remove)
- Free tier: 3 MCP server connections; Pro: unlimited

MCP Catalog (App Store for MCP tools)

Built-in curated catalog (30+ MCP servers, no network required to browse)
- Categories: Developer, Productivity, Data, AI/ML, Web, Communication, System
- Each entry: id, name, description, runtime, command, args, required env vars, tags, popularity
- Runtime detection: npx, node, uv, uvx, python3 (auto-detect availability + versions)
- One-click install: resolves config → saves to settings → auto-connects
- Uninstall: disconnect + remove from settings
- Official/MCP App badges for trusted and interactive servers
- Frontend: searchable/filterable McpAppStore.tsx with category sidebar, env var forms
- Tauri commands: get_mcp_catalog, detect_runtimes, install_mcp_from_catalog, uninstall_mcp_server
- Community catalog contributions via PR
- Official MCP Registry integration (6,000+ servers at registry.modelcontextprotocol.io)
  - Background sync: paginated fetch of all servers, cached locally as JSON
  - Local search: multi-word query matching against name, title, description
  - Auto-conversion: server.json → CatalogEntry (npm→npx, pypi→uvx, oci→docker, remotes→http)
  - Deduplication against curated catalog to avoid double entries
  - Registry UI: expandable section in MCP App Store with dedicated search, sync status
  - install_mcp_entry command: accepts full CatalogEntry directly for registry servers
  - Tauri commands: sync_mcp_registry, search_mcp_registry, get_registry_status
  - Privacy-first: opt-in sync — only fetches when user explicitly browses the registry
  - Cache TTL: 24 hours, stale cache still usable, refresh button available

Runtime Bootstrap (Zero-Config Prerequisites)

RuntimeBootstrapper system (protocols/runtime_bootstrap.rs)
- Ghost-managed runtimes directory: <app_data>/runtimes/ — no system PATH pollution
- Auto-detect Node.js, uv/Python, Docker (system AND Ghost-managed)
- Download Node.js LTS from nodejs.org prebuilt binaries (tar.xz/zip per platform)
- Download uv from GitHub releases (static binary, all platforms)
- uv auto-installs Python via uv python install after install
- Archive extraction (tar.gz, tar.xz, zip) with nested directory flattening
- PATH injection: build_env_path() prepends managed runtimes when spawning MCP servers
- Binary resolution: resolve_binary() checks managed then system
- 13 unit tests + 3 integration tests (network-dependent)
MCP server launch integration
- connect_stdio in MCP client auto-injects managed runtimes into PATH
- Resolved command lookup via RuntimeBootstrapper before spawning child process
- Startup auto-provision logs missing runtimes with actionable message
Tauri commands (5 new)
- get_runtime_bootstrap_status — all runtimes status
- install_runtime — install a specific runtime with progress events
- bootstrap_all_runtimes — install all missing runtimes
- recommend_mcp_tools — AI-powered tool discovery via fuzzy matching
- check_tool_requirements — prereqs check before install
Frontend integration (McpAppStore.tsx)
- Interactive Runtime Bootstrap panel with per-runtime install buttons
- “Install All Missing” one-click button
- Progress bar with stage + percentage from runtime-install-progress events
- AI Tool Discovery search bar with fuzzy matching recommendations
- Runtime status pills: installed (green) / installable / manual-only
Future enhancements
- Agent-powered tool discovery: LLM recommends tools from natural language
- Automatic runtime bootstrap on first launch (opt-in)
- Runtime version management (node 20 vs 22, Python 3.11 vs 3.12)
- Cross-platform CI testing for all download URLs

AG-UI Runtime (Agent ↔ User Interaction Protocol)

AG-UI event system in Rust backend
- Implement 30+ AG-UI event types (TEXT_MESSAGE_CONTENT, TOOL_CALL_START, TEXT_MESSAGE_CHUNK, TOOL_CALL_RESULT, REASONING_, ACTIVITY_, MESSAGES_SNAPSHOT, etc.)
- Event bus (broadcast channel) for fan-out to multiple consumers
- SSE endpoint on /agui for external clients alongside MCP /mcp endpoint
- AgentRunner orchestrates chat lifecycle as AG-UI event stream
- Tool call event emission (TOOL_CALL_START/ARGS/END/RESULT) infrastructure ready
AG-UI React client
- useAgui hook: listens to Tauri agui://event events, manages run state
- Handles 30+ event types: streaming text, tool calls, reasoning, activities, messages snapshot
- reasoningContent accumulator for extended thinking models (Reasoning_* events)
- activities Map for citation/annotation events (ActivitySnapshot/ActivityDelta)
- chat_send_streaming Tauri command for event-driven chat
- Fallback to non-streaming chat_send when model not natively available
AG-UI advanced features
- Agent executor emits full AG-UI event lifecycle for ReAct loop
- Tool call events: TOOL_CALL_START → ARGS → END with timing
- Custom events: tool_approval_required, generation_stats, agent_error
- State synchronization between Rust agent and React UI via event bus
AG-UI remaining features
- Bidirectional streaming: user actions → agent (human-in-the-loop)
- Approval UI: frontend confirm/deny for dangerous tool calls
- True token-by-token streaming from Ollama (replace word-chunking)

A2UI Renderer (Generative UI)

A2UI JSON → React component renderer (types + renderer complete, not yet wired to agent output)
- Rust module protocols/a2ui.rs with full A2UI v0.9 types, serialization, component builders
- 8 unit tests for serialization, round-trip, component builders, child lists
- React A2UIRenderer.tsx maps A2UI JSON → native Tailwind components
- Standard catalog: Text (6 variants), Image, Icon, Video, Row, Column, Card, List, Tabs (active tab switching), Modal, Divider, Button (4 variants), TextField, CheckBox, ChoicePicker, Slider, DateTimeInput
- Data binding: JSON Pointer resolution, two-way binding for inputs
- Adjacency list → tree resolution with automatic root detection
- A2UI messages transported via AG-UI CUSTOM events over Tauri IPC
- useAgui hook processes A2UI createSurface/updateComponents/updateDataModel/deleteSurface
- Theme integration with Ghost’s CSS custom properties
- +9.8 KB JS bundle cost (245.8 KB total, well within 500 KB budget)
- Agent executor emits A2UI surfaces for rich tool results (wiring pending)
MCP Apps support
- Sandboxed iframe renderer for MCP App HTML content
- Communication bridge: MCP App ↔ Ghost host via postMessage
- Security: CSP headers, no external network access from sandbox

Skills System

Skills.md format support (implemented in agent/skills.rs, not protocols/)
- Define agent capabilities in markdown files (OpenClaw-compatible)
- SKILL.md parser: YAML frontmatter (name, description, triggers, tools, enabled) + Markdown instructions body
- Skill discovery: scan ~/.ghost/skills/ directory (configurable)
- SkillRegistry: load, match by query triggers, build system prompts with matched skills
- Skill loading: register tools from skill definitions (SkillTool → OllamaTool conversion)
- Three-tier loading: metadata (~100 tokens) → instructions (<5000 tokens) → resources
- list_skills Tauri command for frontend
- Community skills: shareable via Git repos
- 6 unit tests passing

Exit Criteria

Claude Desktop can search local files through Ghost MCP server
Ghost chat can invoke tools from at least 2 external MCP servers
AG-UI event stream renders streaming text + tool progress in React
A2UI renders 17+ component types with full interactivity (types + renderer — agent wiring pending)
<100ms overhead added by MCP protocol layer
Setup guide published for MCP server + client configuration

Phase 1.7 — “Multiplatform” (Weeks 12-16)

Goal: Adapt Ghost for Android and iOS via Tauri v2 mobile targets, making it the first local-first AI assistant on every platform.

Market insight: AI assistant market $16.29B (2024) → $73.8B (2033), 18.8% CAGR. Mobile is 60%+ of compute time. Ghost is the only local-first, open-source, multiplatform AI assistant. TV platforms rejected as not viable (closed ecosystems, no file system access).

Technical Deliverables

Backend (Rust) Adaptation

Conditional compilation with #[cfg(desktop)] / #[cfg(mobile)]
- Use Tauri’s built-in platform macros (set by target triple, not Cargo features)
- Target-specific deps: notify, notify-debouncer-mini, tauri-plugin-global-shortcut, tray-icon → desktop only
- [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies] in Cargo.toml
Platform-gated features
- File watcher (indexer::watcher): desktop only; mobile no background file monitoring
- System tray + global shortcuts: desktop only
- Window toggle (toggle_window): desktop only
- MCP stdio transport: desktop only; mobile falls back to HTTP transport with clear error
- start_watcher(): desktop version starts notify; mobile stub returns Ok(())
Mobile hardware detection (embeddings/hardware.rs)
- iOS: Metal GPU backend, conservative 6GB RAM estimate (no std::process::Command)
- Android: Vulkan GPU backend, /proc/meminfo RAM detection (Linux-based)
Platform info command (get_platform_info)
- Returns: platform, is_desktop, is_mobile, has_file_watcher, has_system_tray, has_global_shortcuts, has_stdio_mcp
- Frontend uses this to adapt UI dynamically

Capabilities Split

Tauri capabilities separated by platform
- default.json: core permissions only (all platforms)
- desktop.json: global-shortcut permissions (linux, macOS, windows)
- mobile.json: core permissions (iOS, android)

Frontend Responsive Adaptation

usePlatform() hook — detects platform via Tauri command, fallback to navigator.userAgent
- Computed properties: isMobile, isDesktop, isIos, isAndroid, isMacos, modKey, activationShortcut
App.tsx multiplatform
- Auto-hide on blur: desktop only (mobile apps don’t hide)
- Drag region: desktop only (no title bar drag on mobile)
- h-dvh instead of h-screen for mobile browser chrome
- Window hide after file open: desktop only (spotlight-style)
- Escape key: doesn’t hide window on mobile
- Responsive border/shadow: md:rounded-2xl md:border md:shadow-2xl
GhostInput.tsx mobile
- isMobile prop: larger touch targets (48px buttons), larger icons
- Font size: text-base on mobile vs text-[15px] desktop
- Keyboard hints (kbd elements): hidden on mobile
- Clear button: larger tap area on mobile
StatusBar.tsx compact mode
- compact prop: fewer details on mobile (hide DB stats, vector status)
- Larger settings button touch target on mobile
- Safe area bottom padding (pb-safe)
Settings.tsx mobile
- Full-screen modal on mobile (no rounded corners, full viewport)
- Horizontally scrollable tabs on small screens
- Directories tab hidden on mobile (no file watcher)
- Larger close button touch target
- Safe area top padding
Onboarding.tsx mobile
- Conditional drag region (desktop only)
- Safe area padding, adapted content padding
- h-dvh viewport height
Responsive CSS (globals.css)
- Mobile safe area insets: pt-safe, pb-safe, pl-safe, pr-safe
- h-dvh utility (100dvh for mobile browser chrome)
- scrollbar-none utility for hidden scrollbars
- Touch-friendly overrides @media (pointer: coarse): min 44px touch targets
- Momentum scrolling for touch devices

Mobile Project Scaffold

Android setup: tauri android init, Gradle config, minimum SDK 24+
- Full Gradle project scaffolded with npx tauri android init
- 4 Android Rust targets installed: aarch64, armv7, i686, x86_64
- OpenSSL eliminated — entire dep tree uses rustls (cross-compilation safe)
- llama-cpp-2 gated to desktop-only (avoids C++ cross-compilation on mobile)
- std::ffi::c_char / c_int for sqlite-vec FFI (Android C char is unsigned)
- Window management APIs (hide, show, start_dragging) gated with #[cfg(desktop)]
- ChatEngine.native field and chat::native module gated desktop-only
- APK: 39MB (unsigned, aarch64), AAB: 16MB — zero Rust warnings
iOS setup: tauri ios init, Xcode project, minimum iOS 15+
- Requires macOS — tauri ios subcommand only available on macOS
- Backend Rust code already adapted (conditional compilation ready)
- Frontend already responsive with iOS safe areas
Mobile CI/CD: GitHub Actions for Android APK + iOS IPA builds
- Android job: Java 17 + SDK 34 + NDK 27 + Gradle cache + APK signing (if keystore configured) + upload to release
- iOS job: conditional on IOS_BUILD_ENABLED repo var + Apple Developer certificates
- RPM bundle added to Linux builds
- All jobs have timeouts, workflow_dispatch trigger added
App Store assets: screenshots, descriptions, privacy policies
Mobile-specific features: share sheet integration, notification support

Dead Code Removal

Removed ChatPanel.tsx — superseded by unified Omnibox (GhostInput)
Removed SearchBar.tsx — superseded by unified Omnibox (GhostInput)

Component Adaptation (All Components)

ChatMessages.tsx — isMobile prop, platform-aware tips (no keyboard shortcuts on mobile), useMemo for tips
ResultsList.tsx — isMobile prop, conditional kbd elements, mobile-friendly empty state text
ResultItem.tsx — isMobile prop, single-tap opens on mobile (vs double-click desktop), 44px+ touch targets, active: state
DownloadProgress.tsx — reviewed, already responsive (no changes needed)

Exit Criteria

bun run build compiles frontend with zero errors (245.96 KB JS)
cargo check + cargo test (248 tests) + cargo clippy -- -D warnings all pass clean
All responsive adaptations compile and render correctly on desktop
tauri android build --target aarch64 produces a working APK (39MB) + AAB (16MB)
tauri ios build produces a working IPA (requires macOS)
Mobile app tested on device/emulator and shows Onboarding on first launch

Phase 2 — “The Agent OS” (Weeks 13-22)

Goal: Transform Ghost from a search tool into a true local Agent OS. Users interact with their computer through natural language. Growing paid user base.

Technical Deliverables

A2A Protocol (Agent-to-Agent Communication)

Ghost Agent Card (types + endpoint live, task execution stubbed for Phase 2)
- Published /.well-known/agent.json (RFC 8615) at localhost MCP server port
- protocols/a2a.rs: full A2A v0.3.0 type system (AgentCard, Task, JSON-RPC 2.0, 5 tests)
- Advertises Ghost’s capabilities (file-search, file-read, shell-command, mcp-tools skills)
- A2A JSON-RPC endpoint at /a2a — dispatch_request() returns “Phase 2 planned” errors
- Wire A2A dispatcher to agent executor for real task execution
- OAuth 2.0 / API key authentication
A2A Client
- Discover and connect to other A2A-compatible agents (OpenClaw, NanoClaw instances)
- Task delegation: send tasks to specialized remote agents
- SSE streaming for long-running delegated tasks
- Task lifecycle: submitted → working → input-required → completed
A2A Server
- Accept tasks from external agents via JSON-RPC 2.0
- Expose Ghost tools as A2A skills
- Multi-agent orchestration: break complex requests into sub-tasks

Agent Engine (Tool Calling)

ReAct Agent with hardware-adaptive model selection
- agent/ module: config, executor, tools, safety, memory, skills (7 files, ~2800 lines)
- Qwen2.5-Instruct family via native llama-cpp-2 (0.5B→7B, Apache 2.0, ChatML format, GGUF)
- Hardware-adaptive auto-selection: detect RAM → pick largest fitting model → dynamic context window
- 4 model tiers: 0.5B (1GB), 1.5B (2GB), 3B (4GB), 7B (8GB) — same models as chat engine (no double download)
- Q4_K_M quantization, runtime GPU auto-detection (Vulkan/CUDA/Metal)
- All config auto-detected but user-overridable via Settings
Fully native ReAct (Reason + Act) execution loop — ZERO external dependencies
- llama.cpp apply_chat_template_with_tools_oaicompat() with GBNF grammar-constrained generation
- Model’s built-in Hermes 2 Pro tool-calling format + grammar ensures valid JSON tool calls
- parse_response_oaicompat() for native tool call parsing (no regex, no prompt injection)
- Lazy grammar sampling: grammar activates only when tool-call trigger tokens appear
- Iterative loop: LLM reasons → calls tools → gets results → reasons again (max 10 iterations)
- 6 built-in tools: ghost_search, ghost_read_file, ghost_list_directory, ghost_index_status, ghost_write_file, ghost_run_command
- MCP external tools auto-collected from connected servers
- AG-UI event streaming: RUN_STARTED → TOOL_CALL_START/ARGS/END → TEXT_MESSAGE_CONTENT → RUN_FINISHED
- System prompt with index stats, matched skills, and tool schemas
3-tier safety classification
- RiskLevel: Safe (read-only, auto-approved), Moderate (sensitive paths, logged), Dangerous (write/exec, requires approval)
- Pattern matching on tool names, arguments, file paths, and shell commands
- Pipe-based installer detection (curl | sh, wget | bash)
- External MCP tools classified as Moderate by default
- Human-in-the-loop: approval events emitted via AG-UI CUSTOM for dangerous actions
- 8 unit tests passing
Conversation memory (SQLite)
- conversations + messages tables with FTS5 search
- Full CRUD: create, list, get messages, delete, update title
- FTS5 search across all conversation history
- Recent context retrieval for conversation continuity
- 11 Tauri commands for frontend integration
- 6 unit tests passing
LLM-driven tool selection (advanced)
- Multi-step planning: chain multiple tool calls for complex tasks
- Approval UI in frontend (confirm/deny tool execution)

OS Integration Layer

Browser history indexing
- Read Chrome/Edge/Firefox SQLite history DBs (Windows/macOS/Linux)
- Index page titles, URLs, timestamps
- Respect private/incognito mode flags
App activity via UI Automation
- Windows: uiautomation Rust crate for reading control trees
- macOS: accessibility crate for AXUIElement tree walking
- Linux: AT-SPI2 D-Bus interface for accessibility tree
- Capture: active window title, focused control text, app name
- Activity timeline: “What was I doing at 3pm yesterday?”
- <1% CPU overhead, sample every 5 seconds
Clipboard history
- Monitor clipboard changes cross-platform
- Store text clips with timestamp and source app
- Semantic search across clipboard history
- Privacy: configurable exclusion rules (password managers, banking apps)
Agent actions (OS control)
- Open/focus applications
- Create/move/rename/delete files
- Copy text to clipboard
- Send keyboard shortcuts to active window
- Search and open URLs in default browser
Action Preview (safety layer)
- Before executing, Ghost shows a plan via A2UI components
- Step-by-step action visualization with confirm/cancel
- Undo support for reversible actions (file ops)
- Audit log of all executed actions (local SQLite table)

Micro-Agents (PicoClaw-inspired)

Background task agents
- Spawn lightweight background tasks that monitor conditions
- Example: “Watch this folder and organize new PDFs by date”
- Example: “Alert me when file X changes”
- Cron-like scheduling for recurring tasks
- Status dashboard showing active micro-agents

Activity Timeline UI

Chronological view of all indexed activity
Filter by: date range, app, content type
Natural language queries: “show me what I worked on last Tuesday”
A2UI-rendered rich cards for different activity types

Premium Features (Ghost Pro)

Vault encryption with ChaCha20-Poly1305 (age crate)
Encrypted sync between devices (optional, user-controlled)
Unlimited MCP server connections
WebMCP browser agent (Phase 2.5)
A2A multi-agent orchestration
Advanced models (Qwen2.5-7B+, or custom model support)
OS automation: unlimited actions/day (free: 5/day)
Micro-agents (free: 1 active, Pro: unlimited)

Licensing System

License key validation (offline-capable, cryptographic)
Feature gating via PlatformExtensions trait (extensions.rs)
Free tier: core search + chat + 3 MCP servers + 5 actions/day
Pro tier: everything unlimited + premium features

Exit Criteria

Agent can reliably execute 5+ action types on the OS
Action Preview shows correct plan >95% of the time
A2A discovery works with at least 1 external agent
Paying users onboarded
Encryption passes basic security review
Mac + Linux automation working alongside Windows

Phase 2.5 — “Web Agent” (Weeks 23-26)

Goal: Extend Ghost’s reach to the web via WebMCP, enabling structured interactions with websites.

Technical Deliverables

WebMCP Consumer
- Parse WebMCP tool contracts from website navigator.modelContext declarations
- Bridge: Ghost sends structured tool calls to browser extension
- Ghost browser extension (Chrome/Firefox) that reads WebMCP tool contracts
- Invoke website tools on behalf of the user (booking, forms, data entry)
Browser Extension
- Lightweight extension exposing current page’s WebMCP tools to Ghost
- Communication via native messaging (Chrome Native Messaging API)
- Page context: current URL, page title, selected text → Ghost search context
- Ghost can request the extension to perform WebMCP tool calls

Exit Criteria

Ghost can read WebMCP tools from at least 3 websites
Browser extension communicates bidirectionally with Ghost desktop
User can ask “Book me a flight to Madrid” and Ghost interacts with a travel site

Phase 3 — “The Platform” (Months 7-12)

Goal: Partnerships, marketplace, and platform expansion. Explore B2B/teams model.

Technical Deliverables

Skills Marketplace
- Community-created skills with install/uninstall from Ghost UI
- Skills categories: productivity, development, data, creative, automation
- Revenue share: 70% creator / 30% Ghost (Pro feature to sell skills)
- NPM package: @ghost/skills-sdk for JavaScript skill development
- Rust crate: ghost-skills for native Rust skill development
- Example skills: GitHub integration, Notion sync, Slack search, calendar
Third-party integrations
- Obsidian vault indexing (direct SQLite reading)
- VS Code extension (Ghost as search backend, sidebar panel)
- Slack message search via MCP server
- Browser extension v2: page content indexing, reader mode
Multi-agent orchestration
- A2A agent team composition: assign specialized agents to sub-tasks
- Agent routing: analyze request → pick best agent(s) → coordinate results
- Visual agent workflow builder (A2UI-rendered)
B2B/Teams features (Ghost Pro Teams)
- Shared team vaults with role-based access control
- Admin dashboard: manage team licenses, usage analytics
- Compliance: audit trail, data retention policies, export controls
- SSO integration (SAML 2.0 / OIDC)
- Team-shared MCP server configurations
- Centralized skill management for team deployments
Platform stability
- Mac port fully tested (WebKit, Accessibility API)
- Linux Wayland support verified
- Performance profiling: cold start, search latency, memory footprint
- Crash recovery: auto-save state, graceful degradation

Exit Criteria

10+ community skills published in marketplace
Mac version stable with full feature parity
At least one B2B pilot customer
A2A working with 3+ external agent platforms
$50K+ ARR from Pro + Teams subscriptions

Key Technical References

Resource	URL	Notes
Tauri v2	tauri.app	v2.10.2 stable. Plugins: global-shortcut, fs, shell
sqlite-vec	github.com/asg017/sqlite-vec	SIMD-accelerated KNN. Works with FTS5
rmcp	crates.io/crates/rmcp	Official Rust MCP SDK v0.15+. Client + Server. `#[tool]` macro
AG-UI	github.com/CopilotKit/ag-ui	Agent↔User protocol. 12K+ stars. Rust SDK available
A2UI	github.com/google/A2UI	Google-backed declarative generative UI. JSON → native components
A2A	google.github.io/A2A	Agent-to-Agent protocol. Agent Cards + JSON-RPC 2.0 + SSE. Linux Foundation
WebMCP	developer.chrome.com/blog/webmcp-epp	W3C proposal. `navigator.modelContext` browser API
MCP Apps	blog.modelcontextprotocol.io/posts/2026-01-26-mcp-apps	Tools return interactive UI (iframes). Anthropic spec
MCP Spec	modelcontextprotocol.io	v2025-11-25 spec. Linux Foundation / AAIF
OpenClaw	github.com/nicepkg/OpenClaw	Model-agnostic agent infra. Skills.md format. 100K+ stars
Ollama	ollama.com	Optional fallback LLM runtime. Ghost runs natively without it
nomic-embed-text	ollama.com/library/nomic-embed-text	768 dims, surpasses ada-002, ~274MB
uiautomation	crates.io/crates/uiautomation	Windows UI Automation wrapper for Rust
notify	crates.io/crates/notify	Cross-platform filesystem watcher
candle	github.com/huggingface/candle	Rust ML framework, BERT/LLM inference
all-MiniLM-L6-v2	huggingface.co/sentence-transformers/all-MiniLM-L6-v2	384 dims, 23MB, excellent quality
hf-hub	crates.io/crates/hf-hub	HuggingFace model download/cache

Protocol Stack Architecture

┌─────────────────────────────────────────────────────────────────┐
│  USER (natural language via Ghost Omnibox)                       │
└────────────────────┬────────────────────────────────────────────┘
                     │
┌────────────────────▼────────────────────────────────────────────┐
│  AG-UI Runtime (Agent ↔ User Interaction Layer)                 │
│  ├── ~16 event types: text, tool calls, state, lifecycle        │
│  ├── Bidirectional streaming (Rust ↔ React)                     │
│  └── Human-in-the-loop approval gates                           │
├─────────────────────────────────────────────────────────────────┤
│  A2UI / MCP Apps (Generative UI Layer)                          │
│  ├── A2UI: JSON → native React components (safe, sandboxed)     │
│  └── MCP Apps: iframe-based interactive tool UIs                │
├─────────────────────────────────────────────────────────────────┤
│  MCP Host (Tool Layer — rmcp crate)                             │
│  ├── MCP Server: Ghost tools exposed to Claude/Cursor/etc.      │
│  ├── MCP Client: connects to 10,000+ external MCP servers       │
│  └── Tool calling: LLM selects + invokes tools from schemas     │
├─────────────────────────────────────────────────────────────────┤
│  A2A (Agent Coordination Layer)                                 │
│  ├── Agent Card at /.well-known/agent.json                      │
│  ├── Task delegation to specialized agents                      │
│  └── SSE streaming for long-running multi-agent tasks           │
├─────────────────────────────────────────────────────────────────┤
│  WebMCP (Web Agent Layer — Phase 2.5)                           │
│  ├── Read tool contracts from websites                          │
│  └── Browser extension bridge for structured web interactions   │
├─────────────────────────────────────────────────────────────────┤
│  OS Integration Layer                                           │
│  ├── Filesystem: index, watch, CRUD (already implemented)       │
│  ├── UI Automation: Windows + macOS + Linux accessibility       │
│  ├── Clipboard history, browser history                         │
│  └── App activity monitoring, micro-agents                      │
└─────────────────────────────────────────────────────────────────┘

Business Model

Open Core (Grafana pattern — extensions trait)

Feature	Free	Pro ($8/mo)	Teams ($15/user/mo)
Local search (FTS5+vector)	✅	✅	✅
Chat AI (Candle native)	✅	✅	✅
MCP Server (Ghost as tool)	✅	✅	✅
MCP Client (3 servers)	✅	—	—
MCP Client (unlimited)	—	✅	✅
A2UI Generative UI	Basic	Full	Full
A2A Multi-agent	—	✅	✅
WebMCP Browser Agent	—	✅	✅
Skills Marketplace	Free only	Free + Premium	Free + Premium
OS Automation (actions/day)	5	Unlimited	Unlimited
Micro-agents	1 active	Unlimited	Unlimited
Vault encryption	—	✅	✅
Cross-device sync	—	✅	✅
Team vaults + SSO	—	—	✅
Audit trail + compliance	—	—	✅
Advanced models (7B+)	—	✅	✅