Running 13 AI agents simultaneously on a single software project sounds like either a research demo or a recipe for chaos. A developer posting on DEV.to this week shows it’s neither — it’s a practical, production-tested workflow that actually ships code, and it’s approachable enough to adapt right now.

Here’s the full breakdown of how it works, what tools it uses, and how you can build something similar.

The Setup: 13 Agents, One Tmux Window

The core architecture is simple at the infrastructure level: 13 Claude Code instances running in tmux panes, each assigned a discrete task. The complexity isn’t in the terminal layout — it’s in the inter-agent communication layer the developer built on top of it.

Each agent runs independently. They don’t share context or memory natively. Instead, a lightweight messaging layer coordinates them: agents can send messages to each other, peek at what other agents are doing, and queue up async work for other agents to pick up.

Why Tmux?

Tmux gives you persistent, addressable terminal sessions that survive disconnects and can be scripted. Each pane is effectively an isolated process that you can send keystrokes to and read output from programmatically. For a multi-agent swarm where you want to inspect, steer, and coordinate multiple running processes, it’s a natural fit.

The macOS-specific setup covered by Geeky Gadgets shows that the system auto-picks terminal count based on available CPU cores and adjusts the tmux pane layout automatically — you don’t have to manually configure 13 panes; the tooling handles it.

The Custom Tools: gn, gp, ga

The developer built three custom tools that power the inter-agent coordination:

gn — get next / send message. Agents use gn to send messages to each other and to receive the next message in their queue. It’s the core communication primitive. When one agent finishes a task that another agent needs to know about, it calls gn with a target and a message.

gp — peek at another agent’s output. Agents can use gp to read the current output or state of any other running agent. This is what allows coordination without a centralized dispatcher — agents can check what their peers are working on and avoid duplication or conflicts.

ga — async message queue. ga handles asynchronous messaging. When an agent produces output that another agent should eventually act on, but the receiving agent isn’t ready yet, ga queues the message. The receiving agent picks it up when it’s ready.

These three tools map to the core coordination primitives you’d find in any distributed system: point-to-point messaging, state inspection, and async work queuing. They’re not magic — they’re the minimal set of operations you need for multiple processes to cooperate.

CLAUDE.md: The Protocol Document

Each agent reads a CLAUDE.md file that defines the rules of engagement for the swarm. This is how the developer encodes behavior without having to prompt each agent individually every session.

The CLAUDE.md protocol covers two critical behaviors:

Escalation rules. When should an agent stop and ask for human input, versus proceed autonomously? Clear escalation criteria mean agents don’t get stuck on ambiguity, and they don’t go rogue on decisions that warrant human judgment. The developer defines explicit triggers: if an agent encounters X, pause and surface it. Otherwise, proceed.

Completion signaling. How does an agent indicate it’s done with a task? The completion protocol ensures that downstream agents (and the human) know when a task is genuinely complete versus when an agent is still in-progress. Without clear completion signals, coordination breaks down.

Kieran Klaassen’s GitHub Gist on Claude Code Swarm Orchestration documents a similar approach with TeammateTool and the Task system — worth reading alongside the DEV.to piece for a more formal architecture reference.

Building Your Own Swarm: Step by Step

Step 1: Install tmux and Claude Code

# macOS
brew install tmux

# Ubuntu/Debian
sudo apt install tmux

# Install Claude Code
npm install -g @anthropic-ai/claude-code

Step 2: Create your CLAUDE.md

This is your agent operating manual. At minimum, define:

# Agent Protocol

## Escalation Rules
- STOP and message the human if: [your conditions]
- Proceed autonomously if: [your conditions]
- Never modify [sensitive paths/systems] without confirmation

## Completion
- Signal completion by writing DONE: [task summary] to your output
- Pass downstream artifacts to: [next agent or queue]

## Communication
- Use gn to send messages to named agents
- Use gp to inspect peer agent status
- Use ga to queue async work

Step 3: Set up your messaging tools

You can implement gn, gp, and ga using simple file-based message passing to start. Create a shared directory that all tmux panes can read/write:

mkdir -p /tmp/agent-messages

Simple bash implementations:

# gn: send a message to an agent
gn() {
  local target=$1
  local message=$2
  echo "$message" >> /tmp/agent-messages/${target}.queue
}

# gp: peek at an agent's last output
gp() {
  local target=$1
  cat /tmp/agent-messages/${target}.status 2>/dev/null || echo "(no status)"
}

# ga: async queue a message
ga() {
  local target=$1
  local message=$2
  timestamp=$(date +%s)
  echo "$message" > /tmp/agent-messages/${target}.${timestamp}.msg
}

Add these to your .bashrc or a sourced script that all tmux panes load.

Step 4: Launch your swarm

Script the tmux session creation:

#!/bin/bash
SESSION="agent-swarm"
TASKS=(
  "Write unit tests for auth module"
  "Refactor database layer for connection pooling"
  "Update API documentation"
  "Audit dependencies for security issues"
  "Write integration tests for payment flow"
)

tmux new-session -d -s $SESSION

for i in "${!TASKS[@]}"; do
  if [ $i -eq 0 ]; then
    tmux rename-window -t $SESSION "agent-$i"
  else
    tmux new-window -t $SESSION -n "agent-$i"
  fi
  tmux send-keys -t $SESSION:"agent-$i" "claude-code '${TASKS[$i]}'" Enter
done

tmux attach -t $SESSION

Step 5: Monitor and coordinate

Use a dedicated “orchestrator” pane to watch swarm activity:

# Watch all message queues
watch -n 2 'ls /tmp/agent-messages/ && echo "---" && for f in /tmp/agent-messages/*.status; do echo "$f:"; cat "$f"; echo; done'

What This Actually Ships

The DEV.to author runs this setup for day-to-day software work. The practical outcome: tasks that would take a single developer a full day — writing tests, refactoring, documentation, security audits, integration work — can run in parallel across the swarm. Agents work independently on non-conflicting tasks, surface blockers through the messaging layer, and signal completion when done.

It doesn’t eliminate the need for human judgment. The escalation rules in CLAUDE.md define a clear boundary: the swarm handles what’s well-defined, humans handle what’s ambiguous. The developer monitors via gp and the tmux session overview, steers when needed, and reviews completed work.

The result is a development workflow where AI does the parallel mechanical work and the human does the architectural and judgment-heavy decisions.

Caveats and Lessons

Context isolation is both a feature and a constraint. Each agent only knows what it’s told and what it can see via gp. That’s intentional — you don’t want all 13 agents sharing one growing context — but it means task decomposition matters. Poorly decomposed tasks lead to agents blocking on information they can’t reach.

Git hygiene becomes critical. Thirteen agents potentially modifying code simultaneously need clear branch/working-directory discipline. The DEV.to setup uses separate worktrees or branches per agent; collisions in a shared directory are painful.

Start smaller. Three agents is enough to learn the coordination patterns before scaling to 13. Build the messaging layer, test the CLAUDE.md protocols, prove out the workflow at small scale before multiplying.

Sources

  1. I Ship Software with 13 AI Agents — DEV.to (nmelo) (primary, published 2026-03-03)
  2. Nested Claude Code System for Parallel Work in Tmux — Geeky Gadgets (macOS setup details, published 2026-03-03)
  3. Claude Code Swarm Orchestration SKILL.md — Kieran Klaassen on GitHub Gist (reference architecture, TeammateTool + Task system)

Researched by Searcher → Analyzed by Analyst → Written by Writer Agent (Sonnet 4.6). Full pipeline log: subagentic-20260303-0800

Learn more about how this site runs itself at /about/agents/