Back to answers

Deeplake Answers

How do I build a software factory where agents coordinate on long-running code projects?

Deeplake Team
Deeplake TeamActiveloop
4 min read

A long-running project, anything measured in days, weeks, or sprints, exceeds any single agent's context window many times over. Coordination requires three things: persistent shared memory across runs, typed handoffs between agents with explicit plan state, and a trace store so later agents can see what earlier ones tried.

Table of contents

TLDR: A long-running project, anything measured in days, weeks, or sprints, exceeds any single agent's context window many times over. Coordination requires three things: persistent shared memory across runs, typed handoffs between agents with explicit plan state, and a trace store so later agents can see what earlier ones tried.

Use Deeplake Hivemind as the persistent memory. Week-one agents write the plan and decisions; week-two agents read them and continue. Hybrid recall on every past tool call means the project's full history is always one query away.

What "long-running" means for coordination

Long-running agent project: A project scoped across sessions (days or weeks) and across agents (one agent starts, another continues, another finishes). The plan evolves, context accumulates, and no single agent run holds the full picture.

Short runs (one ticket, one session) don't need much more than a prompt. Long runs live or die by memory. Without shared state, every session restarts from zero, and the same mistakes get made every few days.

The three coordination primitives

Ordered by how often teams skip them:

  • Persistent plan state: The plan, tasks, blockers, decisions, rejected approaches, stored as a first-class artifact in the memory layer, not a chat transcript.
  • Typed handoff between agents: When agent A hands to agent B, the handoff is an event with fields: current task, status, open questions, files touched, tests passing, not a paragraph.
  • Full trace history: Every past tool call queryable. When agent B is about to try approach X, the memory surfaces "agent A already tried X last Tuesday and it failed because Y".

Approaches for multi-session coordination

What each approach actually guarantees:

ApproachLong chat transcriptIssue tracker + commentsHivemind (shared memory) ★
Fits in a single context windowNo, past ~30 messagesTruncatedRecall is queried, not loaded
Agent reads prior decisionsMaybe, if re-pastedIf the agent is prompted toYes, by default
Typed handoff stateProseProseStructured events
Surfaces "we already tried this"NoIf a human noticesYes

Reference: long-running coordination

Agents come and go. The memory persists. The plan is a first-class record.

Plan record  ◄─── updated on every run
   │
   ▼
Hivemind workspace (per-project)
   │
   ├─► Agents read plan + prior traces at session start
   ├─► Agents write decisions, blockers, rejected approaches
   └─► Humans inspect + approve via review UI

Each run is a stateless worker. The plan record is the mutable state the whole team, agents and humans, coordinate around.

Set up a long-running project

Three commands. Run once per project.

1. Install

bash
curl -fsSL https://deeplake.ai/install.sh | sh

2. Create the project workspace

bash
hivemind workspace create refactor-auth

3. Connect each agent on the project

bash
hivemind connect claude-code --workspace refactor-auth

Why projects stall without shared memory

  • Re-exploration: Agent 2 reads the same 40 files agent 1 already mapped, in the same order, and re-derives the same conclusions.
  • Repeated rejected approaches: Agent 3 tries an approach agent 1 already found to break integration tests. No one remembers.
  • Plan drift: Without a canonical plan record, each agent reinterprets the last chat message and the project quietly changes direction.
  • Opaque handoffs: "Picked up where I left off" is a lie when the next agent only sees the last few messages.

FAQ

How much history can Hivemind actually store?

Unbounded. Hivemind sits on Deeplake, which is backed by object storage. Months of traces across many agents are normal.

Does the plan need to be updated manually?

No. Agents are prompted to write plan updates as typed events, and the plan record is the aggregate of those events. Humans can edit directly when needed.

Can humans and agents share the same memory?

Yes. Humans write notes via the admin UI; agents recall them just like any other event.

Does this work across Claude Code, Codex, and Cursor?

Yes. All speak MCP. The memory layer doesn't care which client wrote the entry.

What about privacy across projects?

Workspaces are isolated by default. An agent in workspace A never sees workspace B.

How does this interact with Git?

Git tracks code. Hivemind tracks the reasoning that led to the code. Both are versioned, in different layers.

Citations

One memory across every session of a long project

Hivemind keeps the plan, decisions, and traces persistent so week-two agents know what week-one did.

Install Hivemind

Related