honeycomb

AI coding agents forget. They forget across sessions, and they forget across tools. A decision you reached in Claude Code at midnight is invisible to Cursor the next morning. Honeycomb fixes that. A local daemon captures what happens on every turn, distills it, and serves it back to any harness that asks. Learn something once; recall it everywhere, on any machine, in any tool, for anyone on your team.

It answers the questions you keep paying for twice: What did we decide about this? Why is it built this way? What fixed it the last time it broke? Who on the team already solved this?

New here? One command and you're on a dashboard. Jump to Install. · Want the docs? Everything lives at theapiary.sh.

🛹 For AI Augmented Devs

Stop re-explaining your project to a fresh agent every morning. Honeycomb remembers your decisions, your conventions, and the fixes that worked, then primes your next session with them automatically. One install command, a friendly dashboard, no SQL, no config gauntlet.

🏢 For Enterprise Teams

One shared brain across every developer, device, and coding tool. A skill discovered by one engineer propagates to the whole team on their next session. Tenancy is enforced at the storage layer; credentials live behind a single loopback boundary; everything is versioned and auditable.

✨ What makes Honeycomb different

A vector database can store text and hand it back by similarity. Honeycomb does that, and then keeps going. On top of Activeloop Deeplake, Legion Code builds the memory system that turns raw recall into a brain your agents actually trust.

• 🧠 Three-tier memory. Every memory exists at three resolutions at once (one-line key → summary → full raw session). Agents skim the keys, then zoom into detail only when they need it. (Legion Code)
• 🎯 Session priming. At session start a tiny, bounded index (~300-800 tokens) of your most relevant keys is pushed once; the agent pulls deeper on demand. No per-turn injection, no "lost in the middle." (Legion Code)
• 🍯 Skillify & propagation. The daemon mines reusable skills out of real sessions, gates them for quality, and auto-pulls the team's latest skills into every agent at session start. Author a skill once; everyone gets it. (Legion Code)
• 🌼 The pollinating loop. A periodic maintenance pass reasons over accumulated memory and the entity graph to merge duplicates, prune junk, and supersede stale facts, so memory gets sharper over time, not noisier. (Legion Code)
• 🕸️ Knowledge graph. An entity-centric, versioned, provenance-tracked index over your memories. Newer facts supersede stale ones; every claim traces back to the session that produced it. (Legion Code)
• 🔀 Hybrid recall. Lexical (BM25) and semantic (768-dim vectors) search fused by Reciprocal Rank Fusion, with a measured recall@5 ≈ 0.72-0.78. (built on Deeplake)
• 🗺️ Codebase graph. A multi-language AST graph (TypeScript, JS, Python, Go, Rust, Java, Ruby, C/C++) of files, functions, and their call/import/extends edges, queryable for impact and neighborhood. (Legion Code)

🚀 Install (one command)

No Node? No npm? No problem. The installer detects and sets up everything, then opens a dashboard in your browser. The terminal is just a progress log; the product is the first thing you touch.

# macOS / Linux
curl -fsSL https://get.theapiary.sh | sh

# Windows (PowerShell)
irm https://get.theapiary.sh/install.ps1 | iex

That single line installs a current Node/npm if missing, installs @legioncodeinc/honeycomb globally, brings up the daemon on 127.0.0.1:3850, opens the dashboard (Hive portal at 127.0.0.1:3853), and sets up Doctor, a tiny watchdog that keeps it all healthy (opt out with --no-doctor). Then:

1. The dashboard loads in a pre-auth setup state. No token ever touches your shell.
2. Click "First time setup." Honeycomb runs the Deeplake device-flow login for you, shows the code right on the page, and opens the verification tab.
3. Done. The same running daemon lights up its Deeplake-backed surfaces, and capture and recall go live.

Already running Hivemind? The dashboard detects it, explains that running both is unsupported, and "Proceed with Honeycomb" migrates you cleanly. Prefer to inspect before you pipe? The script and a published SHA256SUMS are served from get.theapiary.sh.

git clone https://github.com/legioncodeinc/honeycomb.git
cd honeycomb
npm install
npm run build          # tsc + esbuild → bundle/cli.js, daemon, harness, MCP, embed bundles

node bundle/cli.js setup     # detect your assistants, wire hooks, start the daemon
node bundle/cli.js status    # check the daemon and your environment

setup wires every coding assistant it detects and starts the loopback daemon; any storage command auto-starts the daemon if it is down. You'll need Activeloop Deeplake credentials; the device flow above writes them to the shared ~/.deeplake/credentials.json.

Self-hosting the storage backend? You can run Honeycomb against Activeloop's open-source pg_deeplake Postgres extension instead of hosted Deeplake, and point Honeycomb at it with honeycomb login --endpoint postgres://... (direct) or --endpoint https://... (HTTP gateway), no Activeloop account required. See the self-hosting guide for the setup and the backend contract.

🖥️ Using the dashboard

The dashboard is Hive portal at http://127.0.0.1:3853, the one UI for the whole Apiary stack and the first thing the installer opens. Honeycomb's old in-daemon dashboard is retired; the daemon on :3850 serves data, the portal serves the picture. Everything Honeycomb knows shows up there: KPIs up top (memories, turns, estimated savings, team skills), memory recall you can query by hand, the codebase graph, every captured turn, skill-sync status, and settings, hydrated server-side from the daemon's API. It doubles as the guided-setup surface for first-time login.

⌨️ Using the CLI

One unified honeycomb binary drives everything. Run honeycomb --help for the full list; these are the core verbs: