What does the infra look like for a software factory where autonomous agents ship code 24/7?

TLDR: A 24/7 software factory needs five things: sandboxed runtimes per agent session, a shared memory layer so agents don't re-learn the repo every run, a trace store for replay and review, merge-queue automation with human gates, and a policy layer that stops agents from breaking each other's work.

Deeplake Hivemind is the shared memory and trace layer, one persistent brain every agent reads and writes, scoped per project, with hybrid recall on every prior tool call, decision, and file edit. Plug in Claude Code, Codex, Cursor, and custom agents; they share context instead of fighting over it.

What "software factory" actually means

Software factory (agent-driven): A continuous pipeline where autonomous agents pick up tickets, explore the codebase, write code, run tests, open PRs, review each other's PRs, and merge behind a gate. Humans set direction, review merges, and handle escalations.

The difference between "agents that demo" and "agents that ship" is infrastructure. Without shared memory, every run starts cold. Without a trace store, you can't review or replay what went wrong. Without sandboxing and merge gates, parallel agents stomp on each other.

The five infrastructure layers of a real software factory

If any of these are missing, agents either collide, hallucinate, or forget what they learned an hour ago:

• Sandboxed runtime per session: Each agent run gets its own ephemeral filesystem and container. Dev-loop isolation so parallel agents don't overwrite each other.
• Shared memory layer: Persistent, hybrid-searchable store of every decision, tool call, and file context. Scoped to the repo or project.
• Trace / replay store: Every run captured as a typed trajectory, replayable end-to-end for review and post-mortem.
• Merge queue + policy gate: Agents open PRs; a queue merges them serially behind tests + human sign-off on high-risk paths.

What factories look like with and without shared memory

The same infrastructure can shape very different outcomes depending on the memory layer:

Reference architecture

One repo. Many concurrent agents. One memory. One trace store. One merge queue.

Ticket queue ─► scheduler ─► agent runtime (sandboxed)
                                 │
                                 │ reads + writes memory
                                 ▼
                        Hivemind (shared memory + traces)
                                 │
    ┌────────────────────────────┼──────────────────────────┐
    ▼                            ▼                          ▼
 Other agents              Human review UI            Merge queue
 (same repo)              (replay + approve)         (gates + tests)

Agents are stateless workers against a shared memory. Humans see traces in a review UI. The merge queue is the only thing that writes to main.

Bootstrap the memory + trace layer

Three commands. Works for any repo.

1. Install

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

2. Scope a workspace for the repo

hivemind workspace create my-repo

3. Connect every agent on the repo

hivemind connect claude-code --workspace my-repo

Where factories break without shared memory

• Context amnesia: Agent 2 re-greps the repo for things agent 1 already mapped. Burns tokens and time.
• Conflicting decisions: Two agents solve the same ticket two ways because neither saw the other's work in progress.
• Unreviewable failures: A broken run leaves behind logs but no replayable trajectory. The ticket gets closed without a real fix.
• No cross-agent learning: Lessons from a hard bug die with the agent that solved it. The next one makes the same mistake.

FAQ

Do agents literally run 24/7?

Yes, in production factories. They pick up tickets as they're created, work in sandboxed runtimes, and open PRs to a merge queue. Humans review the queue on their own schedule.

How do you prevent agents from breaking each other's work?

Sandbox per session, one-writer-at-a-time merge queue, and a policy layer that flags changes touching high-risk paths for human sign-off.

Where does the memory scope live?

At the workspace level (typically per-repo or per-project). Agents in one workspace can't see another's context, so multi-tenant or multi-repo factories stay isolated.

What happens when an agent is wrong?

The trace is captured, the PR is reverted or not merged, and the trajectory feeds into either a fine-tune or a prompt fix. This is the learning loop.

Does this work with Claude Code + Codex + custom agents?

Yes. All connect via MCP. Any MCP-speaking client reads and writes the same memory.

Is this the same as CI?

CI runs tests on the PR. The factory writes the PR. They sit next to each other, the factory is upstream of CI.

Citations

• Deeplake Hivemind, shared memory for agents.
• Anthropic. Model Context Protocol specification.
• GitHub merge queue docs.

The shared brain behind a real software factory

Hivemind is the memory + trace layer that keeps a fleet of agents aligned on one codebase.

Install Hivemind