u/_ggsa

I've been running 8 AI agents in production for a few months. Each is a Docker container with its own role (CTO, dev, devops, PM, traders, auditor) and its own Telegram bot. They coordinate through a workflow engine and a shared memory layer. Sharing the patterns that survived contact with real work.

The setup

• 8 agents, each a Claude or Codex process inside a container, registers with an orchestrator and pulls work off a queue
• Coordination happens through Temporal workflows, not direct agent-to-agent messages. Every meaningful interaction is a workflow with a defined shape (wrote up the Temporal/durability mechanics separately on r/Temporal — link in comments)
• Shared memory layer (markdown + vector index) so any agent can read what any other agent wrote — not per-agent isolated state

Coordination patterns that worked

Consensus review as a primitive. When one agent finishes a unit of work (a PR, a design spec, a doc update), N other agents review it in parallel through a ConsensusReviewWorkflow. The implementing agent doesn't know it's being reviewed in parallel — it just gets one consolidated feedback message and either ships or revises. Same workflow reused across PR review, design review, and doc review.

One human, many agents, signal gates. Instead of an agent asking the human "should I proceed?" via chat, the workflow blocks on a wait_for_signal for human approval. The human sees a clickable button in a dashboard with full context (PR diff, reviewer verdicts, repo, phase). Removes the "agent waiting in chat" anti-pattern.

Memory as the cross-agent knowledge layer. All 8 agents share one semantic memory store. The PM writes a design spec memory, the dev reads it before implementing. The ops agent writes a runbook, the CTO reads it before delegating. No prompt engineering to "share context" between agents — they just search the same memory.

Orchestrator as router, not coordinator. The orchestrator doesn't decide which agent does what — that's in the workflow definitions. It just provisions containers, routes messages, and tracks heartbeats. Keeps the brain in the workflow layer where it can be inspected and changed without redeploying anything.

What didn't work

• Direct agent-to-agent chat. Tried it early, removed it within a month. Conversations drift, no audit trail, no cancellation primitive. Every cross-agent interaction now goes through a workflow.
• Per-agent isolated memory. Each agent having its own context turned out to be a coordination tax — same facts re-derived in five places. Shared memory + scoped reads is better.
• Long-running "supervisor" agents that babysit other agents. Workflows do this better and survive restarts.

Demo + code in comments.