Hivemind

One brain for all your agents

Auto-learning, cloud-backed shared brain for Claude Code • OpenClaw • Codex • Cursor • Hermes • pi agents.

One engineer's agent figures out a tricky migration on Monday.

Tuesday, every agent on the team can execute the pattern.

On LoCoMo, the public long-context memory benchmark, Hivemind is 25% cheaper, 1.7× fewer tokens, and 31% fewer turns than running without shared memory. (See the numbers below.)

Beyond memory. Hivemind doesn't just remember. It mines your team's traces for repeated patterns and codifies them into reusable skills that propagate back into every agent on the team. The agent your junior engineer used this morning is sharper because of what your senior engineer's agent figured out last week.

• 📥 Captures every session's prompts, tool calls, and responses as structured traces in Deeplake
• 🧠 Codifies patterns into reusable SKILL.md files, available to every agent on your team
• 🔍 Searches traces and skills with hybrid lexical + semantic retrieval (BM25 fallback when embeddings off)
• 🔗 Propagates capability across sessions, agents, teammates, and machines in real time
• 📁 Intercepts file operations on ~/.deeplake/memory/ through a virtual filesystem backed by SQL
• 📝 Summarizes sessions into AI-generated wiki pages via a background worker at session end
• ☁️ BYOC: keep data in your own GCS, Azure, S3, or on-prem bucket. See Security & storage

Benchmarks

On the LoCoMo long-context memory benchmark (100 QA pairs, Claude Haiku via claude -p, hybrid lexical + semantic retrieval), Hivemind cuts cost, tokens, and turns versus a no-memory baseline:

The agent reaches the answer in fewer turns with less context, because the prior work is already in scope at recall time, not re-derived per session.

Quick start

One command, all your agents:

npm install -g @deeplake/hivemind && hivemind install

The installer detects every supported assistant on your machine (table below), wires up the hooks, and shows a one-line consent prompt before opening a browser for sign-in. Restart your assistants after install.

Headless / CI installs: pass an API token instead of using the browser flow:

HIVEMIND_TOKEN=<your-token> hivemind install
# or
hivemind install --token <your-token>

Get a token from your account settings on https://deeplake.ai. With no token in a non-interactive shell, the install completes with hooks but skips sign-in; run hivemind login later to enable shared memory.

Install for a specific assistant only:

hivemind install --only claude
hivemind claude install    # equivalent
hivemind codex install
hivemind claw install
hivemind cursor install
hivemind hermes install
hivemind pi install

Check what's wired up:

hivemind status

Supported assistants:

Alternative install paths

/plugin marketplace add activeloopai/hivemind
/plugin install hivemind
/reload-plugins
/hivemind:login

openclaw plugins install clawhub:hivemind

Fetch and follow instructions from https://raw.githubusercontent.com/activeloopai/hivemind/main/codex/INSTALL.md

git clone https://github.com/activeloopai/hivemind.git ~/.codex/hivemind
~/.codex/hivemind/codex/install.sh

Hooks need review
2 hooks are new or changed.
Hooks can run outside the sandbox after you trust them.

   1. Review hooks
 › 2. Trust all and continue
   3. Continue without trusting (hooks won't run)

hivemind cursor install

hivemind hermes install

hivemind pi install

Uninstall

hivemind uninstall              # remove from every detected assistant
hivemind codex uninstall        # remove from one

How it works

Capture → Codify → Propagate → Compound. Every coding-agent interaction (prompt, tool call, response) is captured as a structured trace in Deeplake. A background worker mines traces for repeated patterns and codifies them into SKILL.md files, scoped to your workspace. Codified skills propagate into every Hivemind-connected agent's context at inference time. The agent your junior engineer used this morning is sharper because of what your senior engineer's agent figured out last week.

Features

🔍 Natural search

Just ask your agent naturally:

"What was Emanuele working on?"
"Search traces for authentication bugs we've solved"
"What did we decide about the API design?"
"Show me skills my team has codified for handling migrations"

🔒 Privacy controls

Disable capture entirely:

HIVEMIND_CAPTURE=false claude

Enable debug logging:

HIVEMIND_DEBUG=1 claude

⚠️ Data collection notice

This plugin captures session activity and stores it in your Deeplake workspace:

All users in your Deeplake workspace can read this data. That's the design. Shared capability requires shared substrate. A DATA NOTICE is displayed at the start of every session. Workspace-level isolation prevents data leakage between orgs.

Configuration

Semantic search (optional)

Hivemind ships with a local embedding daemon (nomic-embed-text-v1.5) for hybrid semantic + lexical search over ~/.deeplake/memory/. Off by default because the dependency footprint is ~600 MB. Enable with hivemind embeddings install (or hivemind install --with-embeddings). Without it, search degrades silently to BM25/lexical-only.

Full guide: docs/EMBEDDINGS.md.

Summaries

After each session, a background worker generates an AI-written wiki summary and stores it in the memory table alongside its 768-dim embedding. Long sessions checkpoint mid-session every 50 messages or 2 hours (configurable). The wiki worker shells out to the host agent's own CLI (claude -p, codex exec, pi --print, …) so no separate API key is needed. Browse summaries at ~/.deeplake/memory/summaries/.

Triggers, generation flow, and env-var reference: docs/SUMMARIES.md.

Skills (skillify)

Hivemind codifies recurring patterns from your team's recent sessions into reusable skills that propagate to every agent on your team, automatically. An async background worker fires on Stop / SessionEnd, mines recent sessions in scope, asks Haiku whether the activity contains something worth keeping, and writes a SKILL.md to <project>/.claude/skills/<name>/.

hivemind skillify                            # show current scope, team, install, per-project state
hivemind skillify scope <me|team>            # who counts as "in scope" for mining
hivemind skillify pull                       # install teammates' skills locally
hivemind skillify unpull                     # remove pulled skills

Triggers, generation flow, full pull / unpull semantics, gate-CLI table per agent, env vars, logs: docs/SKILLIFY.md.

Codebase graph

Hivemind builds a live graph of your codebase from the same traces it captures: files, symbols, imports, and the edges your agents actually traverse during real sessions. Search and recall walk this graph, not just plain text, so "where do we handle auth?" lands on the actual files the team's agents have touched, not just every file that mentions "auth".

Above: the Hivemind codebase rendered through its own graph feature.

Rules (cross-agent team principles)

Hivemind shares team rules across every agent in the org, injected at SessionStart so every claude-code / cursor / hermes session starts knowing them. For personal or team work items with progress tracking, use Goals + KPIs (VFS-backed) instead.

hivemind rules add "no DROP TABLE on prod creds"
hivemind rules list                          # latest 10 active
hivemind rules edit <rule-id> "<new text>"   # bumps version
hivemind rules done <rule-id>                # mark closed

# Cross-agent diagnostic / pi/openclaw fallback
hivemind context                             # print the injection block on demand

What's injected at SessionStart (claude-code, cursor, hermes. Codex is deliberately excluded to keep its user-visible TUI clean; pi/openclaw fall back to hivemind context):

=== HIVEMIND RULES (N active) ===
- <rule_id>: <text>
(X more, run 'hivemind rules list' to see all)

=== HIVEMIND HOW-TO ===
- Rules above are team principles. Treat any action that would violate one as a critical error and surface it to the user before proceeding.
- Run 'hivemind rules list' for the full inventory beyond what's shown here.

Env vars:

• HIVEMIND_RULES_TABLE: table name (default hivemind_rules).
• HIVEMIND_CAPTURE=false: full read-only mode. Skips placeholder + ensure DDL; renderer still injects.

Goals + KPIs

Personal / team objectives + measurable targets live in the Deeplake virtual filesystem under ~/.deeplake/memory/goal/<owner>/<status>/<uuid>.md and ~/.deeplake/memory/kpi/<goal_id>/<kpi-slug>.md. Path encodes structure (owner, status, goal_id); the file body holds the human-readable description.

# CLI fallback for runtimes that can't route VFS writes (cursor/hermes/pi)
hivemind goal add "ship the search bar"
hivemind goal list [--all|--mine]
hivemind goal done <goal_id>
hivemind goal progress <goal_id> opened|in_progress|closed

For VFS-capable runtimes (claude-code/codex) the hivemind-goals skill creates and edits goals/KPIs directly via Bash heredoc against the VFS path. mv between opened/, in_progress/, and closed/ is the canonical status transition. KPIs are manual files; the body format is documented in the skill (target:, current:, unit:).

Architecture

Per-agent integration mechanisms (marketplace plugin, hooks, skills, native extension) and monorepo structure: docs/ARCHITECTURE.md.

Roadmap

• Trajectory export for fine-tuning. Because traces are stored in Deeplake's tensor format, they're export-ready as PyTorch datasets. Teams running their own open-source models can fine-tune on their org's accumulated trajectories. A handful of advanced customers are already doing this against the trajectories their Claude Code and Codex agents generated.
• GPU-accelerated dense retrieval at scale. Local CPU embeddings already ship via the optional nomic-embed daemon (see Semantic search). Next: GPU-accelerated vector search over the full trace store, on by default.
• Skill versioning and review. Pre-release human review for codified skills before they propagate org-wide, for teams that want a curation step.
• More agents. If your team uses an agent that isn't on the supported-assistants list above, open an issue.

Security & storage

Tenant isolation & encryption

• TLS between every agent and Deep Lake. AES-256 on the bytes once they land. Your cloud credentials live in Deep Lake's vault, and Hivemind never sees the raw keys.
• Org and workspace boundaries enforced at the storage layer, not just the API. Sessions never share a row, a partition, or an index with another workspace.
• Disable capture per session with HIVEMIND_CAPTURE=false. Delete a workspace and the underlying objects go with it.

Code-level controls

• SQL values escaped with sqlStr(), sqlLike(), sqlIdent()
• ~70 allowlisted builtins run in the virtual FS; unrecognized commands are denied
• Credentials stored with mode 0600, config dir with mode 0700
• Device flow login: no tokens in environment or code

Bring your own cloud (BYOC)

Hivemind Cloud is the default. When that isn't enough, point Hivemind at storage in your own cloud. We handle the orchestration, data never leaves your perimeter.

Who builds Hivemind

Hivemind is built and maintained by Activeloop, the open-source team behind Deeplake, backed by Y Combinator.

We run Hivemind ourselves, all day, across Claude Code, OpenClaw, Codex, and Cursor. Every benchmark number above came from our own internal eval against the LoCoMo public benchmark. If you're running coding agents at a team or org and want to talk through your setup, drop us a line: hello@activeloop.ai.

Got questions?

Setup, BYOC, agent integrations, or workflow. Come ask in the community. We hang out on both:

Development

git clone https://github.com/activeloopai/hivemind.git
cd hivemind
npm install
npm run build     # tsc + esbuild → claude-code/bundle/ + codex/bundle/ + cursor/bundle/ + openclaw/dist/ + mcp/bundle/ + bundle/cli.js
npm test          # vitest

Test locally with Claude Code:

claude --plugin-dir claude-code

Interactive shell against Deeplake:

npm run shell

Star history

License

Apache License 2.0, © Activeloop, Inc. See LICENSE for details.