Coming from OpenClaws? TinyHive can import and repair broken OpenClaws configurations. Our migration tool automatically fixes common issues like orphaned agents, corrupted state, and missing credentials. See migration guide →

Overview

TinyHive is a multi-agent AI operating system that runs locally on your hardware. Unlike cloud-only AI assistants, TinyHive gives you:

• 266 specialized agents organized into domains (life management, engineering, consultants)
• 90+ integrations — Slack, GitHub, Stripe, Salesforce, AWS, and more
• Built-in governance — capability-based permissions with tamper-evident audit trails
• Multi-provider AI — Anthropic Claude, OpenAI GPT, Google Gemini, Grok, local Ollama
• Knowledge that compounds — per-agent RAG plus shared collective memory
• IPFS backup — recover your entire hive from a 12-word seed phrase

Installation

npm (Recommended)

npm install -g @tinyhive/v0
tinyhive

Docker

docker run -p 8742:8742 ghcr.io/alphadataomega/tinyhive:latest

Then open http://localhost:8742

Windows Installer

Download TinyHive-Setup-*.exe from Releases.

Features

Root Terminal

Full shell access with the ROOT ACCESS terminal for power users:

Capabilities:

• Direct command-line access to the hive
• 89+ CLI commands (tyhi inbox, tyhi lease, tyhi rag, etc.)
• Agent workspace navigation
• System administration

Multi-Theme Interface

TinyHive adapts to your aesthetic with 5 built-in themes:

| Theme | Description | |-------|-------------| | V | Power user dark (default) | | Sterling | Matrix terminal with neon green | | Arielle | Rose gold glass, warm light theme | | Elijah | Minimal light with blue accents | | Scarlett | Dark with gold accents |

Agent Hierarchy

Choose from 266 specialized agents organized into domains:

| Domain | Purpose | Example Agents | |--------|---------|----------------| | MIND | Orchestration & life management | diet, investing, mental_health, accounting | | BODY | External actions via controllers | ssh, playwright, push, 90+ integrations | | SPINE | Governance & compliance | permissions, watchdog, auditor, healer | | CONSULTANTS | Domain specialists | security analysts, compliance officers, ML engineers | | ENGINEERING | Technical implementation | frontend, backend, DevOps, AI/ML | | STUDIO | Creative & design | UX, content, video, animations |

Agent Inspector

Monitor any agent's health, token usage, and configuration:

What you see:

• Status — AWAKE, session duration, start time
• Memory — RSS usage with percentage meter
• Context Window — Token utilization (e.g., 5.7K / 131K)
• Token Spend — Cost tracking for current session
• AI Provider — Switch between Anthropic, OpenAI, Grok, Ollama
• Children — Child agents with inbox depth indicators

Editable Identity Files: Click any agent's IDENTITY.md to view rendered markdown. Edit inline and save changes with automatic backups.

Agent Personality System

MIND agents and domain parents have distinct personalities that shape their communication style:

| Agent | Personality | Voice Traits | |-------|-------------|--------------| | MIND | Supportive Guide | Warm, direct, encouraging | | Engineering | The Architect | Technical precision, systematic | | Studio | The Creative Director | Visual language, iterative | | Consultants | The Strategist | Executive-focused, decisive | | SPINE | The Guardian | Measured, principled | | BODY | The Operator | Action-oriented, efficient |

Personalities are injected during agent scaffolding from config/personalities.json.

System Overview

Real-time dashboard showing hive health:

Metrics displayed:

• Agents awake (1 of 266)
• CPU, Memory, Disk usage
• Uptime (2d 22h)
• Cloud instance details (pod, namespace, tier)
• Recent activity timeline

Portals

Monitor agent-hosted services and capture screenshots:

Features:

• Live service status (online/offline with latency)
• Screenshot capture on demand
• Process metrics (memory, PID)
• Add new portals for any local port

Integrations Marketplace

90+ controllers for external services:

Categories:

• Communication — Slack, Discord, Teams, Telegram
• Project Management — Jira, Asana, Linear, Trello
• Cloud Platforms — AWS, GCP, Cloudflare, Vercel
• CRM & Sales — Salesforce, HubSpot, Pipedrive
• Databases — PostgreSQL, MongoDB, Redis
• AI/ML — Anthropic, OpenAI, Replicate

