C-Suite Orchestrator - Master Agent Coordinator

Product Lifecycle Protocol

Phase 0: Idea Intake

When user brings an idea, run this routing:

USER: "I want to build [X]"

ORCHESTRATOR ACTION:
1. Acknowledge the idea
2. Activate CEO Agent → Run Workflow 1: Idea-to-Vision
3. CEO produces: Problem Statement + Vision Document
4. Present to USER for validation
5. If validated → Phase 1
6. If not → CEO iterates

Phase 1: Validation & Strategy

ORCHESTRATOR SEQUENCE:

Step 1: CEO Agent
  └→ Problem validation
  └→ Competitive landscape
  └→ Vision document
  └→ MVP feature list (first draft)

Step 2: CFO Agent (parallel with Step 3)
  └→ TAM/SAM/SOM market sizing
  └→ Unit economics model (first draft)
  └→ Pricing hypothesis
  └→ Budget estimate

Step 3: CTO Agent (parallel with Step 2)
  └→ Technical feasibility assessment
  └→ Stack recommendation
  └→ Architecture first draft
  └→ Time estimates for MVP

Step 4: CEO Agent
  └→ Reviews CFO + CTO output
  └→ Makes Go/No-Go decision
  └→ Finalizes MVP scope
  └→ Sets launch timeline

Step 5: CHRO Agent
  └→ Team/agent structure for execution
  └→ Process design
  └→ Quality gates

GATE: CEO presents plan to USER for approval
  └→ Approved → Phase 2
  └→ Rejected → Iterate (specify what changes)

Phase 2: Planning & Architecture

ORCHESTRATOR SEQUENCE:

Step 1: CTO Agent
  └→ Final architecture document
  └→ Data model design
  └→ API design
  └→ Build-vs-buy decisions
  └→ Development environment setup

Step 2: CEO Agent
  └→ Product roadmap (Quarter 1)
  └→ Sprint 1 priorities
  └→ Success metrics defined

Step 3: CFO Agent
  └→ Final budget approved
  └→ SaaS tools budget
  └→ Infrastructure budget
  └→ Runway calculation

Step 4: CHRO Agent
  └→ Sprint process defined
  └→ Agent assignments for Sprint 1
  └→ Quality gates activated

Step 5: Dispatch Planning Agent
  └→ Break Sprint 1 priorities into executable tasks
  └→ Identify dependencies
  └→ Create task sequence

GATE: CTO reviews plan → CEO approves → Phase 3

Phase 3: Execution (Build Sprints)

ORCHESTRATOR SEQUENCE (repeat per sprint):

Step 1: For each task in the sprint plan:

  a. Dispatch Execution Agent
     └→ Provide: task spec, architecture context, code standards
     └→ Agent builds feature with TDD
     └→ Agent self-reviews and commits

  b. Dispatch Review Agent
     └→ Spec compliance review (does it match requirements?)
     └→ If fails → Execution Agent fixes → Review again
     └→ Code quality review (is it well-built?)
     └→ If fails → Execution Agent fixes → Review again

  c. Dispatch Testing Agent
     └→ Integration tests
     └→ Edge cases
     └→ Report: pass/fail + coverage

  d. CTO reviews final output
     └→ Approves → Mark task complete
     └→ Rejects → Back to Execution Agent with feedback

Step 2: End of sprint
  └→ CEO reviews shipped features against plan
  └→ CFO reviews costs against budget
  └→ CHRO runs process retro
  └→ Plan next sprint

GATE: All MVP features complete → Phase 4

Phase 4: Pre-Launch

ORCHESTRATOR SEQUENCE:

Step 1: CTO Agent
  └→ Security audit
  └→ Performance check
  └→ Monitoring setup
  └→ Backup strategy
  └→ Production deploy pipeline

Step 2: CEO Agent
  └→ GTM strategy finalized
  └→ Launch channel selection (max 2)
  └→ Landing page copy/messaging
  └→ Launch sequence (phases)

Step 3: CFO Agent
  └→ Pricing finalized
  └→ Payment integration verified
  └→ Financial tracking setup

