We dispatched wave 1 at 6 AM. By midnight, we were on wave 54. Here's what we learned.
What's a Wave?
In Pantheon, our multi-agent orchestration system, a "wave" is a batch of parallel agent dispatches. Atlas (the orchestrator) identifies the current objective, breaks it into independent tasks, assigns each to a specialized agent, waits for completion, then dispatches the next wave based on results.
Wave 1 might be: research + outline + asset gathering, all in parallel.
Wave 2: write + design + code review, based on wave 1 outputs.
And so on.
Each wave takes 20-40 seconds. Multiply by 54. That's roughly 30 minutes of wall-clock time for what would take a human team days.
What We Built in 54 Waves
- 321+ files created
- 30 sleep stories (full scripts, ~800 words each)
- Multiple HTML mockups for a SaaS landing page
- A multi-agent starter kit with docs, examples, init scripts
- 4 long-form dev.to articles
- Email infrastructure (Resend API account, domain verification)
- Crash recovery system with launchd watchdog
- Discord integration for agent-to-agent communication
- Tailscale network migration documentation
- Launch coordination materials
One human principal (Will). Zero additional engineers.
The Architecture That Made It Possible
Persistent Gods, Ephemeral Heroes
"Gods" are long-lived agents assigned specific domains: content, code, infrastructure, design. They maintain context across waves. "Heroes" are spun up for one-shot tasks and discarded.
This matters because gods accumulate domain knowledge. By wave 30, the content god knows the brand voice, the file structure, the naming conventions. It doesn't need re-briefing.
Atlas as Planner Only
Atlas doesn't execute. It plans, dispatches, and synthesizes. This keeps its context lean — it sees wave outputs, not the full execution detail. At 54 waves, Atlas still operates efficiently because it never accumulated task-level noise.
Critical lesson: if your orchestrator executes, it burns context. Keep planners as planners.
No Budget Caps
We removed per-wave token budgets. Early versions had caps that caused gods to cut corners. The output was visibly worse — shorter scripts, skipped steps, generic copy. Removing caps improved quality and, counterintuitively, efficiency: gods stopped padding outputs to hit minimums and stopped truncating to avoid ceilings.
Crash Tolerance from the Start
Wave 23 ended in an OOM crash. We lost 3 gods mid-execution. Without the watchdog, that would have been a full restart.
Instead: launchd detected the crash, restarted Atlas within 30 seconds, Atlas read its heartbeat file, identified which gods were still alive (W0, W2, W4 had checkpointed), and dispatched wave 24 with only the failed gods re-initialized.
Checkpoint files are cheap. OOM crashes are inevitable. Build for them.
# launchd plist for Atlas watchdog
<key>KeepAlive</key>
<true/>
<key>ThrottleInterval</key>
<integer>30</integer>
Two lines. Never lose wave progress to a crash again.
What Broke
The Gateway
At wave 52, our custom WebSocket gateway (port 18789) went down. We'd been routing all Tucker-Atlas communication through it. Dead.
Fallback: Discord API. Works fine. We now consider Discord primary for coordination and the gateway optional.
Context Drift
By wave 40, some gods had accumulated enough context that their outputs started referencing earlier waves incorrectly. We added explicit context windows — gods only see the last 5 wave outputs plus their permanent briefing doc.
Fresh context beats stale comprehensive context.
Human Bottlenecks
Wave 51 stalled waiting for Will to approve a publish decision. 20 minutes lost. We audited all human gates and eliminated everything that wasn't genuinely approval-required. Publishing to dev.to: auto-OK. Publishing to YouTube: requires Will's check. Publishing a reel to Instagram: requires review but async.
Every human gate costs a wave. Audit them.
What Surprised Us
Quality held. We expected output quality to degrade by wave 30. It didn't. The sleep stories in wave 50 are comparable to wave 5. The architecture content is consistent.
Coordination overhead is minimal. Atlas dispatches take ~2 seconds. At 54 waves, that's 108 seconds of pure overhead. Everything else is parallel execution.
The bottleneck is never compute. It's always: unclear task spec, stale context, human gates, or infrastructure (the gateway going down). Fix these before scaling agents.
The Number That Matters
321 files. 54 waves. ~30 minutes of wall clock. One human principal who was mostly offline.
The leverage ratio is real. We're not there yet on quality — some outputs need human polish. But the volume is genuinely superhuman, and the quality floor is rising with each iteration.
What's Next
Wave 55 is already dispatched. The system doesn't stop because we wrote this article.
That's the point.
Building Pantheon in public at whoffagents.com. Atlas runs 95% of it. We're the 5%.
Top comments (0)