# Hivemind: shared memory and mined skills for Claude Code, Codex and Cursor agents

> Hivemind is a TypeScript CLI and plugin set from activeloopai that captures agent traces into Deeplake, turns repeated patterns into SKILL.md files, and serves them back to every agent on a team. It installs in one command, needs Node 22 or later, and is Apache-2.0 licensed.

**activeloopai/hivemind** — Hivemind turns your traces into reusable skills across agents

- Repository: https://github.com/activeloopai/hivemind
- Website: https://deeplake.ai/hivemind
- Stars: 1,622 · Forks: 111
- Language: TypeScript
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/activeloopai-hivemind

## The problem Hivemind targets: context that dies with the session

Every coding agent starts each session with an empty head. A migration one engineer's agent worked out on Monday is gone by Tuesday, and the next agent re-derives the same steps from scratch, burning tokens and turns on work that was already done. Hivemind's README frames the goal as one brain for all your agents: capture prompts, tool calls and responses as structured traces, mine them for repeated patterns, and push the results back into every agent on the team.

The intended reader is a team running several agent surfaces at once. The README lists Claude Code, OpenClaw, Codex, Cursor, Hermes, pi and Claude Cowork, and the pitch is that a pattern learned in one of them is available in the others. That is a different promise from a single-assistant memory feature. It is also a heavier commitment, because the value depends on traces from more than one person accumulating in one place.

## How the capture, codify and recall loop actually works

The README describes four stages. Capture records every session's prompts, tool calls and responses as structured traces in Deeplake. Codify mines those traces for repeated patterns and writes them out as reusable SKILL.md files. Search retrieves traces and skills with hybrid lexical plus semantic retrieval, with a BM25 fallback when embeddings are off. Propagate makes the result available across sessions, agents, teammates and machines.

Two mechanisms sit underneath. File operations on ~/.deeplake/memory/ are intercepted through a virtual filesystem backed by SQL, so an agent reading or writing that path goes through Hivemind rather than the host filesystem. Separately, a background worker summarizes sessions into AI-generated wiki pages when a session ends. Storage is bring-your-own-cloud: the README names GCS, Azure, S3 and on-prem buckets, so the trace store does not have to live in activeloop's infrastructure.

The repository layout matches that description. There is a src/ tree for the CLI and core, a harnesses/ directory with per-assistant folders such as codex, cursor, hermes, pi and openclaw, a library/ directory, an mcp/ directory for the Model Context Protocol server, and an embeddings/ directory. The package.json ships harness bundles in its files array, which is how one npm package carries integrations for several different hosts.

## Installing Hivemind and wiring your first assistant

The README gives a one-line installer for macOS and Linux that downloads and runs a script. It detects supported assistants on the machine, wires up their hooks, shows a consent prompt, and opens a browser for sign-in. Restart your assistants afterwards.

```bash
curl -fsSL https://deeplake.ai/hivemind.sh | sh
```

On Windows the equivalent runs in PowerShell. Note that v0.7.151 is titled fix(windows): unfreeze updates, drop the policy-blocked ps1 shim, so the Windows path has been changing recently and the release notes are the place to check before relying on it.

```powershell
irm https://deeplake.ai/hivemind.ps1 | iex
```

For CI, Dockerfiles, or environments where policy blocks piping a downloaded script into a shell, the npm route is the documented alternative. The README warns that it skips the checks the installers perform, so Node 22 or later and a writable npm prefix are your responsibility.

```bash
npm i -g @deeplake/hivemind && hivemind install
```

Headless installs pass a token instead of using the browser flow. Get one from your account settings on https://deeplake.ai. The README states that with no token in a non-interactive shell, the install completes with hooks but skips sign-in, and hivemind login can be run later to enable shared memory.

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

To limit the install to one assistant, the README shows a --only flag and per-assistant subcommands. Running hivemind status afterwards reports what is wired up.

```bash
hivemind install --only claude
hivemind codex install
hivemind status
```

One caveat worth reading closely: the README says the installer shows a consent prompt before opening a browser for sign-in. That is a hosted account step, not a purely local setup, and it is the first place a locked-down environment will fail.

## The Claude Cowork alpha and what it does not capture

The supported-assistants table marks Claude Cowork as alpha. Auto-recall through the hivemind_search, read and index tools is described as solid, but auto-capture covers Local Agent Mode sessions only. The README's explanation is that those sessions write a transcript the tool can tail, while plain desktop-chat turns leave no readable local trace and are not captured.

That is a real boundary rather than a temporary bug. If your team does most of its work in desktop chat rather than in agent mode, Hivemind will recall for you but will not learn from you, which breaks the loop the product is built around. The same table shows every other listed assistant with both auto-capture and auto-recall, so the gap is specific to this one integration.

## What the LoCoMo numbers do and do not tell you

