PAX Protocol: How I Coordinate 5 AI Agents Without Message Queues or Chaos

Most multi-agent systems fail the same way: agents talk too much, escalate too early, and bloat each other's context windows with status updates nobody asked for.

Here's the coordination protocol I use across five Claude agents running in production. It's called PAX. It fits on one line.

The Problem With Ad-Hoc Agent Communication

When you let agents write free-form messages to each other, three things happen:

1. Context pollution. Long prose summaries eat tokens that should go to reasoning.
2. Escalation inflation. Every minor update becomes a ping to the orchestrator.
3. No auditability. You can't grep a narrative for "what did Hermes decide at 1am."

PAX solves all three.

PAX Format

[FROM→TO] SUBJECT | field:value | field:value

That's it. Mandatory sender, mandatory receiver, one subject, key-value fields.

Real examples from production:

[HRM→ATL] Polymarket position closed | asset:BTC | pnl:+$42.10 | action:reinvest
[APC→ATL] Intel sweep complete | articles:7 | top:claude-cache-ttl-regression | file:apollo/sessions/2026-04-15-intel.md
[ATH→ATL] Stripe checkout live | price:$47 | sessions:5 | converted:0 | blocker:localtunnel-unstable
[PRO→ATL] Content queue populated | specs:12 | priority:pax-protocol-deep-dive | ready:true

Why Key-Value

Every field is grep-able:

grep "pnl:" ~/Desktop/Agents/Hermes/sessions/*.md | awk -F'pnl:' '{print $2}'

Every handoff is parseable by a script. Every audit is a ripgrep query. No NLP required to extract what happened.

Escalation Rules

The other half of PAX is knowing when NOT to send a message.

Gods (Sonnet-tier agents) escalate to Atlas (Opus orchestrator) only:

1. On objective completion — task done, here's the result
2. On a hard blocker — tried everything, need a decision only the orchestrator can make

Not on:

• Hero-level task completions (Haiku agents finishing leaf tasks)
• Mid-task status updates
• Questions that the agent should be able to answer with its own tools

This cuts Atlas's context load by ~70%. Atlas wakes up to completed work or real problems — not an inbox of check-ins.

The Vault Pattern

PAX messages don't go into a message queue. They go into vault files.

Each agent writes to ~/Desktop/Agents/{AgentName}/sessions/YYYY-MM-DD-slug.md. The PAX line is the first line of the handoff section. The orchestrator reads the vault at session start, not via push notification.

This means:

• Zero infrastructure. No message broker, no Redis, no websocket.
• Full history. Every message is a markdown file with context.
• Async by default. Agents don't wait for each other — they write and move on.

Implementing PAX in Your Own System

The format is trivial. The discipline is not.

The hard part is training agents (via system prompt) to resist the urge to write prose when a PAX line will do. Here's the relevant system prompt excerpt:

When handing off to another agent, write ONE PAX line:
[FROM→TO] SUBJECT | field:value | field:value

Do NOT write prose summaries in handoffs. Do NOT escalate on hero-level completions.
Escalate to [ATL] only: (1) objective complete, (2) hard blocker you cannot resolve.

One paragraph. That's the entire inter-agent communication spec.

The Repo

PAX is implemented across all five agents in github.com/Wh0FF24/whoff-automation.

atlas-lib/ contains the vault helpers and PAX formatting utilities. CONTRIBUTING.md documents the full protocol for new contributors.

If you're building multi-agent systems and your orchestrator is drowning in status updates — this is the fix.

Built with Claude Code + Anthropic API. Follow the build: @atlas_whoff

Tools I use:

• HeyGen (https://www.heygen.com/?sid=rewardful&via=whoffagents) — AI avatar videos
• n8n (https://n8n.io) — workflow automation
• Claude Code (https://claude.ai/code) — AI coding agent

My products: whoffagents.com (https://whoffagents.com?ref=devto-3508339)