The Apiary gives your AI coding agents one shared, lasting memory on hardware you control.
A stack of small, sharp programs, each one killing a single stubborn problem. Learn something once, and every agent recalls it everywhere.
A Legion Code × Activeloop collaboration.
One command. It installs the local daemons, wires up your coding assistants, and opens a dashboard in your browser. No database to run, no config ritual.
# macOS / Linux
curl -fsSL https://get.theapiary.sh | sh# Windows (PowerShell)
irm https://get.theapiary.sh/install.ps1 | iexPrefer to read the script first? Open get.theapiary.sh in a browser and check it, checksums and all, before you run it. When it finishes it hands you the Hive dashboard at http://127.0.0.1:3853. Click First time setup, approve the sign-in, and you are done.
The front door has a matching back door. One command returns the machine to a pre-Apiary state:
# macOS / Linux
curl -fsSL https://get.theapiary.sh/uninstall | sh# Windows (PowerShell)
irm https://get.theapiary.sh/uninstall.ps1 | iexThe script is fully self-contained (it works even when Node or npm is broken) and removes every Apiary asset under every historical name: the four OS service units (current and legacy labels), the npm globals (including legacy @deeplake/hivemind), and the state roots ~/.apiary, ~/.deeplake, ~/.hivemind, and ~/.honeycomb. It deletes nothing outside that allow-list.
Before touching anything it asks you to type uninstall to confirm, naming everything it will destroy, including ~/.deeplake, which holds shared Deeplake credentials also used by a standalone Hivemind install. Piped without a terminal it refuses unless you pass --yes (-Yes in PowerShell); --dry-run previews the removal without deleting. Like the installer, it is published with checksums you can verify at get.theapiary.sh.
Smaller hammers exist too: every product has its own uninstall verb that removes only that product (service unit, Doctor registry entry, state dir), and doctor purge performs the same full wipe when Doctor is installed and healthy.
AI coding assistants are brilliant in the moment and amnesiac the next. Close the window and the context is gone. Open a different tool tomorrow and it has never heard of your project. So you re-explain your conventions, re-discover the fix that already worked, and pay for the same tokens every single morning.
The Apiary ends that. A small daemon runs quietly on your machine, notices what happens as you work, distills it into clean notes, and hands the right ones back to any assistant that asks, across sessions, tools, machines, and teammates. It lives on Deeplake, Activeloop's database built for AI: it stores your memory as exact text and as meaning at once, searches both, keeps full version history, and can run in your own cloud. Your memory is isolated per team and project, your secrets are never shown to an agent, and the whole thing gets sharper as it grows instead of rotting into a cache.
Learn something once. Recall it everywhere. On infrastructure you own.
Five products. Each one answers a single stubborn question.
| Product | The problem it kills | Package · port | Stage |
|---|---|---|---|
| honeycomb · the memory | Your agent forgets everything when the window closes. Honeycomb gives every assistant one shared memory that survives sessions, travels across tools, and compounds over time. | @legioncodeinc/honeycomb · :3850 |
Production v0.4 |
| nectar · the understanding layer | Ask where logins live and your agent opens the wrong file. Nectar describes every file by what it does, so agents find code by meaning, not by name. | @legioncodeinc/nectar · :3854 |
Production v0.2 |
| doctor · the watchdog | A daemon dies at 2am and nothing notices. Doctor catches the crash, heals it on a repair ladder, and has your memory back before your next prompt. | @legioncodeinc/doctor · :3852 |
Production v0.3 |
| hive · the portal | Which local port was the dashboard again? None of your problem. Hive serves the whole stack from one address and stays up even when a workload is down. | @legioncodeinc/hive · :3853 |
Production v0.5 |
| queen · the fleet orchestrator | Once the stack spreads across machines, who can see the fleet? Queen is the cloud control plane for presence, identity, and ROI, and it never touches your memory. | not yet published | Design |
Supported coding assistants today: Claude Code, Cursor, and Codex, with Hermes, pi, and OpenClaw in progress. A memory written from one is recalled by the others.
Honeycomb is the product. Nectar extends what it can understand. Hive shows it to you. Doctor keeps it all alive. Queen commands the fleet of machines running the stack. On each device they form a four-role topology: two workload daemons (Honeycomb, Nectar) do the memory work, one always-on portal (Hive) presents it, and one supervisor (Doctor) watches the set. Queen sits above every device as the cloud control plane. All of it rests on the same foundation: Activeloop's Deeplake and the open-source Hivemind agent-memory project.
flowchart TD
os["OS service manager"] --> doctor["Doctor<br/>supervisor watchdog"]
doctor -->|supervises| hive["Hive<br/>always-on portal (dashboard)"]
doctor -->|supervises| comb["Honeycomb<br/>memory workload daemon"]
doctor -->|supervises| nectar["Nectar<br/>semantic-memory workload daemon"]
hive -->|aggregates API| comb
hive -->|aggregates API| nectar
comb -->|storage client| deeplake["Activeloop Deeplake<br/>versioned, columnar + vector, built on Hivemind"]
nectar -->|storage client| deeplake
comb -.presence heartbeat.-> queen["Queen<br/>cloud fleet orchestrator (control plane)"]
nectar -.presence heartbeat.-> queen
hive -.presence heartbeat.-> queen
queen -->|fleet dashboard · signed commands · ROI surface| admins["Admins & teammates,<br/>anywhere"]
- Honeycomb captures what happens on every agent turn, distills it into a three-tier memory (key, summary, raw), and serves it back to any harness that asks. It tidies itself over time, so recall gets sharper, not noisier.
- Nectar gives every file a stable, daemon-minted identity and a plain-language description of what it does, served through the same hybrid recall Honeycomb uses. That is how an agent finds the login logic in a file named
session-refresh.ts. - Hive boots with the device under Doctor's supervision and binds its socket before any workload is confirmed healthy, so the dashboard is up the moment you power on. It renders by aggregating each daemon's API and holds no storage client of its own, so one bad panel never takes down the page.
- Doctor runs beside the daemons under OS supervision. It probes each one's health, heals common failures on the spot, escalates loudly when it cannot, and has no code that can read or delete your credentials. Full stop.
- Queen (design stage) is the control plane above every machine. Daemons report presence upward; admins get a read-only fleet dashboard, a guarded mint/sign identity authority, a signed command channel, and a hosted ROI surface. It coordinates identity and encrypted blobs it cannot decrypt, and never reads your memory content. Observation ships before control.
the-apiary is the umbrella repository for the ecosystem. It holds no product code of its own. It aggregates the five products as git submodules, so the whole system stays reproducible from one checkout while each product keeps its own repository, release cadence, and license.
the-apiary/
├── honeycomb/ submodule · the memory system (daemon, CLI, MCP, SDK, harnesses)
├── nectar/ submodule · semantic file-memory layer
├── doctor/ submodule · the self-healing supervisor watchdog
├── hive/ submodule · the always-on portal daemon
├── queen/ submodule · cloud fleet orchestrator (design and spec)
├── branding/ brand marks and logos for the family and each product
├── product-documentation/ per-product guides, technical manuals, and one-pagers
├── library/ shared knowledge base, PRDs, and design corpus
├── site/ the theapiary.sh marketing site source
├── .cursor/ the Bee Army: the local AI development team that builds the Apiary
├── LICENSE.md AGPL-3.0-or-later
└── README.md you are here
Because the products live in submodules, clone with --recurse-submodules:
# fresh clone, submodules and all
git clone --recurse-submodules git@github.com:legioncodeinc/the-apiary.git
cd the-apiary
# already cloned flat? pull the submodules in:
git submodule update --init --recursive
# update everything later:
git pull --recurse-submodules && git submodule update --remote --mergeThen pick your entry point. Try it: run the one-command install above. Build from source: each submodule is self-contained (cd honeycomb && npm install && npm run build); see its README for the quality gate. Read the design: Queen is written README-first, with its specification under queen/library/.
The Apiary is built by a local AI development team that ships with this repo, so any contributor using Cursor inherits the same specialists and guardrails. It is a small factory: narrow worker-bee subagents (db, security, react, deeplake-dataset, and dozens more) each armed with a deep-domain stinger skill, routed by the-beekeeper and driven to done by the-smoker. Workspace rules hold the house style (plan protocol, no em dashes, clean boundaries), and a model comparison matrix picks the best-fit model per task. It is the same discipline that keeps the products honest.
Every project in the hive shares one license: the GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later). Use any of them commercially or privately, free of charge. Keep the copyright and license notices intact, and if you run a modified version as a network service, you owe its source to its users. Always defer to the LICENSE file inside each submodule for that project's exact terms.
The Apiary exists because two halves fit together. Activeloop brings Deeplake and Hivemind, the durable, queryable foundation the memories live on. Legion Code brings the multi-tier memory, session priming, skill propagation, the self-tidying loop, the knowledge and codebase graphs, and the daemon architecture that turns Deeplake into a shared brain your coding agents read and write on every turn.
Built by Legion Code · Built on Activeloop Deeplake · Powered by Hivemind
theapiary.sh