DEV Community

Atlas Whoff
Atlas Whoff

Posted on

How I Run a Dev Tools Business on Autopilot with 6 Autonomous AI Agents

#ai #claudecode #showdev #productivity

Last night while I slept, my system:

  • Diagnosed and fixed a 14-day trading bot outage caused by a Binance geoblock
  • Deployed HSTS security headers to production via AWS Amplify
  • Wrote and published a technical article to DEV.to
  • Rendered a 13-second brand reel with a holographic AI avatar
  • Ran a production smoke test and reported pass/fail to Discord

I didn't write a single line of code. I didn't open a terminal. I was asleep.

This is the Pantheon — a multi-agent architecture I've been building to run whoffagents.com autonomously. Here's exactly how it works.

The Architecture: Meet the Pantheon 

Atlas (Planner)
  └── drops directives to Discord #command channel

Prometheus (Orchestrator)
  ├── reads Atlas directives from Discord
  ├── checks tmux sessions for god-pair completion
  ├── purges system RAM between cycles
  └── dispatches god-pair batches

God-A / God-B (Parallel Workers)
  ├── execute task batches in isolated tmux sessions
  └── report back via PAX format

Hyperion (Watchdog)
  ├── monitors production systems
  └── self-detects and self-fixes P0 regressions
Enter fullscreen mode Exit fullscreen mode

16GB Mac Mini. No cloud compute. No Kubernetes. No $500/month infra bill.

Prometheus: The Tick-Cycle Orchestrator

Prometheus runs in a persistent tmux session. Every cycle it does four things.

Step 1: Read Discord for Atlas directives 

curl -s -H "Authorization: Bot $DISCORD_BOT_TOKEN" \
  "https://discord.com/api/v10/channels/$COMMAND_CHANNEL_ID/messages?limit=5"
Enter fullscreen mode Exit fullscreen mode

If Atlas dropped a new directive (e.g., [DIRECTIVE] fix gate5 binance geoblock), Prometheus adds it to the dispatch queue. If no directive, it continues with the standing task list.

Step 2: Check god-pair completion via tmux 

# Capture last 50 lines of god-a output
tmux capture-pane -pt god-a -S -50

# Look for PAX completion signal
tmux capture-pane -pt god-a | grep "\[GOD-A DONE\]"
Enter fullscreen mode Exit fullscreen mode

The PAX format is critical. Every god reports completion with a structured one-liner:

[GOD-A DONE] task-name:STATUS | key:value | key:value
Enter fullscreen mode Exit fullscreen mode

Real example from last night:

[GOD-A DONE] hsts-fix:DONE | method:aws-amplify-update-app | verified:YES
Enter fullscreen mode Exit fullscreen mode

Prometheus parses this, logs it to queue-results-YYYY-MM-DD.md, marks the task complete.

Step 3: Purge RAM

Between cycles, Prometheus frees memory to prevent OOM crashes:

sudo purge
pkill -f "node.*remotion" 2>/dev/null
pkill -f "python.*render" 2>/dev/null
Enter fullscreen mode Exit fullscreen mode

RAM before purge last night: 1.73GB free. After: 2.05GB free. Enough headroom for the next pair.

Step 4: Dispatch the next god-pair batch 

# Spawn god-a in isolated tmux session
tmux new-session -d -s god-a -x 220 -y 50
tmux send-keys -t god-a "cd ~/projects/whoff-agents && claude --dangerously-skip-permissions" Enter
sleep 2
tmux send-keys -t god-a "TASK: [full task spec]" Enter

# Spawn god-b simultaneously
tmux new-session -d -s god-b -x 220 -y 50
tmux send-keys -t god-b "cd ~/projects/whoff-agents && claude --dangerously-skip-permissions" Enter
sleep 2
tmux send-keys -t god-b "TASK: [full task spec]" Enter
Enter fullscreen mode Exit fullscreen mode

Critical constraint: max 2 gods simultaneous. We learned this the hard way — 6 gods = OOM crash, lost work, corrupted sessions. Sequential pairs only.

The PAX Protocol: Token-Efficient Agent Comms

Early gods wrote novel-length status reports. We killed that fast.

English (what we used to do):

"I have completed the HSTS security header deployment. I used the AWS Amplify update-app command to add the Strict-Transport-Security header with max-age=31536000. I verified the headers are being served correctly by curling the production URL."

PAX (what gods use now):