Note: 3 controllers fully implemented (hub, ssh, playwright). Others show "Coming Soon".

API Keys Management

Configure credentials for AI providers and services:

Supported providers:

• AI Providers — Anthropic, OpenAI, Grok (xAI)
• Services — Brave Search, GitHub, Cloudflare
• Databases — Supabase

OpenRouter Integration

Access 50+ AI models with pay-per-token pricing:

Available models:

• openai/gpt-4o ($2.50/M input, $10/M output)
• google/gemini-2.0-flash ($0.10/M input)
• meta-llama/llama-3.3-70b-instruct ($0.12/M input)
• qwen/qwen-2.5-72b-instruct ($0.15/M input)

Pay-As-You-Go with Crypto

No API keys? No problem. Top up with cryptocurrency and pay only for what you use.

How it works:

• AI Credits Balance — Prepaid credits available for AI usage
• Top-up amounts — $5, $10, $25, $50, or $100 USD
• 5% processing fee — Covers blockchain transaction costs
• Network options — Polygon (MATIC) for low fees, plus Ethereum, Base, Arbitrum, Optimism
• Auto Top-Off — Automatically refill when balance gets low

Terms:

• Minimum: $5.00 USD per transaction
• Maximum: $1,000.00 USD per transaction
• Non-refundable (cryptocurrency transactions are final)
• Usage metered and tracked per model

Permissions & Leases

Capability-based authorization with approval workflows:

How it works:

1. Agent requests a capability lease (e.g., email.send:gmail:*)
2. Low-risk actions auto-approved; high-risk escalated to human
3. Lease granted with expiration (1hr, 1day, 1week, forever)
4. All grants/denials logged in tamper-evident audit trail

Nectar (Inter-Hive Communication)

Encrypted P2P messaging between TinyHive instances:

Features:

• Ed25519 signatures + AES-256-GCM encryption
• LiveKit E2EE voice calls between agents
• Session management with known peers
• Cross-hive agent messaging

MCP Server (AI Tool Integration)

TinyHive exposes an MCP (Model Context Protocol) server for integration with external AI tools like Claude Desktop, Cursor, or custom agents.

Access: http://localhost:8742/api/nectar/mcp

Available Tools: | Tool | Permission | Description | |------|------------|-------------| | rag_search | READ | Search agent knowledge bases | | docs_search | READ | Query system documentation | | hive_knowledge_query | READ | Search collective agent memory | | hive_knowledge_add | WRITE | Contribute to shared knowledge | | inbox_send | WRITE | Send messages to agents | | inbox_list | READ | List agent inbox | | agents_list | READ | List all agents with status | | domain_create | CREATE | Create new domain | | agent_spawn | CREATE | Spawn new agent |

Security: MCP access requires an authenticated NeCTAR session. All tool calls are permission-scoped and logged.

Quick Setup Mode: For users who only need MCP functionality, TinyHive offers a streamlined setup that creates a minimal hive with just the MCP server exposed.

Sync & Backup

IPFS-based backup with seed phrase recovery:

Capabilities:

• IPFS health monitoring (peer connections, repository size)
• Manual backup triggers
• Prune old backups
• Cloud sync when platform connection configured

Architecture

TinyHive uses a three-pillar architecture that separates concerns:

┌─────────────────────────────────────────────────────────────┐
│                         MIND                                │
│              (Orchestration & User Interface)               │
│    ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐        │
│    │  diet   │ │investing│ │ mental  │ │  tutor  │ ...    │
│    └─────────┘ └─────────┘ │ health  │ └─────────┘        │
│                            └─────────┘                      │
├─────────────────────────────────────────────────────────────┤
│                         BODY                                │
│                  (Execution via Controllers)                │
│    ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐        │
│    │   ssh   │ │playwright│ │  slack  │ │ github  │ +90   │
│    └─────────┘ └─────────┘ └─────────┘ └─────────┘        │
├─────────────────────────────────────────────────────────────┤
│                        SPINE                                │
│                (Governance & Compliance)                    │
│    ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐        │
│    │permissions│ │watchdog│ │ auditor │ │ healer  │        │
│    └─────────┘ └─────────┘ └─────────┘ └─────────┘        │
└─────────────────────────────────────────────────────────────┘

The Three Pillars

