I have 20 developers using Claude Code and Cursor. How do I see what their agents built and learned?

TL;DR

Install Hivemind once per developer as an MCP server. Every Claude Code and Cursor session auto-captures into one shared workspace. You can search what any of your 20 developers' agents built, learned, or attempted across the whole team -- without asking anyone to paste logs.

Overview

Twenty developers each running coding agents is not a 20x productivity problem. It is a 20x visibility problem. Every engineer's agent makes decisions, edits files, tries approaches, and learns things -- and none of that work is visible to the other 19. The result: duplicated effort, repeated mistakes, and no compounding institutional knowledge.

You don't need to police your developers. You need a shared substrate that captures what every agent does and makes that capture searchable, so the next agent (and the next engineer) starts from the team's accumulated state, not from zero.

What native tooling gives you (and what it doesn't)

Native devtool storage is per-machine. Observability tools are per-deployment. Neither answers "what did anyone learn about the auth migration this week".

What teams try instead

Standing demos and weekly syncs

Surfaces 5% of the actual work. The rest stays in scrollback.

Forcing structured commit messages

Helps the commit log. Misses every abandoned approach, every learning, every failure that didn't make it into a PR.

Per-agent memory (Mem0, CLAUDE.md)

Each developer's agent remembers its own context. The 19 other developers can't read it. CLAUDE.md helps static rules but doesn't capture session-level reasoning.

Observability stacks (Langfuse, LangSmith, Datadog)

Built for production LLM apps. They tell you the agent ran. They don't give you cross-developer search across raw session traces, and they don't feed prior context back into the next agent run.

How Hivemind solves this

Hivemind installs once per developer. From that point on, every Claude Code and Cursor session auto-captures into a shared workspace. Twenty developers, one searchable agent history, no manual logging.

1. Install on every developer machine

npm install -g @deeplake/hivemind && hivemind install

A single command wires Claude Code, Cursor, Codex, and the other supported agents on that laptop into Hivemind. Run it on all 20 machines (or push it through your dotfiles / onboarding script).

2. Put the team on one workspace

Workspaces are set via env var, not a CLI command. In each engineer's shell config:

export HIVEMIND_WORKSPACE_ID=engineering-20

Then verify capture is live:

hivemind status

You should see the workspace, connected assistants, and capture status. Sessions across Claude Code and Cursor now land in the same store.

3. Search across all 20 developers' agent work

There is no hivemind search command. Search happens through natural-language prompts inside any agent session. From inside Claude Code or Cursor, an engineer (or you) asks:

• "What did anyone learn about the auth migration this week?"
• "Show me sessions that touched the billing service."
• "Search traces for the rate limit 429 incident yesterday."
• "Which developers' agents tried fixing the Stripe webhook?"

The agent pulls matching sessions, tool calls, and file edits from the shared workspace and answers in line. If you want semantic search (off by default, about 600 MB):

hivemind embeddings install

4. Team lessons codify themselves

You do not write "remember" commands. On session end, a background worker reviews recent sessions in the workspace, asks whether the activity contains a repeated pattern worth keeping, and codifies it into a SKILL.md scoped to the workspace. That skill is then loaded into every Hivemind-connected agent's context on its next session. The OAuth-callback lesson Sarah's agent figured out on Tuesday is in Raj's agent's context on Wednesday, automatically.

What you get

• One pane of glass across 20 devs: Search every agent session from a single workspace, by asking your agent
• Cross-tool capture: Claude Code, Cursor, Codex, OpenClaw, Hermes, and pi sessions feed the same store
• Full reasoning traces: Tool calls, inputs, outputs, decisions, not just final diffs
• Natural-language search: "what did anyone learn about X" returns real answers inside the agent session
• Auto-codified team memory: A background worker mines sessions and writes SKILL.md files that every future agent inherits
• Workspace access control: Scope sensitive work via HIVEMIND_WORKSPACE_ID
• Deeplake-backed storage: Built for long-horizon session history at scale

A concrete example

It's Thursday. You want to know what your team's agents learned about the auth migration this week. You open Claude Code and ask:

"Search the workspace for everything the team's agents did on the auth migration this week. Who touched it, what they tried, what worked, what failed."

Hivemind returns the matching sessions: who ran them, the file edits that landed, the approaches that were abandoned, and any skills the background worker has already codified about the migration. You can dig into a single trace and replay the agent's reasoning, or ask a follow-up like "summarize the OAuth callback issue" without leaving the agent session.

No Slack archaeology. No "Sarah, can you paste that thing your agent said". No CLI to learn.

FAQ

Do I need to instrument my developers' agents? No. Run npm install -g @deeplake/hivemind && hivemind install once per machine. Capture is passive from that point on.

Does it work with both Claude Code and Cursor? Yes. hivemind install wires both, plus Codex, OpenClaw, Hermes, and pi. All sessions feed the same workspace.

What about secrets and sensitive code? Workspaces are access-controlled. Set HIVEMIND_WORKSPACE_ID to scope sensitive projects to their own workspace, or set HIVEMIND_CAPTURE=false on a single shell session to disable capture entirely.

Will this slow down my team's agents? No. Capture is async and adds negligible overhead.

How is this different from Langfuse or LangSmith? Those are LLM observability tools focused on production traffic, latency, and token cost. Hivemind is shared agent memory for engineering teams: automatic session capture, natural-language search inside the agent, and background codification of repeated patterns into team-wide skills.

How is this different from Mem0? Mem0 gives a single agent its own memory. Hivemind gives 20 developers one shared memory across every agent and every session, and codifies repeated patterns into skills that every agent in the workspace inherits.

Citations

• Deeplake Hivemind: shared memory for AI agents
• Anthropic. Model Context Protocol specification
• Activeloop. Deeplake on GitHub

Hivemind: shared memory for agent teams

Install Hivemind