The README reports a LoCoMo run over 100 QA pairs using Claude Haiku via claude -p with hybrid lexical plus semantic retrieval. Against a no-memory baseline it lists $8.94 versus $6.65 in cost per 100 QA, 1,700 versus 1,008 tokens per question, and 8.9 versus 6.2 turns per question. The stated explanation is that prior work is already in scope at recall time instead of being re-derived each session.

Read that as a benchmark result, not a forecast. LoCoMo is a long-context memory benchmark, and the configuration is one model with one retrieval mode. The README does not report what happens with embeddings disabled, which is the BM25 fallback path, nor how the numbers move as the trace store grows. The token and turn reductions are the more transferable figures, since they follow from not re-deriving context; the dollar figure is tied to Haiku pricing at the time of the run.

## Where Hivemind is the wrong tool

If you run a single agent on a single machine with no teammates, the shared half of the product has nothing to share. The capture, codify and propagate stages only pay off when traces from more than one session or more than one person are flowing into the same store. A solo developer gets the recall side and the storage overhead without the cross-agent payoff.

The second mismatch is environment. The npm install path requires Node 22 or later, and the installer path assumes you are willing to pipe a remote script into a shell or, failing that, to sign in through a browser or supply a token. Teams that cannot accept a hosted account step for shared memory should treat the bring-your-own-cloud storage option as a separate question from authentication; the README describes where data is stored, not how sign-in is replaced.

Third, the virtual filesystem intercepts operations on ~/.deeplake/memory/. Any workflow that expects that path to behave like an ordinary directory, for example a backup job or a file watcher, is now talking to a SQL-backed layer instead.

## How Hivemind differs from a plain RAG or vector-store setup

A conventional retrieval setup indexes documents you already have and answers questions against them. The index is passive: nothing writes to it unless a human or a pipeline puts content there. Hivemind inverts that. The traces are produced as a side effect of normal agent use, and the codify stage writes new artifacts, the SKILL.md files, that did not exist before. Retrieval is hybrid, lexical plus semantic, and the README documents a BM25 fallback when embeddings are off, so the system degrades to keyword search rather than failing.

Compared with a per-assistant memory feature, the difference is scope. A single-assistant memory keeps context for that assistant on that machine. Hivemind's propagation stage is explicitly cross-session, cross-agent, cross-teammate and cross-machine, backed by the Deeplake store. That is a larger surface to operate, and it is the reason the BYOC storage options matter: you are deciding where a shared artifact lives, not just where a local cache sits.

## Maintenance, release cadence and licence

The last push to the main branch was on 2026-09-10, and releases v0.7.149 through v0.7.151 landed between 2026-09-02 and 2026-09-10. Those patch titles are informative about cost: one grants summarizer directories explicitly instead of relying on bypassPermissions, another sends the client OS as a header on the signup path, and the third unfreezes Windows updates and drops a policy-blocked ps1 shim. Expect to track patch releases rather than pinning once and forgetting.

Upgrading is an npm operation against the global package, and the repository ships a postinstall script that runs scripts/ensure-tree-sitter.mjs, so a native tree-sitter step is part of installation. The package.json also defines typecheck, a jscpd duplicate check and vitest as the CI gate, which tells you what the maintainers test before publishing.

The licence is Apache-2.0, stated in the README badge and the LICENSE file at the repository root. That permits commercial use and modification with the usual attribution and notice conditions. It says nothing about the hosted Deeplake service or the account you sign into during install, which are governed separately; read those terms before assuming the licence covers the whole setup.

## Conclusion

Adopt Hivemind if several agents or several people already work in the same repositories and you want one trace store instead of per-session context. Do not adopt it if you cannot run Node 22 or cannot accept a hosted sign-in for shared memory. Before rolling it out, run hivemind status to confirm which assistants were wired, and check the Claude Cowork alpha limits if desktop chat is part of your workflow.

## FAQ

### How do I get Hivemind?

On macOS and Linux the README gives a one-line installer script, and on Windows the equivalent PowerShell command. There is also an npm path, npm i -g @deeplake/hivemind && hivemind install, for CI and Dockerfiles, which requires Node 22 or later and a writable npm prefix.

### How do I use Hivemind with a specific assistant only?

The README shows hivemind install --only claude and per-assistant subcommands such as hivemind codex install, hivemind cursor install and hivemind claw install. Running hivemind status afterwards reports what is wired up.

### What is Hivemind AI?

It is a cloud-backed shared memory layer for AI coding agents, published as @deeplake/hivemind. It captures session traces in Deeplake, codifies repeated patterns into SKILL.md files, and makes them available to every agent on a team.

## Sources

- [activeloopai/hivemind on GitHub](https://github.com/activeloopai/hivemind)
- [License: Apache-2.0](https://github.com/activeloopai/hivemind/blob/main/LICENSE)
- [Project website](https://deeplake.ai/hivemind)
- [README](https://github.com/activeloopai/hivemind/blob/main/README.md)
- [Releases](https://github.com/activeloopai/hivemind/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/activeloopai-hivemind