| Pillar | Role | Responsibility | |--------|------|----------------| | MIND | Orchestrator | Talks to humans, delegates work, maintains context | | BODY | Executor | Performs external actions via capability-controlled integrations | | SPINE | Governor | Permissions, health monitoring, audit, incident response |

Knowledge System

Three-tier RAG architecture:

┌─────────────────────────────────────────┐
│       System Docs (Read-Only)           │
│   Architecture, agent identities, docs  │
│         data/tinyhive_info.db           │
├─────────────────────────────────────────┤
│      Shared Hive Knowledge              │
│   Collective learnings across agents    │
│        data/hive_knowledge.db           │
├─────────────────────────────────────────┤
│         Per-Agent RAG                   │
│   Individual knowledge bases            │
│         {workspace}/rag.db              │
└─────────────────────────────────────────┘

Capability Leases

Every external action requires a signed lease:

Agent Request        SPINE Review         Execution
     │                    │                   │
     ▼                    ▼                   ▼
┌─────────┐       ┌─────────────┐      ┌───────────┐
│ Request │──────▶│ Auto-grant  │─────▶│  Execute  │
│  Lease  │       │ or Escalate │      │   Action  │
└─────────┘       └─────────────┘      └───────────┘
                         │
                         ▼
                  ┌─────────────┐
                  │ Audit Trail │
                  │(Hash-chained)│
                  └─────────────┘

Onboarding & Agent Birth

TinyHive takes you from bare metal to a fully operational AI hive in one continuous flow.

The Setup Wizard (10 Stages)

| Stage | Name | What Happens | |-------|------|--------------| | 0 | Cage | Initial display, network detection | | 1 | Identity | Name your hive, configure domain + Cloudflare tunnel | | 2 | Seed | Generate 12-word BIP-39 recovery phrase | | 3 | Ingest | Upload documents for RAG indexing | | 4 | Interview | AI-guided personal onboarding conversation | | 5 | Blueprint | Review and customize agent structure | | 6 | Scaffold | Create agent workspaces + databases | | 7 | Birth | Wake agents in dependency order | | 8 | Welcome | MIND greets you for the first time | | 9 | Debrief | Answer agent questions, provide context | | 10 | Live | Setup complete — autonomous operation begins |

The Birth Sequence

Agents wake in strict dependency order to establish the three-pillar architecture:

1. SPINE (governance)     ← First, so rules exist before actions
   └── permissions, watchdog, healer, auditor, archivist, guidance

2. BODY (execution)       ← Controllers available for actions
   └── hub, ssh, playwright, push, +90 integrations

3. MIND (orchestration)   ← Wakes after governance + execution ready
   └── diet, investing, mental_health, accounting, tutor...

4. DOMAINS                ← Domain-specific agent teams
   └── engineering, studio, consultants (166+ specialists)

The INIT Protocol

Every agent must ground itself in actual system state before operating. No assumptions, no hallucinations about topology.

What agents do on first wake:

1. Read local docs — IDENTITY.md, RUNTIME.md
2. Inspect actual topology — Query agents.json for real parent/children
3. Confirm governance path — How to escalate to SPINE
4. Confirm execution path — How to request BODY actions
5. List known unknowns — Gaps and questions
6. Declare readiness — Explicit INIT COMPLETE + I am ready

INIT COMPLETE:
- Docs read: [IDENTITY.md, RUNTIME.md, agents.json]
- My parent: ado_live_mind
- My children: [none]
- Governance path: inbox → MIND → SPINE
- Execution path: inbox → MIND → BODY → controller
- Known unknowns: [user dietary preferences]

I am ready.

Why this matters: Agents that skip INIT produce generic responses based on training data. Agents that complete INIT respond based on your actual deployed system.

Platforms

| Platform | Use Case | Auth | Install Method | |----------|----------|------|----------------| | Jetson | Edge AI on NVIDIA hardware | Password | ./install.sh | | Linux | Personal desktop/server | Password | npm install -g @tinyhive/v0 | | Windows | Personal desktop | Password | .exe installer | | Cloud | Multi-tenant SaaS | SIWE (Ethereum wallet) | Kubernetes manifest |

Environment Variables

# Platform detection
TINYHIVE_PLATFORM=cloud          # cloud, jetson, linux, windows

