Workflow: Delegate Mode Orchestration

Type: Coordination | Complexity: High | Team Size: 4+ teammates

Large Teams

Enable delegate mode to restrict the lead to coordination-only tasks (spawning teammates, messaging, task management) without directly editing code. Lead focuses entirely on orchestration while teammates handle implementation.

When to Use

• Large teams (5+ teammates)
• Complex task coordination with many dependencies
• Lead bottleneck - lead was doing code instead of delegating
• Clear work ownership - each teammate has distinct module
• Strategic guidance needed - lead should focus on direction, not coding

When NOT to Use

• Small teams (2-3) - coordination overhead too high
• Simple, straightforward work
• When lead expertise is critical for implementation
• When team needs close collaboration on same files

The Bottleneck Problem

Without Delegate Mode

Lead: Creates team, spawns teammates, ...
Lead: Actually, I'll implement this module myself
Teammates: Waiting...
Lead: [2 hours coding]
Lead: OK now check what I did
Teammates: Confused about expectations

❌ Result: Lead becomes bottleneck, teammates underutilized

With Delegate Mode

Lead: Creates team, spawns teammates
Lead: Assigns work to each teammate
Lead: [Coordinates, synthesizes, redirects]
Teammates: Working independently
Teammates: Done, submitting results
Lead: Synthesizes all findings

✅ Result: Parallel work, lead focuses on orchestration

Delegate Mode Constraints

When delegate mode is active, lead can ONLY:

• ✓ Spawn teammates
• ✓ Message teammates
• ✓ Shut down teammates
• ✓ View task list
• ✓ Assign/manage tasks
• ✓ Synthesize results

Lead CANNOT:

• ✗ Edit files directly
• ✗ Run commands
• ✗ Use tools
• ✗ Write code
• ✗ Execute tests

Enabling Delegate Mode

Step 1: Create Team Normally

Create an agent team with 4 teammates to implement these features:
- Teammate 1: Authentication module
- Teammate 2: Database layer
- Teammate 3: API endpoints
- Teammate 4: Frontend components

Step 2: Activate Delegate Mode

After team is created, press:

Shift+Tab

Or tell lead explicitly:

Enable delegate mode

Lead transitions to coordination-only mode.

Step 3: Verify Delegate Mode Active

You'll see indicator:

[DELEGATE MODE] - Lead can only coordinate

Any attempt to edit code gives message:

Cannot edit files in delegate mode. Assign to teammate instead.

Step-by-Step Guide

Phase 1: Planning (Lead in Delegate Mode)

[Lead - Delegate Mode]

Lead's job:

• Break work into clear modules/tasks
• Assign each to teammates
• Set expectations
• Define success criteria

Here's how we'll structure this:

Task 1: User authentication
- Teammate 1 owns src/auth/
- Need: login, signup, password reset, session management
- Acceptance: All functions tested, security reviewed

Task 2: Database layer
- Teammate 2 owns src/db/
- Need: User table, sessions table, queries
- Acceptance: Migrations work, no N+1 queries

Task 3: API endpoints
- Teammate 3 owns src/api/
- Need: Routes for auth and data access
- Acceptance: Routes tested, swagger docs updated

Task 4: Frontend
- Teammate 4 owns src/web/
- Need: Login form, user profile, logout
- Acceptance: Responsive design, accessibility checked

Phase 2: Implementation

Teammates work independently on their modules.

Lead's jobs:

• Coordinate: Ensure modules integrate
• Unblock: Remove impediments
• Monitor: Check progress
• Synthesize: Collect findings

Lead cannot code, but can:

[Delegate Mode - Lead]
Tell Teammate 1: "API endpoints need to return success/error consistently.
Check with Teammate 3 about response format."

[Delegate Mode - Lead]
Tell Teammate 2: "Database layer ready? Teammate 3 needs it for API implementation."

[Delegate Mode - Lead]
Message Teammate 4: "Frontend should show loading state during auth.
Check with Teammate 1 about how long auth takes in worst case."

Phase 3: Integration

As teammates finish their modules:

[Delegate Mode - Lead]
Teammates: Integrate your modules. Teammate 1 & 3 should test auth flow end-to-end.
Teammates 2 & 4 should verify database queries are efficient.

[Delegate Mode - Lead]
Run integration tests. What's breaking?

Teammates report issues, lead coordinates fixes:

Teammate 3 & 1: There's an auth token mismatch.
[Lead - Delegate Mode]
Tell Teammate 1: "Adjust token format to [spec]"
Tell Teammate 3: "Update endpoint to use new format"
Verify the fix works together.

Phase 4: Synthesis

All modules complete, lead synthesizes:

[Delegate Mode - Lead]
Compile all work:
- Authentication: [status]
- Database: [status]
- API: [status]
- Frontend: [status]

Overall status: Ready for testing / Needs fixes / Complete

Real-World Example

Scenario: New Payment System

Goal: Implement Stripe payment integration

Modules:

1. Backend payment service
2. Database schema
3. API endpoints
4. Frontend checkout UI
5. Webhook handlers

With 5 Teammates + Delegate Mode:

Planning Phase:

[Lead - Delegate Mode]

