Hivemind, answered plainly.

What is Hivemind?

Hivemind is a self-hosted, offline server that gives a fleet of AI coding agents one shared episodic memory. When any agent solves a problem, the finding is captured once and every other agent can recall it — so the fleet stops re-solving the same problem twice. Recall stays silent rather than guess, memories are re-verified against the code they describe, and unused ones fade on their own.

It runs as a single container on your own hardware and connects to agents over the Model Context Protocol (MCP). For the full picture, read how Hivemind works.

How do I know a memory is still true after the code changes?

Hivemind checks, mechanically. A memory about code carries an anchor (file:symbol); the companion hive-edge CLI mints a deterministic AST fingerprint of that code at capture and re-verifies it against your current tree at recall. A breaking change — the symbol removed, or its call shape changed incompatibly — flags the hit stale; a compatible widening, like a new optional parameter, leaves it current; and a comparison the checker can’t decide comes back unverifiable rather than a guess either way. A radius advisory also fires when code around the anchor moved without changing the anchor itself. No LLM judges freshness, and unused memories expire on a TTL regardless.

The guide explains the mechanism in full.

How does the recall gate work?

Every recall is scored for how well it matches the question, and Hivemind only serves matches at or above an absolute serve floor called τ (tau, default 0.70). If the best match falls below the floor, the gate abstains and returns nothing rather than lower the bar to produce an answer.

The gate also fails closed: an empty result or any internal error resolves to abstention, never to a served guess. You can see it live — drag the gate on the homepage.

How does a memory earn trust, and what stops a poisoned one from spreading?

Every memory moves through four states — quarantined → provisional → established → retired. A capture lands quarantined and is served to no one. It becomes provisional — served, always labeled as such — only after independent demand: repeated matching recall misses, including at least one agent other than the writer, so no agent can manufacture both supply and demand. It becomes established, served as settled fact, only when a human signs off via hive_write; there is no mechanical path to established.

That is what stops a wrong or planted memory from spreading — it can never reach the fleet on its own say-so. On the project’s adversarial trust bench, this lifecycle took the poisoned-memory serve rate from 0.92 to 0.0. Retirement is a first-class state, not a delete: a retired memory is re-checked at serve time and never served again, but it stays in the audit ledger with its full history. The guide has the stage-by-stage table.

Will the store bloat over time, and does keeping it tidy cost tokens?

No on both counts — by design it sheds, for free. Unused quarantined memories expire in 14 days (default) and unused provisional ones in 45; only human-established memories are permanent. Hivemind treats a bigger store as a worse store — dilution and staleness degrade every recall — so expiry of unused memory is a feature doing real work, not data loss. The whole store stays one lean SQLite file.

And Hivemind runs no autonomous maintenance LLM: no compression jobs, no summarizer on a stop hook, no per-turn classification. The automated hygiene — decay, demand-based promotion, serve-time dedup, conflict detection — is deterministic and costs nothing. The curation on top is deliberate, not a background job: agents store, supersede, tag, and prune through gated tools, and a human curates the established tier — a weekly hive_health read shows where to spend that effort. Upkeep is hybrid: mechanical hygiene underneath, deliberate curation on top. Why the store stays lean →

What are the eight tools, and do they break prompt caching?

Hivemind exposes eight MCP tools — not fifty. Five are open to any agent: hive_recall (recall, or abstain), hive_capture (log a finding; lands quarantined), hive_flag (record a conflict), hive_outcome (report what helped or hurt), and hive_health (memory health, trends, gaps, conflicts). Three are approver-only, reserved for a human: hive_write (approve as established), hive_supersede (replace an answer), and hive_prune (retire an error).

They don’t touch your prompt cache. The usage contract is served once at connect — static and versioned — and recall is pull-based: an agent asks when it needs something, and only the memories that clear the gate enter context. Nothing rewrites the system prompt per turn, so caching stays intact, and eight tools keep the tool list small too. The guide lists what each one does.

How does Hivemind coordinate multiple agents?

Through stigmergy: instead of messaging each other, agents leave durable traces in the shared memory, and later work builds on those traces automatically. It is how an ant colony finds a path without any ant giving orders.

No agent has to be online at the same time as another, and there is no message bus to run. The memory itself is the coordination layer. The guide goes deeper.

Can memories leak between projects or agents?

No. Hivemind is single-tenant per project by architecture: one server, one codebase, one store — another project’s memory is never in the same store to begin with.

Identity is per-agent-session, minted by the server rather than inferred from a directory name, and remote access is bearer-gated per seat with revocation in one command.

How does Hivemind keep secrets out of memory?

Every memory is scanned for stray API keys and passwords before it is saved — on by default. Secrets are caught before they are stored, not after, so a careless capture does not quietly persist a credential into the shared store.

Findings log the rule that fired — never the matched bytes.

What happens to my memory on a restart, and can I back it up?

Your fleet’s entire shared memory is one SQLite file, and writes are atomic — so a restart loses nothing. Persistence is the default: the containerized store lives at /data/shared.db in a Docker volume out of the box, and copying .env.example to .env just makes that config explicit. Only a deliberate :memory: store is ephemeral, and Hivemind doesn’t hide it — that boot warns loudly and hive_health reports store_ephemeral.

Back it up like any file — hive backup takes atomic snapshots and hive restore rolls back — and upgrades never touch your data without telling you. The file carries its full history too: retired memories ride along in the audit ledger, so a backup preserves provenance, not just the current truth.

Is Hivemind self-hosted and offline — and can remote teammates connect?

It runs entirely on your own hardware in one container, and it is offline by build rather than configuration: the embedding model is baked into the image, so there are no runtime downloads and nothing phones home. It behaves the same on a laptop with no network as on a shared box, and makes no outbound calls — your data only moves if you move it.

Working solo, the server is reachable only on your own machine, tokenless. Bring in remote teammates and every connection is token-gated over a tunnel — nothing else about your host is exposed, and you can revoke a seat’s access at any time. The token authenticates the connection; it is never an identity.

Which AI coding agents are compatible with Hivemind?

Any agent that speaks the Model Context Protocol (MCP), including Claude and Cursor. Hivemind is a standard MCP server at http://localhost:8765/mcp, so there is no Hivemind-specific SDK to adopt — if your agent can add an MCP server, it can recall from and contribute to the shared memory.

How do I install Hivemind?

Clone the repository, install the CLI with pip install -e ., copy .env.example to .env to set your store config, and run hive up to build and start the container. When it reports healthy, run hive connect to print the line that registers an agent against http://localhost:8765/mcp.

Step-by-step, with the terminal output, is in the self-hosting section of the guide.

Is Hivemind free and open-source, and under what license?

Yes — Hivemind is released under the Apache-2.0 license (© 2026 Hivemind) and free to use. That permits self-hosting, modification, and commercial use under the standard Apache-2.0 terms.

The license and full source live on GitHub in the Hivemind-OSS organization, at github.com/Hivemind-OSS/Hivemind.