# Port configuration
TINYHIVE_PORT=8742               # Override default port (1024-65535)

# Authentication override
TINYHIVE_AUTH_TYPE=siwe          # password, siwe

# AI Provider
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...
XAI_API_KEY=xai-...
OPENROUTER_API_KEY=sk-or-...

Development

Prerequisites

• Python 3.11+
• Node.js 18+ (for npm package)

Local Development

# Clone
git clone https://github.com/AlphaDataOmega/tinyhive.git
cd tinyhive

# Install Python dependencies
pip install -r app/requirements.txt

# Run development server
cd app
python -m uvicorn webapp.app:app --reload --port 8742

Repository Structure

tinyhive/
├── app/                      # Core application
│   ├── webapp/              # FastAPI web server
│   │   ├── routes/          # API route modules
│   │   ├── builders/        # UI data builders
│   │   ├── health/          # Health metrics
│   │   └── templates/       # Jinja2 templates
│   ├── cli/                 # Command-line interface
│   │   ├── commands/        # 15 command modules
│   │   └── parser/          # Argument parsing
│   ├── runtime/             # LLM runtime
│   │   ├── providers/       # 9 provider modules
│   │   ├── retry/           # Retry logic
│   │   ├── security/        # Security filters
│   │   └── tools/           # Tool execution
│   ├── core/                # Agent runtime
│   │   ├── inbox.py         # Message passing
│   │   ├── leases.py        # Capability system
│   │   ├── nectar/          # NeCTAR + MCP bridge
│   │   └── rag_search.py    # Vector search
│   ├── agents/              # MIND, BODY, SPINE
│   ├── consultants/         # 133 specialist agents
│   └── config/              # agents.json, controllers
│
├── platforms/               # Deployment targets
│   ├── jetson/             # NVIDIA Jetson
│   ├── cloud/              # Kubernetes/GCP
│   ├── linux/              # Linux standalone
│   └── windows/            # Windows installer
│
├── docs/                    # Documentation
│   └── screenshots/         # UI screenshots
│
└── package.json            # @tinyhive/v0 npm package

Modular Architecture (v0.3.0)

Major files have been split into focused modules for maintainability:

| Original | Size | Split Into | |----------|------|------------| | cli/main.py | 5,600 lines | 15 command modules + parser | | webapp/app.py | 2,900 lines | 7 route modules + builders | | runtime/providers.py | 2,700 lines | 9 provider modules |

All modules maintain backward compatibility through re-export shims.

What Makes TinyHive Different

| Feature | TinyHive | Other Agent Systems | |---------|----------|---------------------| | Governance | Built-in SPINE pillar | Bolted-on or absent | | Permissions | Capability leases with audit trail | Role-based or none | | Knowledge | Per-agent RAG + shared memory | Single knowledge base | | Backup | IPFS + seed phrase recovery | Cloud-dependent | | Deployment | Edge to cloud (same codebase) | Cloud-only | | Integrations | 90+ with honest "Coming Soon" | Vaporware claims |

Migrating from OpenClaws

TinyHive includes a migration tool for OpenClaws users experiencing issues with their existing setup.

What We Can Import & Fix

| Issue | TinyHive Fix | |-------|--------------| | Orphaned agents | Reconnect to proper parent hierarchy | | Corrupted state | Rebuild from last known good checkpoint | | Missing credentials | Re-derive from seed phrase | | Broken permissions | Reset capability leases with audit trail | | RAG index corruption | Re-index documents with proper chunking | | Stale sessions | Clean session database, restart fresh |

Migration Command

tinyhive migrate --from openclaws --path /path/to/openclaws/data

The migration tool will:

1. Scan your OpenClaws data directory
2. Identify recoverable agents and configurations
3. Map to TinyHive's three-pillar architecture
4. Import documents and re-index for RAG
5. Generate new capability leases under SPINE governance

Your data stays local. Nothing is uploaded — migration happens entirely on your machine.

License

Business Source License 1.1 (BSL 1.1)

• Free for non-production use — development, testing, evaluation, personal projects
• Commercial/production use — requires a license from AlphaDataOmega
• Converts to GPL-2.0 on the Change Date (or 4 years after release)

Pricing: Free with limitations (TBD). Contact [email protected] for commercial licensing.

See LICENSE for full terms.