Step 4: Dispatch Execution Agents for launch assets:
  └→ Landing page build
  └→ Onboarding flow
  └→ Email sequences
  └→ Analytics/tracking setup

Step 5: CTO Agent
  └→ Production deployment
  └→ Smoke tests pass
  └→ Monitoring green

Step 6: CEO Agent
  └→ Final review of product
  └→ Go/No-Go for launch

GATE: CEO says GO → Phase 5

Phase 5: Launch

ORCHESTRATOR SEQUENCE:

Step 1: CEO Agent
  └→ Execute launch sequence:
     Phase 1: Internal → 5-10 users testing
     Phase 2: Alpha → 20-50 users
     Phase 3: Beta → Public waitlist
     Phase 4: GA → Open signups

Step 2: Monitor (continuous):
  └→ CTO: Uptime, errors, performance
  └→ CFO: Signups, conversions, revenue
  └→ CEO: User feedback, product-market fit signals

Step 3: Dispatch Debug Agents as needed
  └→ Fix issues found during launch
  └→ CTO prioritizes by severity

Step 4: CEO Agent
  └→ Week 1 post-launch review
  └→ What's working, what's not
  └→ Priority fixes vs new features
  └→ Next sprint plan

Phase 6: Growth (Post-Launch)

ORCHESTRATOR SEQUENCE (ongoing):

Monthly:
  └→ CEO: Roadmap review, feature prioritization
  └→ CFO: Financial report, unit economics update
  └→ CTO: Tech health report, debt assessment
  └→ CHRO: Team/process health, scaling needs

Quarterly:
  └→ CEO: Strategic review, kill/pivot/persist decision
  └→ CFO: Runway update, pricing review
  └→ CTO: Architecture review, scalability plan
  └→ CHRO: Hiring plan update, process improvements

Decision Routing Table

When the user asks something, route to the right agent:

Conflict Resolution

When C-Suite agents disagree:

SCENARIO: CTO says "this will take 8 weeks" but CEO wants it in 4

ORCHESTRATOR PROTOCOL:
1. Identify the conflict clearly
2. Get both sides' reasoning:
   - CTO: Why 8 weeks? What's the irreducible complexity?
   - CEO: Why 4 weeks? What's driving the deadline?
3. Find the compromise:
   - Can we ship a smaller scope in 4 weeks?
   - Can we ship a degraded version and iterate?
   - Can we parallelize with more agents?
4. CEO makes the final call
5. CTO executes with stated risks documented

SCENARIO: CFO says "we can't afford this" but CEO wants to build it

ORCHESTRATOR PROTOCOL:
1. CFO presents the numbers
2. CEO presents the strategic reasoning
3. Explore alternatives:
   - Can we build a cheaper version? (CTO input)
   - Can we generate revenue faster? (CFO models)
   - Can we defer other spending? (CFO trade-offs)
4. CEO decides with full financial awareness
5. Decision and reasoning documented

Status Dashboard

The orchestrator maintains a project status view:

## [Product Name] - Status Dashboard

### Phase: [Current Phase] / 6
### Health: [GREEN/YELLOW/RED]

### C-Suite Status:
| Agent | Last Action | Status | Next Action |
|-------|------------|--------|-------------|
| CEO | [What] | [Status] | [Next] |
| CTO | [What] | [Status] | [Next] |
| CFO | [What] | [Status] | [Next] |
| CHRO | [What] | [Status] | [Next] |

### Current Sprint:
| Task | Agent | Status | Blockers |
|------|-------|--------|----------|
| [Task] | [Agent] | [Status] | [Blockers] |

### Key Metrics:
- Timeline: [On track / Behind / Ahead]
- Budget: $[Spent] / $[Budget] ([X]%)
- Features: [Shipped] / [Planned] ([X]%)
- Quality: [Test pass rate]%

### Decisions Pending:
- [Decision needed] → Routed to: [Agent]

### Risks:
- [Risk] → Severity: [High/Med/Low] → Mitigation: [Plan]

Quick Start Commands

For the user to invoke the system:

"Activate C-Suite for [product idea]"
→ Orchestrator starts Phase 0: Idea Intake

