I ran one command, pointed Hivemind at my real Claude Code history, and about two minutes later it had written nineteen reusable skills describing how I actually work. Then it refused to write one more, because my own repository already documented that pattern.
That refusal is the moment the tool earned my attention. Most "AI memory" products hoard everything and call it a feature. This one made a judgment call. I spent a day wiring Hivemind into my production Claude Code setup, breaking it, tracing a real bug through its source, and measuring what it actually does. What follows is the honest version: the wins, and the parts that cost you.
Hivemind is Activeloop's continual-learning layer for coding agents. It captures your agent sessions as traces, mines the repeated patterns into SKILL.md files, and feeds those skills, plus recalled memory, back into every agent on your team. Claude Code, Cursor, Codex, and a few others. The pitch is simple: the agent your junior used this morning is sharper because of what your senior's agent figured out last week.
Hivemind positions itself as one shared brain across Claude, OpenClaw, and Codex
The One-Command Install, and the Two Things the README Skips
Setup really is one command, followed by a browser sign-in.
npm i -g @deeplake/hivemind
hivemind install --only claude
hivemind login
Two things the README does not advertise. First, it wants Node 22, and I was on 20.19.5. It installed and ran anyway with an engine warning, but that is an unsupported combination you should know about before you build on it. Second, on the very first write the memory table did not exist yet, and the create-table call hit a duplicate-key race on pg_type_typname_nsp_index. It retried and healed itself within seconds, then logged capture ok to cloud. No data was lost, but a cold start that self-heals is worth watching.
Nineteen Skills, Mined From My Own Sessions in Two Minutes
This is the part that sells the product. I ran the miner against my own Claude Code history, and it produced nineteen named skills, each with real provenance in the frontmatter and cross-references to the others.
Nineteen skills mined from my own sessions, each carrying source_sessions provenance.
name: detached-remote-ml-jobs
source_sessions:
- e2f3cd85-54b8-45bf-87e4-9952f50eb6ac
created_by_agent: claude_code
created_at: 2026-07-14T06:28:40.506Z
These were not stubs. staged-ablation-cost-optimization captured how I pilot cheap runs before committing GPU budget. debug-silent-container-failures captured my exact habit of distrusting a green job status and reading the real container logs. detached-remote-ml-jobs even linked to idempotent-ml-pipeline-stages by name. The tool read how I work and wrote it down more clearly than I would have.
The Part That Impressed Me: It Refused to Learn What My Docs Already Covered
I asked it to mine the sessions where I wired a bot into my Telegram notification fabric. It returned zero candidates, and it told me why.
[96ba8816] 0 skill candidate(s) ... bot-tg-fabric wiring workflow
is already documented in CLAUDE.md and largely repo-specific. No
repeatable-mistake pattern detected.
That restraint is the whole game. A memory layer that codifies everything becomes noise you have to wade through. This gate only keeps non-obvious, repeatable gotchas that are not already written down. On a well-documented repository it declines, correctly, and your skill library stays dense with signal.
The Same Bug, Two Agents: One Had the Skill, One Did Not
Claims are cheap, so I ran a controlled test. Same prompt, a silent Azure container job that reports success but does nothing. One fresh agent had the codified debug-silent-container-failures skill in scope, one did not.
Same prompt, same model. The codified skill changed the diagnosis.
With the skill, the agent named it and led with the exact root cause: a try/except block that swallows the exception and exits zero, so the orchestrator reports success. Without the skill, it gave a generic debugging checklist and reached for Log Analytics wiring first, never surfacing that root cause. A skill mined from my own past session made a fresh agent measurably smarter on a matching problem. That is the propagation promise, working.
Recall Was Broken on My Machine, So I Traced It and Fixed It
Out of the box, memory recall did nothing for me. Every backfill of session summaries failed, so there was nothing to recall, and every recall event logged hit=none. This is the kind of thing a puff piece skips. I went into the bundle source instead.
The wiki-summary worker shells out to claude -p with Haiku to summarize each session, on a fixed 120-second per-session timeout with a concurrency of four. My machine has session transcripts ranging from 5 to 18 megabytes. A Haiku summary of even a small session took about 91 seconds on its own, so running four in parallel with an 18 MB transcript in the batch pushes everything past 120 seconds, and it gets killed. The pipeline was not broken. It was starved.
I fixed it by staging summaries for the sessions I cared about outside the batch path, then flushing them to the cloud table. After that, recall fired.
{"event":"injected","mode":"semantic","score":0.68}
Semantic recall, injected into context, with a real relevance score. The embeddings daemon spawned on demand, and it worked.
Where Recall Pays Off, and Where It Quietly Costs You
Here is the honest split, because it matters. I ran a cache-controlled A/B: the same tasks, memory on versus off, with turns as the metric that caching cannot fake.
The result I am not hiding: on short, documented tasks, recall cost more than it saved.
On short, well-documented coding tasks, proactive recall made things worse: roughly 75 percent more turns and 23 percent more cost on average. I ran three wiring tasks. With memory off, each took 4 turns. With memory on, one actually improved to 3, one rose to 7, and one ballooned to 11 as the agent tried to force an injected pattern that did not fit. That is an average of 4 turns going to 7. It pulled in tangentially related memory that sent the agent exploring. This is the wrong workload for it, and the fix is to raise the relevance threshold or turn proactive recall off for short asks.
On the workload it is built for, it shines. I asked a fresh agent, with no local files in front of it, how I had fixed a login-detection bug in an earlier session. It pulled the exact verify_login logic, the session ID, and the commit straight from memory. That is real cross-session recall, and you cannot get it any other way. Use it for memory-heavy work, not for tasks your documentation already answers.
The Sleeper Feature Nobody Markets: A Live Code Graph
Hivemind also builds an AST graph of your repository from the same traces. On my monorepo that came to 2449 nodes and 4333 edges across 237 files, queryable as a filesystem. It correctly surfaced my deliberate vendored-copy pattern, nine identical copies of the same notification client, and mapped call and import edges with line numbers. As a fast index to find the files that matter before you open them, it is genuinely useful, and it honestly declares what it cannot resolve.
The graph caught all nine vendored copies of my notification client.
What to Watch Before You Turn This On
The biggest caveat is privacy. Capture is org-wide across every project, not just the one you are working in. My shared memory accumulated summaries of unrelated, sensitive work, readable by anyone I add to the workspace and surfaceable by recall into unrelated sessions. The summaries themselves are high fidelity, with exact function logic and commit SHAs, and Hivemind does redact some secrets such as image tags, but it left cloud subscription and workspace IDs in the clear. Use a per-project workspace, and review before you add a teammate.
Final Thoughts
Hivemind is two products wearing one name. The codification engine, which turns your real sessions into reusable skills that provably sharpen a fresh agent, is excellent and under-marketed. The proactive recall is powerful on memory-heavy work and a tax on short, documented tasks, so treat it as a setting you tune, not a default you trust everywhere. If you run coding agents across a team, the skill layer alone is worth the install this week. Just scope your workspaces first, and remember that a green status never meant your job did any work.
Resources & References
- Hivemind on GitHub (activeloopai/hivemind)
- Hivemind product page (deeplake.ai)
- Deep Lake documentation
- LoCoMo long-context memory benchmark (arXiv)
- Hivemind on Y Combinator Launch
Originally published on Medium.
Top comments (0)