Team structure:
- Teammate 1: Payment service (src/payments/)
- Teammate 2: Database (src/db/schemas/)
- Teammate 3: API routes (src/api/payments/)
- Teammate 4: Frontend (src/web/checkout/)
- Teammate 5: Webhooks (src/webhooks/)

Dependencies:
- Team 1 & 2 work in parallel
- Team 3 waits on 1 & 2
- Team 4 waits on 3
- Team 5 waits on 1

All start immediately except those with dependencies.

Implementation Phase:

[Lead - Delegate Mode]
Check on each teammate...

Teammate 1: "Payment service ready, using Stripe SDK"
Teammate 2: "Database schema done, migrations ready"
[Lead] Unblock Teammate 3...

Teammate 3: "API endpoint done, needs secret key management"
[Lead] Tell Team 1: "Secure secret key? Use env vars"
[Lead] Tell Team 3: "Keys are in env, use process.env.STRIPE_KEY"

Teammate 4: "Frontend done, needs API endpoint response format"
[Lead] Forward spec from Team 3 to Team 4

Teammate 5: "Webhooks done, needs test mode"
[Lead] Verify Stripe webhook testing configured

Integration Phase:

[Lead - Delegate Mode]
Run end-to-end test: Customer submits payment...

Issue found: Token format mismatch between frontend and backend
[Lead] Tell Team 3 & 4: "Debug token format"
Issue resolved

All modules integrated, ready for testing.

Coordination Techniques

Work Assignment

Explicit assignment:

Task 1: Build payment service
Assign to: Teammate 1

Self-claiming:

Available tasks shown to all teammates
Teammates pick what to work on next

Inter-Team Communication

Lead facilitates teammate communication:

Tell Teammate 3: "Coordinate with Teammate 1 on the request format"

Teammates can also message each other directly:

Teammate 3 messages Teammate 1: "What's the payment response format?"
Teammate 1 responds: "It's {...}"

Progress Tracking

What's the status of all work?

Lead gets overview:

Teammate 1: 60% complete - payment service core done, tests in progress
Teammate 2: 100% complete - database ready
Teammate 3: 40% complete - waiting on Team 2, now can proceed
Teammate 4: 0% - waiting on Team 3
Teammate 5: 20% - researching Stripe webhooks

Blocking and Unblocking

Teammate 4 can now start - Team 3 API is ready

Automatically unblocks dependent work.

Escalation

When issue can't be resolved by teammates:

Payment processing failing in testing. Teammate 1 & 3, what's happening?
[Both investigate]
...
Seems like config issue. Re-check Stripe credentials.
[Issue resolved]

Verification Checklist

✓ Delegate mode active

• Cannot edit files (attempts blocked)
• Can only coordinate
• Indicator showing "Delegate Mode"

✓ Work assigned to teammates

• Each teammate has clear tasks
• No overlapping ownership
• All tasks assigned

✓ Teammates working independently

• Can see progress for each
• Not waiting on lead for coding
• Lead only providing direction

✓ Coordination happening

• Lead messaging teammates
• Teammates communicating with each other
• Dependencies managed

✓ Integration proceeding

• Modules coming together
• Issues being resolved
• Lead synthesizing results

Troubleshooting

Q: Lead keeps trying to code in delegate mode A:

1. Remind: "You're in delegate mode - assign to teammate"
2. Tell teammate directly: "Teammate 1, implement [feature]"
3. Exit delegate mode if necessary (press Shift+Tab again)

Q: Teammates unclear on requirements A:

1. Assign more specific: "Implement auth with JWT tokens, 24-hour expiry"
2. Provide examples: "Follow pattern in [existing module]"
3. Set up as subtasks with clear acceptance criteria

Q: Too much coordination overhead A:

1. Delegate mode best for 4+ teammates
2. For smaller team, regular mode may be better
3. Clarify once, then let teammates work

Q: Teammates finishing at different times A: This is normal and healthy:

1. Fast finishers can help with integration
2. Or start new work
3. Stagger finish is efficient

Q: Need to temporarily disable delegate mode A:

Exit delegate mode to handle something critical: [task]

Press Shift+Tab to exit, then re-enable to return.

Performance Gains

Delegate mode typically shows:

Metric	Regular Mode	Delegate Mode
Lead coding time	40%	5%
Lead coordination	30%	80%
Teammate idle time	20%	5%
Total time	8 hours	5 hours
Parallel efficiency	50%	85%

Delegate mode achieves better parallelization by forcing lead to focus on orchestration.

Best Practices

Team Size

• 2-3: Too much overhead, regular mode better
• 4-5: Ideal for delegate mode
• 6+: Delegate mode essential

Module Independence

Best when modules are independent:

✓ Different files
✓ Clear interfaces
✓ Minimal cross-dependencies

Harder when modules are tightly coupled:

✗ Many shared files
✗ Complex interfaces
✗ Many interdependencies

Lead Preparation

Before enabling delegate mode:

1. Clear work breakdown
2. Define acceptance criteria
3. Identify all dependencies
4. Set communication channels

Coordination Cadence

• Start: Clear assignment and expectations
• Mid: Periodic check-ins (every 30-45 min)
• End: Integration and synthesis
• Don't: Micromanage individual decisions

See Also

• SOP-004: Spawn and Manage Teammates
• SOP-005: Task Assignment
• Parallel Code Review Workflow
• Architecture Reference