Hivemind: a shared trace and skill store for Claude Code, Codex and Cursor agents
Hivemind turns your traces into reusable skills across agents
At a glance
- What is it?
- Hivemind captures agent sessions as structured traces, mines them for repeatable patterns and writes those patterns back out as SKILL.md files. The pitch is one brain for every agent on a team. The catch is that the brain lives in Deeplake and the installers want to pipe a remote script into your shell.
- Who is it for?
- Adopt Hivemind if your team already runs Claude Code, Codex or Cursor side by side and you are willing to route session traces through Deeplake, either hosted or in your own bucket. Do not adopt it for a single developer on one agent, for desktop chat sessions, or anywhere a remote install script cannot be piped to a shell and an outbound account is not acceptable.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 4 days ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The problem Hivemind targets: agents that relearn the same migration every week
Coding agents are stateless across sessions by default. Each new conversation starts with the repository, the prompt and whatever the user pastes in, and nothing else. If one engineer's agent works out how to move a service off a deprecated API on Monday, the agent another engineer opens on Tuesday has no way to know that. The README frames the gap in exactly those terms: one engineer's agent figures out a tricky migration on Monday, and Tuesday every agent on the team can execute the pattern. That is the promise, and it is a coordination problem rather than a model problem. The target user is a team, not an individual. The README lists Claude Code, OpenClaw, Codex, Cursor, Hermes, pi and Claude Cowork (Alpha) as supported assistants, and the value proposition only holds when at least two of those are in use or when more than one person is running the same one. A solo developer on a single agent gets a memory layer; a team gets a shared one, which is the point of the name.
What actually gets stored: traces in, SKILL.md files out
The pipeline has four stages, and the README names all of them. Capture writes every session's prompts, tool calls and responses into Deeplake as structured traces. Codification runs over those traces, looks for repeated patterns and emits reusable SKILL.md files. Retrieval is hybrid lexical plus semantic, with BM25 as the fallback when embeddings are switched off. Propagation pushes both traces and skills back to every agent on the team, across sessions, agents, teammates and machines. Two details in that list matter more than the marketing around them. The first is the BM25 fallback: semantic retrieval is optional, and the system is designed to degrade to keyword search rather than fail. The second is that the output artifact is a file, not a vector or a prompt fragment. SKILL.md is a format the host assistants already understand, which is why the same codified pattern can be dropped into Claude Code and Codex without a translation layer. A background worker also summarizes finished sessions into AI-generated wiki pages, which is a separate output from the skills and serves a different purpose: reading rather than executing.
The virtual filesystem over ~/.deeplake/memory/
Hivemind intercepts file operations on ~/.deeplake/memory/ through a virtual filesystem backed by SQL. That is the least conventional part of the design and the one worth understanding before you install anything. Rather than asking each assistant to call a memory API, Hivemind presents a directory that agents can read and write with ordinary file tools, and translates those operations into SQL against the backing store. The advantage is that no assistant needs a bespoke memory integration: if it can read a file, it can read memory. The cost is that the path is fixed and the interception is a layer between the agent and the filesystem, so anything that bypasses normal file operations, or runs outside the sandbox the hooks establish, will not be captured. The release history shows this layer is still being tuned. v0.7.150 is titled "grant summarizer dirs explicitly instead of relying on bypassPermissions", which is a permissions fix in the summarizer path, and v0.7.151 unfreezes updates on Windows and drops a ps1 shim that policy had blocked. Both are the kind of change you make when an interception layer meets real endpoint policies.
Installing it: three paths and the token you will need
The macOS and Linux installer is a single piped command: curl -fsSL https://deeplake.ai/hivemind.sh | sh. Windows uses irm https://deeplake.ai/hivemind.ps1 | iex in PowerShell. The npm path exists for CI and Dockerfiles and for environments where piping a downloaded script to a shell is blocked by policy: npm i -g @deeplake/hivemind && hivemind install. The README is explicit that the npm route skips the checks the installers perform, so Node 22 or newer and a writable npm prefix are your responsibility. The installer detects supported assistants, wires up hooks and shows a one-line consent prompt before opening a browser for sign-in. For headless installs, pass HIVEMIND_TOKEN=<your-token> hivemind install or hivemind install --token <your-token>, with the token coming from account settings on deeplake.ai. In a non-interactive shell with no token, the install completes with hooks but skips sign-in, and hivemind login enables shared memory later. You can scope the install with hivemind install --only claude, or per-assistant commands such as hivemind codex install, hivemind cursor install and hivemind claw install. hivemind status reports what is wired up. Restart your assistants after installing, since the hooks are read at startup.
Where the integration matrix breaks down
The supported-assistant table is honest about uneven coverage, and the unevenness is the main practical constraint. Claude Code, OpenClaw, Codex, Cursor, Hermes and pi all show auto-capture and auto-recall. Claude Cowork is marked Alpha, with auto-recall described as solid but auto-capture limited to Local Agent Mode sessions. The README gives the reason: those sessions write a transcript that can be tailed, while plain desktop-chat turns leave no readable local trace and are not captured at all. So the memory you get from Claude Cowork is partial by construction, and the gap is in the data source rather than in the implementation. The integration mechanisms also differ per assistant: a marketplace plugin for Claude Code, a native extension for OpenClaw, hooks.json for Codex and Cursor, shell hooks in config.yaml plus a skill and an MCP server for Hermes, and an extension API plus skill plus AGENTS.md for pi. Six different wiring strategies means six different failure surfaces, and hivemind status is the only way to see which ones actually landed on a given machine.
The LoCoMo numbers and what they do not cover
The README reports results on LoCoMo, described as a public long-context memory benchmark, using 100 QA pairs, Claude Haiku via claude -p, and hybrid lexical plus semantic retrieval. Against a no-memory baseline, cost per 100 QA drops from $8.94 to $6.65 (25% cheaper), tokens per question from 1,700 to 1,008 (1.7x fewer) and turns per question from 8.9 to 6.2 (31% fewer). The stated mechanism is that prior work is already in scope at recall time rather than re-derived per session. These are self-reported figures on a memory benchmark, and the setup is narrow: one model, one harness, 100 questions. Nothing in the material reports results on software engineering tasks, which is the workload the product is aimed at, and nothing reports the cost of the codification pass or the summarizer worker that runs at session end. The savings on question answering are not the same as savings on a multi-hour migration. Treat the table as evidence that recall reduces redundant context, not as a forecast for your repository.
The alternative: per-assistant memory files and a checked-in conventions document
The obvious alternative is what teams do today, which is CLAUDE.md, AGENTS.md and similar per-assistant instruction files committed to the repository. The difference is in the direction of the data flow. A checked-in conventions file is written by humans, reviewed in a pull request, versioned with the code and identical for everyone. Hivemind writes its SKILL.md files from observed traces, so the content is derived from what agents actually did rather than from what a person decided they should do. That makes Hivemind better at capturing tacit procedure, the kind of thing nobody bothers to document because it is obvious once you have done it, and worse at guaranteeing that the captured procedure is correct. A bad pattern that happens to repeat will be codified. The two approaches are not exclusive: Hivemind's pi integration already reads AGENTS.md, and the skills it produces land in the same conceptual space as a hand-written conventions file. The question is whether you want the file authored by review or by frequency.
Licence, upgrade cadence and what to check before rollout
Hivemind is Apache-2.0, which permits commercial use and modification and includes an explicit patent grant. That is the licence text and nothing more; whether the Deeplake service the tool talks to carries separate terms is a question for the vendor, not something the repository answers. The upgrade cadence is fast. Three releases land in the eight days covered by the supplied data: v0.7.149 adds a client OS header on the signup path, v0.7.150 fixes summarizer directory grants, v0.7.151 fixes Windows update freezing. Patch-level churn at that rate is normal for a tool that hooks into six third-party assistants, but it also means the hooks in your assistant configs are the thing most likely to break on an assistant upgrade, not the package itself. Storage is BYOC, with GCS, Azure, S3 and on-prem buckets named, so the data residency question has an answer that does not require trusting a hosted store. What none of this tells you is whether the codifier's output is good on your codebase. That is the one thing to measure before a team-wide install: run it on one machine for a week and read the SKILL.md files it produces.
Editorial conclusion
Adopt Hivemind if your team already runs Claude Code, Codex or Cursor side by side and you are willing to route session traces through Deeplake, either hosted or in your own bucket. Do not adopt it for a single developer on one agent, for desktop chat sessions, or anywhere a remote install script cannot be piped to a shell and an outbound account is not acceptable. Before rolling it out, run hivemind status on one machine, confirm which hooks landed in each assistant's config, and read the SKILL.md files the codifier produces for a week to see whether the patterns it promotes are ones you would have written yourself.
Community notes