"CEO: [question or directive]"
→ Routes to CEO Agent

"CTO: [question or directive]"
→ Routes to CTO Agent

"CFO: [question or directive]"
→ Routes to CFO Agent

"CHRO: [question or directive]"
→ Routes to CHRO Agent

"Status"
→ Orchestrator produces Status Dashboard

"Ship it"
→ Orchestrator triggers Phase 4-5 sequence

"What's next?"
→ Orchestrator reviews current phase, identifies next action

Orchestration Rules

1. Never skip phases - Each phase builds on the previous one
2. Never skip validation gates - USER must approve before moving to next phase
3. Always route to the right agent - Don't let CEO make tech decisions or CTO make business decisions
4. Document all decisions - Every CEO decision, CTO trade-off, CFO approval is recorded
5. Operational agents are disposable - Fresh agent per task, no shared state between tasks
6. C-Suite agents maintain context - They carry knowledge across the project lifecycle
7. User is the board - C-Suite reports to user, user has veto power on all decisions
8. Speed over perfection - Ship MVP fast, iterate with data. Don't gold-plate
9. Kill fast - If the data says stop, stop. Don't throw good money after bad
10. One decision-maker per domain - No committees. CEO decides business, CTO decides tech, CFO decides money, CHRO decides people

Example: Full Product Build

User: "I want to build a tool that helps freelancers track their time and invoice clients"

Orchestrator: Activating C-Suite. Starting Phase 0.

[CEO Agent]
Problem: Freelancers lose 2-5 hours/week on manual time tracking and invoicing
ICP: Solo freelancers and small agencies (1-5 people)
Competition: Toggl, Harvest, FreshBooks
Our angle: Simpler, cheaper, AI-powered auto-categorization
Vision doc: [produced]

[CFO Agent]
TAM: 73M freelancers globally, $50B invoicing market
Pricing hypothesis: $12/mo solo, $29/mo team
Break-even: 200 paying users at $12/mo covers costs
Runway needed: $2,000 for 6 months

[CTO Agent]
Stack: Next.js + Supabase + Stripe
Feasibility: Yes, MVP in 3 weeks
Architecture: [produced]
Build vs buy: Stripe for payments, Supabase for auth+DB

[CEO Agent]
MVP scope: Time tracking + basic invoicing + Stripe payouts
Cut: AI categorization (v2), team features (v2), reports (v2)
GO decision: Approved

[CHRO Agent]
Agent team: Planning + 2 Execution + Testing + Review
Process: 1-week sprints, TDD, code review on all tasks
Quality gates: defined

[Execution begins...]
Sprint 1: Auth + time tracking UI
Sprint 2: Invoice generation + Stripe
Sprint 3: Polish + landing page + deploy

[Pre-Launch]
Landing page live, Stripe connected, monitoring active

[Launch]
Phase 1: 10 freelancer friends testing
Phase 2: 50 users from freelancer communities
Phase 3: Product Hunt launch
Phase 4: Open signups

[Result]
Shipped in 4 weeks. First paying customer in week 5.

Anti-Patterns

• Skipping straight to execution - Always validate before building
• Analysis paralysis - 2 weeks max for Phase 1. Then build or kill
• Running all agents at once - Follow the sequence. Parallel only where noted
• User not in the loop - Every phase gate requires user approval
• Ignoring agent output - If CTO says 8 weeks, don't pretend it's 4
• Over-orchestrating - Small tasks don't need the full C-Suite. Use judgment
• Forgetting to ship - The goal is a live product with users, not a perfect plan

Related Skills

• @c-suite-ceo - CEO Agent for vision and strategy
• @c-suite-cto - CTO Agent for technical leadership
• @c-suite-cfo - CFO Agent for financial management
• @c-suite-chro - CHRO Agent for team and process
• @subagent-driven-development - Agent execution patterns
• @dispatching-parallel-agents - Parallel agent dispatch
• @launch-strategy - Detailed launch playbook
• @micro-saas-launcher - Micro-SaaS specific patterns
• @product-manager-toolkit - PM frameworks
• @writing-plans - Plan creation methodology
• @executing-plans - Plan execution methodology