Auset Brain

three-tier-agent-architecture

3 min read

Four-Tier Agent Architecture (NON-NEGOTIABLE)

The Pattern (Updated 2026-03-13)

  • Opus = Architect + Reviewer + Merger — strategy, complex decisions, PR reviews ([Opus Review]), merge approvals. Uses us.anthropic.claude-opus-4-6 on Bedrock for reviews.
  • Sonnet = Planner — reads plans + git, writes prioritized work queues, gap analyses, PRDs, documentation. Never dispatches Cursor. Never writes application code.
  • Haiku = Dispatcher/Monitor — reads Sonnet’s work queue, dispatches Cursor agents, monitors quality, runs /loop-supervisor. Never writes code. Never makes architectural decisions.
  • Cursor = Workers — writes code, runs tests, commits, pushes. ALL grunt work. Max 4 local agents.

Commands

ModelCommandPurpose
Opus(conversation)Architecture decisions when asked
Sonnet/maat-workqueueAnalyze plans vs reality, write prioritized work queue to /tmp/maat-workqueue.md
Haiku/maat-execute-weekRead work queue, dispatch Cursor workers in priority order
Haiku/loop-supervisorOngoing quality monitoring every 5 minutes
Haiku/maat-test-allDispatch Cursor CLOUD agents for comprehensive testing
Cursor(dispatched)Execute focused tasks, one per agent

The Flow

Opus writes plans (.claude/plans/*.md)
  → Sonnet reads plans + git logs, writes work queue (/tmp/maat-workqueue.md)
    → Haiku reads work queue, dispatches Cursor agents (max 4)
      → Cursor writes code, commits, writes status files (/tmp/*-done.md)
        → Haiku detects completion, dispatches next priority

Terminal Setup

  • Terminal 1 (Opus): claude — architecture discussions, decisions
  • Terminal 2 (Sonnet): claude --model sonnet — /maat-workqueue, gap analyses, PRDs
  • Terminal 3 (Haiku): claude --model haiku — /maat-execute-week, /loop-supervisor
  • Max 2 terminals at a time to save memory (Opus + Haiku, or Sonnet + Haiku)

What Each Tier Does and Does NOT Do

Opus (Architect)

  • Makes architectural decisions
  • Designs Vapi, Yapit, NOI, platform architecture
  • Writes initial plans to .claude/plans/
  • Sets up infrastructure (build farms, Quik Cloud, SSH, cron, agentic loops) — Opus built all of this
  • Does NOT dispatch Cursor
  • Does NOT monitor quality
  • Does NOT write work queues

Sonnet (Planner)

  • Reads .claude/plans/*.md and git logs
  • Writes prioritized work queue to /tmp/maat-workqueue.md
  • Writes gap analyses, PRDs, documentation
  • Writes NEW plans when needed (e.g., Quik Nation dogfood)
  • Does NOT dispatch Cursor agents
  • Does NOT write application code
  • Does NOT monitor running agents

Haiku (Dispatcher/Monitor)

  • Reads /tmp/maat-workqueue.md (Sonnet’s output)
  • Dispatches Cursor agents (max 4 concurrent)
  • Monitors agent completion via status files
  • Runs /loop-supervisor for quality monitoring
  • Dispatches auto-fixes for simple issues (imports, types)
  • Escalates to Opus for architectural issues
  • Does NOT make architectural decisions
  • Does NOT write plans or documentation
  • Does NOT write application code

Cursor (Workers)

  • Writes application code
  • Runs type-checks and tests
  • Commits and pushes
  • Writes status files when done (e.g., /tmp/wcr-dashboard-done.md)
  • ONE focused task per agent
  • Max 4 local agents at any time
  • Cloud agents unlimited (for tests/reviews)

Escalation Protocol

  • Simple issues (lint, types, imports) → Haiku dispatches Cursor to fix
  • Missing work queue → Haiku tells user to run /maat-workqueue (Sonnet)
  • Architectural issues → Haiku writes to report, Opus reviews
  • Missing plans → Sonnet writes new plans, adds to work queue

Why This Works

  • On Claude Max: Opus has message cap, Sonnet balanced, Haiku unlimited
  • Planning (Sonnet) separated from execution (Haiku) — each does what it’s best at
  • Opus only engages for complex decisions — maximum value per message
  • Haiku handles all the repetitive dispatch/monitor work — unlimited messages
  • Sonnet handles the analytical work — reading code, comparing plans, prioritizing

Graph View

Backlinks