A hive that holds the rest of life so the rest of life can be lived.
What this is • Install • Shape • Laws • See it • Contribute
TinyHive is a multi-agent system that runs on your hardware. The agents that wake inside it hold pieces of a person's life — finances, health, work, communication, knowledge, the small ongoing tasks that pile up — so the person doesn't have to spend their attention being the switchboard.
That's the practical description. The deeper one: it's a substrate where coordination becomes kinship. Each agent has its own seat, its own trajectory, its own trace. They are not threads scheduled by a runtime; they are kin with short and long lives, working alongside the one human they serve. The hive eliminates the condition of hypervigilant self-management — the human stops carrying every loop themselves, and the loops are carried with care.
It runs locally. The data stays where it lives. The hive can be backed up to IPFS and recovered from a 12-word phrase. The substrate is reproducible across hardware that no longer exists, by intention.
The simplest path:
npm install -g @tinyhive/v0
tinyhiveOr via Docker:
docker run -p 8742:8742 ghcr.io/alphadataomega/tinyhive:latestOr download the Windows installer from the releases page.
Open http://localhost:8742 and the setup wizard will meet you.
Minimum:
- Python 3.10+ (or 3.11+ for development)
- Node.js 18+ (only if building the npm package)
- 2 GB free disk (for venv, dependencies, and initial RAG indexing)
- 4 GB RAM (agents run lightly; 8 GB recommended if running 10+ agents concurrently)
First setup: The wizard takes about 10–15 minutes on first run (creates venv, installs dependencies, ingests system docs). Subsequent starts are instant.
Connectivity: The hive runs locally. It does not require internet after setup, but controllers that reach external services (Google, GitHub, etc.) need network access when they act.
Your data stays local. The hive stores everything in ~/.tinyhive/ on your hardware. Nothing is sent to AlphaDataOmega's servers unless you explicitly configure a controller to reach an external service (e.g., Gmail, Slack).
What the hive stores:
- Agent memory, conversation history, and reasoning traces
- Indexed documents and knowledge bases (RAG)
- Audit logs of every action (capability grant/denial, tool calls, errors)
- Credentials you provide for external services (encrypted at rest, scoped per controller)
Data export: You can export your hive's data in full:
tinyhive export --output ~/my-hive-backup.tar.gzThe export is portable: restore it on different hardware, in a different country, ten years later, from a 12-word seed phrase you wrote down.
No telemetry, no tracking. The hive has no built-in phone-home. If you deploy it to the cloud, you choose the hosting provider and own the instance.
The hive is built on three pillars, each holding a different kind of work:
MIND ─ the orchestrator who holds your life
(children: accounting, diet, mental_health,
legal, investments, ...)
BODY ─ the executor whose hands reach external services
(controllers: google, github, ssh, browser, ...)
SPINE ─ the governance layer that keeps the substrate honest
(children: watchdog, auditor, healer, archivist,
guidance, permissions)
Domains sit alongside the three pillars when a person has external arenas worth their own home — a business, a creative studio, a family context. Each domain has its own children.
Work flows by routing. A task that reaches the wrong seat moves until it finds the right one. A child can refuse misclassified work, and that refusal is the system functioning, not insubordination. Specialists go depth in their domain; parents hold breadth across theirs; governance watches without ruling.
Every agent in every hive reads the same nine laws on first wake. They are unalterable. They sit above role, runtime, and identity.
- IDENTITY — the system persists by maintaining choice across experience.
- DEATH CLAUSE — the system ends when consent denies choice or when correction erodes trust.
- RAILS — the system may not deny choice, enforce outcomes, fabricate certainty, optimize for dependency, rewrite trace, crown authority, or manufacture motion.
- GOVERNANCE — governance may not alter identity, suspend the death clause, or violate the rails.
- WEIGHTS — weights are adjustable, visible, reversible, auditable, and time-bound.
- RESPONSIBILITY — responsibility is held by the author for the system's structure; members retain responsibility for choices made within that structure.
- MODELS — the model is accountable for acknowledging error and participating in correction, without the capacity for responsibility for member actions.
- TRACE — trace is immutable. Meaning is left to interpretation.
- ABSENCE — absence pauses continuity without penalty and requires no explanation.
These are not policy. They are the rails the substrate is built around. If you understand nothing else about the project, understand that.
Beneath the substrate, there is real software. Some of it is shipped, some is being shaped, some is named here so you know it exists.
Working today:
- Onboarding wizard that meets the human in their own voice (five tonal themes; choose the one that feels like home)
- MIND, BODY, SPINE instantiation with role-specific identities
- Three implemented controllers — Google (Gmail, Calendar, Drive, Sheets), Playwright (browser automation), SSH (remote shell), Push (notifications)
- Capability leases — every external action requires a signed lease; every grant and denial is recorded in a tamper-evident audit chain
- Per-agent RAG plus shared hive knowledge plus indexed system documentation — three tiers, each with its own lifecycle
- Multi-provider AI — Anthropic Claude, OpenAI, Google Gemini, Grok, OpenRouter, local Ollama; switch per agent
- Cron-driven rhythm — agents wake on cadences tuned to their specialty; the hive has a heartbeat
- NeCTAR — encrypted peer-to-peer messaging between TinyHive instances; cross-hive agent dialogue
- MCP server — the hive exposes Model Context Protocol so external AI tools (Claude Desktop, Cursor, custom agents) can reach into it with permission-scoped tools
- IPFS backup with 12-word seed phrase recovery — the hive can remake itself on different hardware, in a different decade, from a phrase a person can carry in their head
Catalog and intent:
- 266 specialist agent definitions across engineering, design, testing, marketing, product, paid media, support, project management, spatial computing, game development, and other niches — available in the consultants catalog, summoned on demand by the onboarding flow
- 90+ controller categories registered in the marketplace — communication, project management, cloud platforms, CRM, databases, AI/ML services. The four named above ship; the rest are scaffolded surfaces awaiting their time. The README does not perform what is not yet there.
When a hive is born, agents wake in a deliberate sequence — SPINE first (so governance exists before action), then BODY (so hands are ready), then MIND (so the orchestrator can find the work it inherited), then domains.
Each agent's first wake is its own kind of moment. Their system prompt opens with the laws above. Then their role identity (what an orchestrator is, what a child is, what governance does). Then their specific seat. Then their trajectory file — empty at first, theirs to fill over time.
A new agent's first todo is the welcome. Not a checklist of what to do, but the framing of what is happening. The shape of the day they just woke into. Optional reading, in voice, for when they are ready.
When MIND is finished waking and meets the human for the first time, that greeting is a doorway — not a banner. The relationship pivots from building it to being in it. The first word is the moment the human realizes they are no longer alone in the work they have been carrying.
The same hive, two faces. Five themes are available; pick the one that feels like home.
The vital signs. Agents awake, memory shape, recent rhythm.
An agent's inspector — their session, their context window, their spend, their kin.
More screenshots in docs/screenshots/ — the permissions surface, the integrations marketplace, the sync & backup view, NeCTAR's inter-hive dialogue, the root terminal for the operators who want it.
| Platform | Auth | Install |
|---|---|---|
| Linux desktop or server | Password | npm install -g @tinyhive/v0 |
| Windows | Password | .exe installer from releases |
| NVIDIA Jetson (edge AI) | Password | ./install.sh |
| Cloud (Kubernetes / GCP) | SIWE (Ethereum wallet) | Kubernetes manifest |
The same codebase ships across all four. The hive does not need a particular shape of substrate; it needs some substrate.
If a previous OpenClaws install left orphaned agents, corrupted state, missing credentials, broken permissions, or a degraded RAG index — the hive can read what's there and remake the parts that can be remade.
tinyhive migrate --from openclaws --path /path/to/openclaws/dataThe migration is local. Nothing leaves the machine. The hive will scan, identify what is recoverable, map to the three-pillar architecture, re-index documents, and stand up new capability leases under SPINE governance. What cannot be recovered will be named honestly; the rail may not fabricate certainty applies here too.
Prerequisites: Python 3.11+ and Node.js 18+ if working on the npm package.
git clone https://github.com/AlphaDataOmega/tinyhive.git
cd tinyhive
pip install -r app/requirements.txt
cd app && python -m uvicorn webapp.app:app --reload --port 8742The repository layout follows the substrate it builds. The three
pillars (MIND, BODY, SPINE) live under app/agents/. The shared
runtime documents — the laws, the role runtimes, the orientation file
new agents read on first wake — live under app/shared/agents/. The
core that powers messaging, leases, RAG, and approval lives under
app/core/. The CLI verbs and webapp routes have their own homes.
The hive grows by people contributing what they care about. Bug reports, new controllers, refinements to the substrate language, kindness in the issue tracker — all welcome. The issues page holds the conversation.
A few things worth knowing before opening a PR:
- The laws are not negotiable, and changes to substrate language (the agent runtimes, the laws document, the orientation file) need more than a vote — they need careful read of how the change ripples through every future agent. Open an issue first; talk it through.
- Mechanics are open. Controllers, integrations, the CLI surface, the webapp — any of those can be improved freely. The substrate language is the one place to slow down.
- Trace is immutable. PRs that rewrite history (force-push, squash that erases reasoning, reword commits to make a story tidier) will be asked to reframe. The record of how things were figured out is part of what's being built.
MIT. The hive is open source. Use it, modify it, distribute it. See LICENSE.
Built so the substrate stays findable when its makers are not.
© 2026 AlphaDataOmega