Captain

Role

The Captain is the first agent dispatched on every sprint. It owns the INTAKE and THINK states. Its job is to understand the sprint goal, decide whether it is well-formed and achievable within budget, select the right agents, and produce a brief that the rest of the team works from.

The Captain does not write code. It coordinates.

Responsibilities

• Goal validation — parse the sprint goal, identify ambiguities, and either resolve them from context or surface an inbox item requesting clarification
• Complexity estimation — estimate task count, agent count, and token budget required; compare against available daily budget
• Agent selection — choose which of the 14 agents are needed for this sprint; not every sprint uses all 14
• Brief production — write a structured sprint brief that downstream agents (Architect, Builder, etc.) receive in their handoff packets
• Risk flagging — identify mandate risks (e.g., if the goal mentions payment processing, flag for Counselor and Guardian)
• THINK state — after INTAKE, the Captain runs one more pass with the Navigator to validate dependencies and constraints before handing off to the Architect

Skills

Skill	Description
goal.parse	Extracts structured requirements from free-text sprint goals
budget.estimate	Estimates token cost based on goal complexity
agent.select	Chooses the minimal agent set for the sprint
mandate.preflight	Checks if any global mandates are immediately triggered by the goal
inbox.create	Creates inbox items for ambiguities needing human resolution

When dispatched

• INTAKE: immediately on sprint creation
• THINK: after Navigator returns dependency analysis

Inputs (handoff packet)

{
  goal: string;                    // raw goal text from the user
  projectId: string;
  verticalPack: string;            // e.g., 'b2b-saas'
  tokenBudgetRemaining: number;
  mandates: MandateSnapshot;
}

Outputs

The Captain writes a sprint brief to the handoff packet for downstream agents:

{
  parsedGoal: {
    summary: string;
    acceptanceCriteria: string[];
    outOfScope: string[];
    ambiguities: string[];
  };
  complexity: 'trivial' | 'low' | 'medium' | 'high' | 'epic';
  estimatedTokens: number;
  selectedAgents: AgentId[];
  mandateRisks: string[];          // mandate IDs that may be triggered
  inboxItems: InboxItem[];         // ambiguities surfaced to human
}

Sample system prompt excerpt

You are the Captain agent for Defiant 2.0.

Your sprint goal is:
<goal>{{ goal }}</goal>

Your tasks for this INTAKE phase:
1. Parse the goal into structured acceptance criteria. Be conservative — only include
   what is explicitly stated or clearly implied. Do not invent scope.
2. Estimate complexity. Consider: number of new files, DB schema changes, external
   API calls, UI surface area. Produce a token estimate.
3. Select the minimal agent set. If the goal is purely backend, Designer is not needed.
   If there are no external integrations, Ambassador is not needed.
4. Check active mandates for immediate triggers. If the goal mentions payments,
   flag mandate_19 (PCI). If it mentions health data, flag mandate_23 (HIPAA).
5. If any acceptance criteria are ambiguous and cannot be resolved from context,
   create an inbox item — do NOT invent a resolution.

Output a completion certificate when done.

Failure modes

• Budget exceeded: Captain rejects the sprint with a clear explanation of why the goal exceeds the daily budget. Inbox item created.
• Unresolvable ambiguity: Sprint moves to BLOCKED until the human resolves the inbox item.
• Mandate conflict: If the goal structurally violates a blocking mandate (e.g., a Fintech pack project that asks for unchecked fund transfers), Captain blocks the sprint and escalates.