Hive Documentation

Complete reference for Hive — the native Rust desktop AI platform.

The Three Pillars

Multi-Agent System

Hive does not use a single AI agent. It uses a hierarchical swarm modeled on a beehive:

                    +-------------+
                    |    QUEEN    |   Meta-coordinator
                    |  (Planning) |   Goal decomposition
                    +------+------+   Budget enforcement
                           |          Cross-team synthesis
              +------------+------------+
              |            |            |
        +-----v----+ +----v-----+ +----v-----+
        |  TEAM 1  | |  TEAM 2  | |  TEAM 3  |
        | HiveMind | |Coordinator| |SingleShot|
        +----+-----+ +----+-----+ +----------+
             |             |
       +-----+-----+  +---+---+
       |     |     |  |       |
      Arch  Code  Rev Inv    Impl

Every team gets its own git worktree (swarm/{run_id}/{team_id}) for conflict-free parallel execution, merging back on completion.

AI Providers

11 providers with automatic complexity-based routing and fallback:

Features: complexity classification, 14-entry fallback chain, per-model cost tracking, streaming support, budget enforcement.

Autonomous Skill Acquisition

Hive doesn't just execute what it already knows — it recognizes what it doesn't know and teaches itself. This is the closed-loop system that lets Hive grow its own capabilities in real time:

User request
    |
    v
Competence Detection ─── "I know this" ───> Normal execution
    |
    "I don't know this"
    |
    v
Search Skills / Sources ─── Found sufficient skill? ───> Install & use
    |
    Not found (or insufficient)
    |
    v
Knowledge Acquisition ───> Fetch docs, parse, synthesize
    |
    v
Skill Authoring Pipeline ───> Generate, security-scan, test, install
    |
    v
New skill available for future requests

Personal Assistant

The assistant uses the same AI infrastructure as the development platform — same model routing, same security scanning, same learning loop.

Security & Privacy

Security is the foundation, not a feature bolted on. Every outgoing message is scanned. Every command is validated.

HiveShield — 4 Layers of Protection

Self-Improvement Engine

Hive gets smarter every time you use it. Entirely local. No data leaves your machine.

All learning data stored locally in SQLite (~/.hive/learning.db). Every preference is transparent, reviewable, and deletable.

Automation & Skills

Terminal & Execution

P2P Federation

Hive instances can discover and communicate with each other over the network, enabling distributed swarm execution and shared learning.

Integrations

All integrations make real API calls — no stubs or simulated backends.

Blockchain / Web3

Persistence & Data Storage

All state persists between sessions. Nothing is lost on restart.

On startup, Hive automatically backfills JSON-only conversations into SQLite and builds FTS5 search indexes. Path traversal protection on all file operations. SQLite databases use WAL mode with NORMAL synchronous and foreign key enforcement.

Architecture — 16-Crate Workspace

hive/crates/
├── hive_app           Binary entry point — window, tray, build.rs
├── hive_ui            Workspace shell, chat service, learning bridge
├── hive_ui_core       Theme, actions, globals, sidebar, welcome screen
├── hive_ui_panels     All panel implementations (20+ panels)
├── hive_core          Config, SecurityGateway, persistence, Kanban, channels
├── hive_ai            11 AI providers, model router, complexity classifier, RAG
├── hive_agents        Queen, HiveMind, Coordinator, collective memory, MCP, skills
├── hive_shield        PII detection, secrets scanning, vulnerability assessment
├── hive_learn         Outcome tracking, routing learner, preference model
├── hive_assistant     Email, calendar, reminders, approval workflows
├── hive_fs            File operations, git integration, file watchers, search
├── hive_terminal      Command execution, Docker sandbox, browser automation
├── hive_docs          Document generation — CSV, DOCX, XLSX, HTML, MD, PDF, PPTX
├── hive_blockchain    EVM + Solana wallets, RPC config, token deployment
├── hive_integrations  Google, Microsoft, GitHub, messaging, OAuth2, smart home
└── hive_network       P2P federation, WebSocket transport, UDP discovery

Dependency Flow

hive_app
  └── hive_ui
        ├── hive_ui_core
        ├── hive_ui_panels
        ├── hive_ai ──────── hive_core
        ├── hive_agents ──── hive_ai, hive_learn, hive_core
        ├── hive_shield
        ├── hive_learn ───── hive_core
        ├── hive_assistant ─ hive_core, hive_ai
        ├── hive_fs
        ├── hive_terminal
        ├── hive_docs
        ├── hive_blockchain
        ├── hive_integrations
        └── hive_network

UI — 20+ Panels

All panels are wired to live backend data. No mock data in the production path.

Installation

Option 1: Download Pre-Built Binary (Recommended)

Grab the latest release for your platform from GitHub Releases.

# Ubuntu/Debian
sudo apt install mesa-vulkan-drivers vulkan-tools

# Fedora
sudo dnf install mesa-vulkan-drivers vulkan-tools

# Arch
sudo pacman -S vulkan-icd-loader vulkan-tools

Option 2: Build from Source

Requires Rust toolchain and platform-specific build dependencies (see README for full details).

git clone https://github.com/PatSul/Hive.git
cd Hive/hive
cargo build --release
cargo run --release

Run Tests

cd hive
cargo test --workspace

Configuration

On first launch, Hive creates ~/.hive/config.json. Add your API keys to enable cloud providers:

{
  "anthropic_api_key": "sk-ant-...",
  "openai_api_key": "sk-...",
  "google_api_key": "AIza...",
  "ollama_url": "http://localhost:11434",
  "lmstudio_url": "http://localhost:1234"
}

All keys are stored locally and never transmitted except to their respective providers. HiveShield scans every outbound request before it leaves your machine. Configure provider preferences, model routing rules, budget limits, and security policies through the Settings panel in the UI.