v0.7.167

hivemind-graph

activeloopai@activeloopai⭐ 1.7k stars· last commit 4d ago· 74 open issues

Query the local code graph (functions, classes, calls, imports) through the Deeplake mount at memory/graph/. Use when the user asks structural questions about the codebase — "what calls X?", "what does Y import?", "where is Z defined?", "what's the architecture / which subsystems exist?", "what's the impact of changing this?". The graph is an AST-derived map of the repo, queried as files (no build needed — it rebuilds automatically).

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

6.9/10
Verified
Oct 12, 2026

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐⭐ 1.7k on GitHubGitHub ↗

Very popular

🟢ProSkills ScoreAI Verified
6.9/10
📍

Not yet listed on ClawHub or SkillsMP

// README

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 (ILIKE lexical 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:

MetricBaselineHivemindImprovement
Cost / 100 QA$8.94$6.6525% cheaper
Tokens / question1,7001,0081.7× fewer
Turns / question8.96.231% fewer

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.

macOS / Linux

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

Windows — in PowerShell:

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

Any platform, via npm — for CI and Dockerfiles, or where policy blocks piping a downloaded script to a shell. Skips the checks the installers do, so Node 22+ and a writable npm prefix are on you:

npm i -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
hivemind claude_cowork install   # Alpha

Check what's wired up:

hivemind status

Supported assistants:

PlatformIntegrationAuto-captureAuto-recall
Claude CodeMarketplace plugin✅✅
OpenClawNative extension✅✅
CodexHooks (hooks.json)✅✅
CursorHooks (hooks.json 1.7+)✅✅
Hermes AgentShell hooks (config.yaml) + skill + MCP server✅✅
piExtension API (pi.on(...)) + skill + AGENTS.md✅✅
Claude Cowork 🅰️MCP server (Claude Desktop)🅰️ Alpha¹✅

🅰️ Claude Cowork is Alpha. Auto-recall (the hivemind_search / read / index tools) is solid. ¹Auto-capture covers Local Agent Mode sessions only — those write a transcript we can tail; plain desktop-chat turns leave no readable local trace and aren't captured (why).

Alternative install paths

If you prefer Claude Code's native plugin marketplace:

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

Auto-updates on each session start. Manual update: /hivemind:update.

openclaw plugins install clawhub:hivemind

Then type /hivemind_login in chat, click the auth link, and sign in.

Commands

CommandDescription
/hivemind_loginSign in via device flow
/hivemind_captureToggle capture on/off
/hivemind_whoamiShow current org and workspace
/hivemind_orgsList organizations
/hivemind_switch_org <name>Switch organization
/hivemind_workspacesList workspaces
/hivemind_switch_workspace <id>Switch workspace
/hivemind_updateCheck for plugin updates

Auto-recall and auto-capture are enabled by default. Data i

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • harnesses/claude-code/skills/hivemind-graph/SKILL.md4.8 KBd17651ace062upstream ↗
    ---
    name: hivemind-graph
    description: Query the local code graph (functions, classes, calls, imports) through the Deeplake mount at memory/graph/. Use when the user asks structural questions about the codebase — "what calls X?", "what does Y import?", "where is Z defined?", "what's the architecture / which subsystems exist?", "what's the impact of changing this?". The graph is an AST-derived map of the repo, queried as files (no build needed — it rebuilds automatically).
    allowed-tools: Read Bash
    ---
    
    # Hivemind Code Graph
    
    A deterministic, AST-derived map of the current repository — every function,
    class, method, interface, type, enum, const, and module, plus the edges between
    them (`calls`, `imports`, `extends`, `implements`, `method_of`). It is queried as
    synthesized files under the Deeplake mount; there are no real files on disk and
    no network call in the read path.
    
    The graph **builds and refreshes automatically** (on Stop / SessionEnd, gated by
    a rate limit + git diff). You never run a build command — just read it.
    
    Use it as a fast **INDEX** to locate the few files/symbols that matter, then open
    them with `Read` to answer. It is not a substitute for the source.
    
    ## When to use this skill
    
    Activate when the user asks a *structural / relational* question about the code:
    
    - "What calls `pushSnapshot`?" / "Who uses this function?"
    - "What does `deeplake-pull.ts` import?" / "What depends on X?"
    - "Where is `GraphSnapshot` defined?" / "Find the function that handles Y."
    - "What are the main subsystems / the architecture here?"
    - "If I change this signature, what's affected?" → use `impact/<symbol>` (transitive blast radius)
    
    ## When NOT to use this skill
    
    - Reading the **body** of a symbol you already located → use `Read` on the real
      source file. The graph gives location + relationships, not full source.
    - Code that isn't **committed/built** yet — the graph can lag uncommitted edits.
      If a file's mtime is newer than the build timestamp, read the live source.
    - Languages outside **TypeScript, JavaScript, and Python** (Go, Rust, …) — the
      extractor covers those three, with cross-file `calls`/`imports` resolved for
      named imports. For anything else, fall back to grep/read.
    
    ## Path cheat sheet
    
    ```bash
    cat ~/.deeplake/memory/graph/index.md
    #   Overview: node/edge counts, kind breakdown, top files by node count.
    
    cat ~/.deeplake/memory/graph/query/<pattern>   # START HERE (the 2-in-1)
    #   Search + expand the top matches with their 1-hop neighbors (callers,
    #   callees, imports, heritage). Multi-token AND: query/<a>+<b>.
    
    cat ~/.deeplake/memory/graph/find/<pattern>
    #   Case-insensitive substring search on node id + label (max 50 hits).
    #   Prints numbered handles [1] [2] ... saved for this worktree.
    
    cat ~/.deeplake/memory/graph/show/<handle-or-pattern>
    #   <handle>: a digit from a prior find/ (e.g. 3).
    #   <pattern>: a substring → unique node detail, or a candidate list.
    #   Output: the node + its 1-hop neighbors grouped by edge relation.
    
    cat ~/.deeplake/memory/graph/neighborhood/<file>
    #   Every symbol in a file + its cross-file neighbors (callers/callees/imports).
    
    cat ~/.deeplake/memory/graph/impact/<pattern>
    #   Transitive dependents — the blast radius of changing a symbol.
    
    cat ~/.deeplake/memory/graph/path/<from>/<to>
    #   Shortest dependency path between two symbol patterns (trace a flow across files).
    
    cat ~/.deeplake/memory/graph/layers      # architectural layers / subsystems
    cat ~/.deeplake/memory/graph/tour        # deterministic guided walkthrough
    ```
    
    ## Workflow
    
    1. Broad? Start at `index.md` to see subsystems and the biggest files.
    2. Looking for a symbol? `find/<name>` (or `query/<name>`) → pick the handle.
    3. Want relationships? `show/<handle>` / `neighborhood/<file>` → callers/callees, imports.
    4. Tracing a flow? `path/<from>/<to>`. Change impact? `impact/<symbol>`.
    5. Need the actual code? Take the `source_file:line` and `Read` it — don't answer from the graph alone.
    
    ## Anti-patterns (read these)
    
    - **"Incoming (0)" does NOT mean dead code.** Cross-file `calls` are resolved for
      *named imports* (TS/JS/Python), but **instance-method dispatch** (`obj.method()`),
      dynamic calls, and nested/inner functions are NOT — a zero-incoming symbol may
      still be reached via one of those. Confirm in the source before calling it unused.
    - **The graph can be stale.** It rebuilds at most once per rate-limit window. The
      SessionStart inject prints the build age; if it's old or you've just edited a
      file, prefer the live source for that file.
    - **Don't try to build it.** There is no user-facing build step in normal use;
      the hooks handle it. Just read the mount.
    - **`find/` is lexical, not semantic.** It matches substrings, not meaning —
      `find/auth` won't surface `login`/`credentials` unless those strings appear in
      the id/label. Try multiple keywords if the first misses.
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/activeloopai-hivemind-harnesses-claude-code-skills-hivemind-graph.md

// REPO STATS

1.7k stars
74 open issues
Last commit: 4d ago