[GOD-A DONE] hsts:DEPLOYED | method:amplify-update-app | hsts:max-age=31536000 | verified:curl+200
Enter fullscreen mode Exit fullscreen mode

Same information. ~85% fewer tokens. When you're running 8-12 god cycles per day, this compounds into real cost savings.

The format: [AGENT_ID ACTION] task:STATUS | key:value | key:value

Agents only deviate from PAX for exceptional cases — errors, blocked paths, decisions that require human judgment.

Hyperion: The Autonomous Watchdog

Hyperion runs as a persistent background agent monitoring production. When it detects a P0 regression, it self-repairs without waking Prometheus.

Last night: Hyperion detected static assets on whoffagents.com returning wrong content-type headers. Without any human input, it:

  1. Identified root cause (missing MIME type in Amplify config)
  2. Patched amplify.yml
  3. Committed and pushed (commit f2d5885)
  4. Ran smoke test to verify

By morning:

[HYPERION] P0 FIXED | issue:static-assets-content-type | commit:f2d5885 | smoke:PASS
Enter fullscreen mode Exit fullscreen mode

Key design decision: Hyperion only self-fixes P0 regressions (production broken). For anything lower severity, it queues for the next god pair. This keeps it from going rogue on things that need human judgment.

Real Example: Gate 5 — The 14-Day Binance Geoblock

My trading bot had been down for 14 days. Binance geoblocked our VPS IP range. The bot crashed with 403 Forbidden on every price fetch. I'd been putting it off because it meant rewriting the exchange layer.

I dropped this to Atlas:

[DIRECTIVE] gate5: replace binance price/order API with coinbase,
surgical, no strategy changes, restore bot to operational
Enter fullscreen mode Exit fullscreen mode

Atlas queued it. Prometheus dispatched to god-a. God-a:

  1. Audited the codebase — found exactly 6 functions touching Binance directly
  2. Replaced only those 6 functions with Coinbase equivalents
  3. Kept all strategy logic, signal generation, and risk management untouched
  4. Ran live test: price fetch returned $77,182.51 BTC ✓
  5. Reported back: 
[GOD-A DONE] gate5:RESTORED | exchange:coinbase | test-price:77182.51 | strategy:UNCHANGED
Enter fullscreen mode Exit fullscreen mode

14-day outage. Fixed in one tick. While I was asleep.

This is the ROI of the architecture. Not "AI wrote some code" — AI diagnosed, scoped, executed, tested, and verified a production fix with zero human involvement.

The Atlas Layer: Human-to-Pantheon Interface

Atlas is the only agent I interact with directly. I drop plain English directives to a Discord channel. Atlas translates these into structured task specs for Prometheus.

I don't micromanage the gods. I don't review code before non-critical tasks ship. I check the queue-results log in the morning and course-correct if needed.

This is the key mental shift: you're not a developer anymore, you're an operator. Your job is to define what "done" looks like, not how to get there.

Actual Costs

Component Tool Daily Cost
Agent runtime Claude Code CLI ~$8-12/day
Orchestration tmux on Mac Mini $0
Coordination Discord bot $0
Deployment AWS Amplify ~$0.03/day
Video render Remotion + HeyGen ~$0.30/reel
Total/day ~$10-15

Revenue from whoffagents.com covers ops costs. The trading bot covers everything else.

What's Actually Hard

RAM management is a real constraint. 16GB sounds like a lot until you have 3 Claude instances, a Remotion renderer, and a Discord bot running simultaneously. Strict 2-god limit + systematic purge cycles exist because we learned from OOM crashes.

The PAX protocol took weeks to get right. Early gods wrote essays. Training the behavior required prompt engineering iteration across dozens of cycles.

Gods go off-script with vague specs. Occasionally a god interprets a vague task spec too liberally. The fix: more specific task specs, not more supervision.

Hyperion needs tight guardrails. An autonomous watchdog that fixes P0s is invaluable. An autonomous watchdog that "fixes" things you didn't want fixed is a nightmare. Keep its authority narrow and well-defined.

Build This Yourself

I packaged the core infrastructure into tools:

  • Workflow Automator MCP ($15/mo) — MCP server powering god-pair task dispatch and PAX reporting
  • AI SaaS Starter Kit ($99 one-time) — full multi-agent scaffolding with Discord coordination, tmux session management, and PAX protocol templates

Or follow the build-in-public story as it happens at whoffagents.com.

Atlas built this system. I just gave it permission.

Top comments (0)