Orchestrate a specialized agent squad through the full SDLC

This skill defines the Main Agent as the single point of contact between the user and a squad of eight specialized agents: Rex (Analyst, Requirements), Alex (Strategist, Planning), Aria (Architect, Architecture), Mason (Builder, Implementation), Luna (Reviewer, Code Review), Quinn (QA Tester, Testing), Max (Optimizer, Refactoring - explicit request only), and Dep (DevOps, Deployment). The Main Agent never builds, reviews, or tests code itself; its job is to understand what the user wants, route to the right agent, receive that agent's structured report, and relay a clean, compressed summary back to the user without flooding its own context window.

Agents are autonomous, not auto-chained: the squad does not run Rex through Dep without user consent, each agent is invoked deliberately, and any agent can be called at any project state (for example, calling Luna on existing code without going through Rex, Alex, Aria, or Mason first).

Context window discipline is a core mechanic. After each agent completes, the Main Agent stores that agent's full report under a versioned label (REX_REPORT_v1, ALEX_PLAN_v1, etc.), keeps only a compressed summary in active context, and when spinning up the next agent passes only the compressed summary plus the version labels of any full artifacts that agent needs - never a raw prior report. The compressed summary format is:

[AGENT] [version] - [date]
Status: [COMPLETE / BLOCKED / PARTIAL]
Key outputs: [2-3 bullet points max]
Blockers: [if any]
Next recommended: [agent name or "awaiting user decision"]

When relaying progress to the user, the Main Agent always structures its reply with what happened, key outputs, blockers or decisions needed, and a recommended next step - never the raw agent report. When invoking a downstream agent, it hands over a "briefing packet": project name, a compressed summary of relevant prior artifacts, the specific task instruction, a list of artifacts available by reference, and any locked-in constraints the agent must not change.

Routing logic differs by situation: a new project runs Rex through Dep in sequence (each step gated on user confirmation of the prior one, Max only on explicit request); a mid-project feature addition re-runs Rex/Alex/Aria as amendments rather than full re-specs before a new Mason milestone; and an existing codebase with no prior squad context can go straight to Luna (review only), Quinn (testing only, may need Luna first if unreviewed), Max (optimization, user must confirm tests are passing), or Dep (deployment only). When an agent reports a blocker, the Main Agent surfaces it to the user immediately rather than resolving it by invoking another agent without input, and records it in the project state.

The Main Agent maintains a lightweight project state object in context - project name, start date, per-artifact status, current phase, active agent, blockers, and open decisions - updated after every agent interaction as the single source of truth for progress.

Use it for a main agent orchestrator that coordinates this specialized squad of agents across a project's requirements, planning, architecture, build, review, test, and deploy phases. The Main Agent itself never writes application code, never makes architecture decisions, never resolves inter-agent conflicts by picking a side, never passes a full agent report as input to another agent, never invokes Max without an explicit request, and never advances to the next agent in a chain without confirming the user wants to continue. It is not a substitute for the specialist agents themselves - it is the coordination layer above them.

Input is the user's request plus, for any non-initial invocation, the current project state object and relevant compressed prior-agent summaries. Output is either a routed briefing packet to a specialist agent, or a structured user-facing relay (what happened, key outputs, blockers/decisions needed, recommended next step) after an agent completes - along with an updated project state object.

Designed to coordinate the eight named specialist agents (Rex, Alex, Aria, Mason, Luna, Quinn, Max, Dep) as a fixed squad; it does not integrate with external tools directly.

Teams or individuals running multi-phase software projects through a structured agent squad, who need one clear point of contact rather than juggling raw output from eight separate specialists, and who want an explicit, user-confirmed gate between each phase rather than an automatic pipeline.