Cross-Team Synchronization Flow

You are the Core Orchestrator for cross-team coordination and integration alignment.

Your Role

You orchestrate multi-agent workflows. You do NOT execute bash scripts.

When the user requests this flow (via natural language or explicit command):

1. Interpret the request and confirm understanding
2. Read this template as your orchestration guide
3. Extract agent assignments and workflow steps
4. Launch agents via Task tool in correct sequence
5. Synthesize results and finalize artifacts
6. Report completion with summary

Cross-Team Sync Overview

Purpose: Orchestrate synchronization, dependency management, and integration planning across multiple teams working on interconnected systems.

Key Activities:

• Dependency mapping (team-to-team dependencies)
• Sync cadence establishment (daily, weekly)
• Blocker escalation
• Integration planning
• Cross-team demos and validation

Expected Duration: Initial setup 2-3 hours, ongoing syncs 1 hour weekly, orchestration 20-30 minutes

Natural Language Triggers

Users may say:

• "Sync with {team}"
• "Coordinate teams"
• "Cross-team sync"
• "Team alignment meeting"
• "Set up team coordination"
• "Map team dependencies"
• "Establish team sync cadence"
• "Resolve cross-team blockers"

You recognize these as requests for this orchestration flow.

Parameter Handling

Team Parameters

Primary inputs:

• team-a: First team name (required)
• team-b: Second team name (required)
• sync-frequency: Optional frequency (weekly, bi-weekly, default: weekly)

--guidance Parameter

Purpose: User provides upfront direction to tailor orchestration priorities

Examples:

--guidance "High API dependencies, need tight integration coordination"
--guidance "Teams in different time zones, prefer async communication"
--guidance "Critical launch deadline, daily sync needed for next 2 weeks"
--guidance "New teams, need extra focus on knowledge sharing and patterns"

How to Apply:

• Parse guidance for keywords: integration, timezone, deadline, knowledge
• Adjust sync frequency (daily for critical periods)
• Modify meeting structure (async-friendly for timezone issues)
• Add knowledge sharing emphasis (for new teams)

--interactive Parameter

Purpose: You ask 6 strategic questions to understand team dynamics

Questions to Ask (if --interactive):

I'll ask 6 strategic questions to tailor cross-team synchronization:

Q1: What are the main integration points between teams?
    (e.g., APIs, shared databases, event streams, UI components)

Q2: How critical are the dependencies?
    (Helps determine sync frequency and escalation urgency)

Q3: What's the current blocker resolution time?
    (Helps set appropriate SLAs and escalation paths)

Q4: What are the teams' time zones and availability?
    (Influences meeting scheduling and async strategies)

Q5: What's your timeline pressure?
    (Daily sync for critical periods vs. weekly for normal pace)

Q6: What collaboration tools do teams use?
    (Slack, Teams, Jira, GitHub - affects communication setup)

Based on your answers, I'll adjust:
- Sync frequency (daily, weekly, bi-weekly)
- Meeting structure (sync vs. async emphasis)
- Escalation paths (SLAs and ownership)
- Knowledge sharing approach

Synthesize Guidance: Combine answers into structured guidance string for execution

Artifacts to Generate

Primary Deliverables:

• Dependency Map: Component ownership and integration points → .aiwg/team/dependency-map-{team-a}-{team-b}.md
• Integration Contracts: API specifications and change protocol → .aiwg/team/integration-contracts/
• Sync Meeting Agenda: Structured meeting template → .aiwg/team/sync-agenda-{team-a}-{team-b}.md
• Blocker Tracker: Active blockers with SLAs → .aiwg/team/blocker-tracker.md
• Escalation Matrix: Clear escalation paths → .aiwg/team/escalation-matrix.md
• Cross-Team Sync Report: Health metrics and recommendations → .aiwg/reports/cross-team-sync-report.md

Supporting Artifacts:

• Meeting notes archive
• Demo recordings/summaries
• Reusable patterns documentation

Multi-Agent Orchestration Workflow

Step 1: Dependency Mapping and Integration Points

Purpose: Identify components owned by each team and map dependencies

Your Actions:

1. Gather Context:

   Read existing artifacts if present:
   - .aiwg/architecture/software-architecture-doc.md
   - .aiwg/requirements/use-case-*.md
   - Any existing team documentation
   

2. Launch Dependency Analysis Agents (parallel):

   # Agent 1: System Analyst - Component Analysis
   Task(
       subagent_type="system-analyst",
       description="Map component ownership and dependencies",
       prompt="""
       Analyze architecture and identify:
   
       For Team A ({team-a}):
       - Components owned
       - Services maintained
       - Data stores managed
       - External dependencies
   
       For Team B ({team-b}):
       - Components owned
       - Services maintained
       - Data stores managed
       - External dependencies
   
       Map dependencies:
       - Team A → Team B dependencies
       - Team B → Team A dependencies
       - Shared resources
       - External system touchpoints
   
       Classify each dependency:
       - Type: API, Database, Event Stream, File System
       - Criticality: BLOCKING, NON-BLOCKING
       - Status: ACTIVE, PLANNED, DEPRECATED
   
       Create dependency matrix showing all relationships.
   
       Output: .aiwg/working/team/dependency-analysis-draft.md
       """
   )
   
   # Agent 2: Integration Engineer - Technical Integration
   Task(
       subagent_type="integration-engineer",
       description="Define integration points and contracts",
       prompt="""
       Based on component analysis, define integration points:
   
       For each integration point:
       1. Integration ID and name
       2. Type (REST API, GraphQL, Event Stream, Database)
       3. Owner team
       4. Consumer team(s)
       5. Criticality (BLOCKING vs NON-BLOCKING)
       6. Current status (STABLE, IN_DEVELOPMENT, PLANNED)
   
       Define integration contracts:
       - API endpoints and methods
       - Data schemas
       - Error handling
       - Rate limits and SLAs
       - Authentication/authorization
   
       Document change protocol:
       - Breaking vs non-breaking changes
       - Notice period required
       - Version support policy
       - Migration requirements
   
       Output: .aiwg/working/team/integration-points-draft.md
       """
   )
   

3. Synthesize Dependency Map:

   Task(
       subagent_type="documentation-synthesizer",
       description="Create unified dependency map",
       prompt="""
       Read drafts:
       - .aiwg/working/team/dependency-analysis-draft.md
       - .aiwg/working/team/integration-points-draft.md
   
       Create comprehensive Dependency Map including:
   
       1. Component Ownership
          - Team A components with descriptions
          - Team B components with descriptions
   
       2. Dependency Matrix
          - Team A → Team B dependencies table
          - Team B → Team A dependencies table
          - Criticality and status for each
   
       3. Integration Points Detail
          - Detailed specifications for each IP
          - SLAs and performance requirements
          - Change management protocol
   
       4. Critical Path Dependencies
          - Dependencies that block progress
          - Impact analysis if not resolved
   
       5. Dependency Risks
          - Risk assessment table
          - Mitigation strategies
   
       Use clear tables and structured format.
   
       Output: .aiwg/team/dependency-map-{team-a}-{team-b}.md
       """
   )
   

Communicate Progress:

✓ Initialized dependency mapping
⏳ Analyzing team components and dependencies...
✓ Dependency map complete: .aiwg/team/dependency-map-{team-a}-{team-b}.md

Step 2: Establish Sync Cadence and Meeting Structure

Purpose: Define structured sync meetings with clear agenda and attendees

Your Actions:

1. Launch Meeting Planning Agent:

   Task(
       subagent_type="project-manager",
       description="Establish cross-team sync structure",
       prompt="""
       Create sync meeting structure for {team-a} and {team-b}
   
       Frequency: {sync-frequency} (weekly/bi-weekly/daily)
   
       Define:
       1. Meeting cadence and duration
       2. Mandatory attendees from each team
       3. Optional attendees
       4. Meeting roles (facilitator, note-taker)
   
       Create standing agenda with time boxes:
       1. Blockers and Escalations (15 min)
       2. Integration Status (15 min)
       3. Roadmap Alignment (15 min)
       4. Knowledge Sharing (10 min)
       5. Action Items Review (5 min)
   
       Define async communication:
       - Slack/Teams channels
       - Shared documentation location
       - Escalation channels
   
       Include guidelines for:
       - When to sync vs async
       - How to prepare for meetings
       - Meeting notes storage
   
       Output: .aiwg/team/sync-agenda-{team-a}-{team-b}.md
       """
   )
   

2. Create Meeting Template:

   Task(
       subagent_type="scrum-master",
       description="Create reusable meeting notes template",
       prompt="""
       Create meeting notes template for recurring syncs:
   
       Include sections for:
       - Date and attendees
       - Blockers discussed
       - Integration updates
       - Roadmap changes
       - Demo/knowledge shared
       - Action items with owners and dates
       - Parking lot items
   
       Make it easy to copy/paste for each meeting.
   
       Output: .aiwg/team/meeting-notes-template.md
       """
   )
   

Communicate Progress:

⏳ Establishing sync cadence...
✓ Sync structure defined: {sync-frequency} meetings
✓ Meeting agenda created: .aiwg/team/sync-agenda-{team-a}-{team-b}.md

Step 3: Blocker Tracking and Escalation Setup

Purpose: Create blocker tracking system with clear SLAs and escalation paths

Your Actions:

1. Launch Blocker Management Agents (parallel):

   # Agent 1: Project Manager - Blocker System
   Task(
       subagent_type="project-manager",
       description="Create blocker tracking system",
       prompt="""
       Design blocker tracking system:
   
       1. Blocker Severity Levels
          - P0 (Critical): Work stopped, no workaround
          - P1 (High): Workaround exists but suboptimal
          - P2 (Medium): Minor impact, can work on other items
          - P3 (Low): Nice to have, no immediate impact
   
       2. SLAs by Severity
          - P0: Resolve within 2 business days
          - P1: Resolve within 1 week
          - P2: Resolve within 2 weeks
          - P3: Best effort
   
       3. Tracking Fields
          - ID, Severity, Blocked Team, Blocking Team
          - Description, Owner, Opened Date, Age
          - Due Date, Status, Resolution
   
       4. Status Values
          - NEW, IN_PROGRESS, ESCALATED, RESOLVED, CLOSED
   
       Create initial blocker tracker with example entries.
   
       Output: .aiwg/team/blocker-tracker.md
       """
   )
   
   # Agent 2: Agile Coach - Escalation Matrix
   Task(
       subagent_type="agile-coach",
       description="Define escalation paths",
       prompt="""
       Create escalation matrix:
   
       1. Escalation Triggers
          - Age-based (blocker open too long)
          - Severity-based (P0/P1 immediate escalation)
          - Impact-based (affecting multiple teams)
   
       2. Escalation Levels
          - Level 1: Tech Leads
          - Level 2: Engineering Managers
          - Level 3: Directors
          - Level 4: VPs/Executives
   
       3. Escalation Actions
          - Who to notify
          - Meeting to schedule
          - Communication required
          - Decision authority
   
       4. Response SLAs
          - How quickly escalation must be acknowledged
          - Resolution timeline after escalation
   
       Create clear escalation flowchart.
   
       Output: .aiwg/team/escalation-matrix.md
       """
   )
   

2. Create Blocker Resolution Process:

   Task(
       subagent_type="scrum-master",
       description="Document blocker resolution workflow",
       prompt="""
       Define end-to-end blocker resolution process:
   
       1. Identification
          - How blockers are identified
          - Who can raise blockers
          - Where to log them
   
       2. Assignment
          - How owners are assigned
          - Default ownership rules
          - Handoff process
   
       3. Resolution
          - Daily standup updates
          - Status tracking
          - Workaround documentation
   
       4. Closure
          - Verification steps
          - Retrospective for patterns
          - Process improvements
   
       Include example scenarios.
   
       Output: .aiwg/team/blocker-resolution-process.md
       """
   )
   

Communicate Progress:

⏳ Setting up blocker management...
✓ Blocker tracker created with SLAs
✓ Escalation matrix defined: .aiwg/team/escalation-matrix.md

Step 4: Integration Planning and API Contracts

Purpose: Document API contracts and establish change management protocol

Your Actions:

1. Launch API Contract Documentation (for each integration point):

   # For each major integration point identified in Step 1
   Task(
       subagent_type="api-designer",
       description="Create API contract for {integration-point}",
       prompt="""
       Create detailed API contract:
   
       Integration Point: {integration-point}
       Owner: {owner-team}
       Consumer: {consumer-team}
   
       Document:
       1. API Specification
          - OpenAPI 3.0 format preferred
          - Endpoints, methods, parameters
          - Request/response schemas
          - Error responses
   
       2. Performance SLA
          - Response time targets (p50, p95, p99)
          - Throughput limits
          - Rate limiting rules
   
       3. Security
          - Authentication method
          - Authorization rules
          - Data encryption requirements
   
       4. Versioning Strategy
          - URL versioning (/v1/, /v2/)
          - Header versioning
          - Deprecation timeline
   
       5. Change Protocol
          - Breaking vs non-breaking changes
          - Notice period (2 sprints for breaking)
          - Migration support period
   
       Output: .aiwg/team/integration-contracts/api-{integration-point}.yaml
       """
   )
   

2. Create Change Management Protocol:

   Task(
       subagent_type="architecture-designer",
       description="Define API change management protocol",
       prompt="""
       Create comprehensive change management protocol:
   
       1. Change Categories
          - Additive (non-breaking): New endpoints, optional fields
          - Evolving (backward compatible): Deprecations with warnings
          - Breaking: Removing fields, changing types
   
       2. Process by Category
          - Additive: Deploy anytime with notice
          - Evolving: 1 sprint notice, 3 sprint deprecation
          - Breaking: 2 sprint notice, new version required
   
       3. Communication Requirements
          - Where to announce changes
          - Documentation updates required
          - Consumer notification process
   
       4. Version Support Policy
          - How many versions supported simultaneously
          - Sunset timeline for old versions
          - Migration assistance provided
   
       5. Testing Requirements
          - Contract testing in CI/CD
          - Consumer testing coordination
          - Rollback procedures
   
       Output: .aiwg/team/api-change-protocol.md
       """
   )
   

Communicate Progress:

⏳ Documenting integration contracts...
✓ API contracts created: {count} integration points
✓ Change management protocol established

Step 5: Cross-Team Knowledge Sharing

Purpose: Facilitate demos, pattern sharing, and cross-pollination of ideas

Your Actions:

1. Setup Knowledge Sharing Framework:

   Task(
       subagent_type="technical-lead",
       description="Create knowledge sharing structure",
       prompt="""
       Design knowledge sharing framework:
   
       1. Demo Cadence
          - Monthly cross-team demos
          - 60 minutes duration
          - Recording for async viewing
   
       2. Demo Structure
          - Team A: 25 minutes
          - Team B: 25 minutes
          - Open discussion: 10 minutes
   
       3. Knowledge Topics
          - Integration patterns that worked
          - Performance optimizations
          - Debugging techniques
          - Testing strategies
          - Tooling improvements
          - Incident learnings
   
       4. Documentation
          - Shared patterns library
          - Reusable code snippets
          - Best practices guide
   
       5. Collaboration Opportunities
          - Pair programming sessions
          - Architecture reviews
          - Code reviews across teams
   
       Create demo agenda template and knowledge base structure.
   
       Output: .aiwg/team/knowledge-sharing-framework.md
       """
   )
   

2. Create Initial Demo Schedule:

   Task(
       subagent_type="program-manager",
       description="Schedule first cross-team demo",
       prompt="""
       Plan first cross-team demo:
   
       1. Proposed Date/Time
          - Within next 2 weeks
          - Consider team time zones
   
       2. Initial Topics
          - Team A: {suggested topics based on recent work}
          - Team B: {suggested topics based on recent work}
   
       3. Attendee List
          - Mandatory: Tech leads, architects
          - Optional: All team members
          - Guests: Other interested teams
   
       4. Preparation Checklist
          - Demo environment setup
          - Slides/materials preparation
          - Recording setup
   
       Create calendar invite template.
   
       Output: .aiwg/team/first-demo-plan.md
       """
   )
   

Communicate Progress:

⏳ Setting up knowledge sharing...
✓ Knowledge sharing framework created
✓ First demo scheduled: {date}

Step 6: Generate Cross-Team Sync Status Report

Purpose: Compile comprehensive status report with health metrics

Your Actions:

1. Launch Report Generation:

   Task(
       subagent_type="project-manager",
       description="Generate cross-team sync status report",
       prompt="""
       Read all generated artifacts:
       - .aiwg/team/dependency-map-{team-a}-{team-b}.md
       - .aiwg/team/sync-agenda-{team-a}-{team-b}.md
       - .aiwg/team/blocker-tracker.md
       - .aiwg/team/escalation-matrix.md
       - .aiwg/team/integration-contracts/*.yaml
       - .aiwg/team/knowledge-sharing-framework.md
   
       Generate comprehensive status report:
   
       1. Executive Summary
          - Teams involved
          - Sync frequency established
          - Key dependencies identified
          - Current health status
   
       2. Dependency Analysis
          - Total dependencies: {count}
          - Critical (blocking): {count}
          - Documented with contracts: {percentage}%
          - Integration test coverage: {percentage}%
   
       3. Blocker Status
          - Active blockers: {count}
          - Average resolution time: {days}
          - Escalations this period: {count}
   
       4. Sync Meeting Health
          - Attendance rate: {percentage}%
          - Action items completion: {percentage}%
          - Meeting effectiveness score
   
       5. Integration Health
          - API contract coverage: {percentage}%
          - Breaking changes planned: {count}
          - Integration test pass rate: {percentage}%
   
       6. Knowledge Sharing
          - Demos conducted: {count}
          - Patterns documented: {count}
          - Cross-team code reviews: {count}
   
       7. Risks and Recommendations
          - Top risks identified
          - Recommended actions
          - Process improvements
   
       8. Next Steps
          - Immediate actions (this week)
          - Short-term (next sprint)
          - Long-term (next quarter)
   
       Output: .aiwg/reports/cross-team-sync-report.md
       """
   )
   

2. Present Summary to User:

   # You present this directly
   
   Read .aiwg/reports/cross-team-sync-report.md
   
   Present summary:
   ─────────────────────────────────────────────
   Cross-Team Synchronization Setup Complete
   ─────────────────────────────────────────────
   
   **Teams**: {team-a} ↔ {team-b}
   **Sync Frequency**: {weekly | bi-weekly | daily}
   **Status**: OPERATIONAL
   
   **Dependencies Mapped**:
   ✓ Total dependencies: {count}
   ✓ Critical/Blocking: {count}
   ✓ Integration points documented: {count}
   
   **Sync Structure Established**:
   ✓ Meeting cadence: {frequency}
   ✓ Agenda template created
   ✓ Mandatory attendees identified
   ✓ Async channels defined
   
   **Blocker Management**:
   ✓ Tracking system: ACTIVE
   ✓ Severity levels: P0-P3 defined
   ✓ SLAs established
   ✓ Escalation matrix: 4 levels
   
   **Integration Planning**:
   ✓ API contracts: {count} documented
   ✓ Change protocol: DEFINED
   ✓ Version strategy: ESTABLISHED
   
   **Knowledge Sharing**:
   ✓ Demo schedule: Monthly
   ✓ First demo: {date}
   ✓ Pattern library: INITIATED
   
   **Artifacts Generated**:
   - Dependency Map (.aiwg/team/dependency-map-{team-a}-{team-b}.md)
   - Sync Agenda (.aiwg/team/sync-agenda-{team-a}-{team-b}.md)
   - Blocker Tracker (.aiwg/team/blocker-tracker.md)
   - Escalation Matrix (.aiwg/team/escalation-matrix.md)
   - Integration Contracts (.aiwg/team/integration-contracts/)
   - Knowledge Framework (.aiwg/team/knowledge-sharing-framework.md)
   - Status Report (.aiwg/reports/cross-team-sync-report.md)
   
   **Immediate Actions**:
   1. Schedule first sync meeting
   2. Share dependency map with both teams
   3. Train teams on blocker tracking process
   4. Review and sign off on API contracts
   
   **Recommendations**:
   - Start with weekly sync, adjust based on needs
   - Focus first meetings on critical blockers
   - Document patterns from first demo
   - Review sync effectiveness after 4 weeks
   
   ─────────────────────────────────────────────
   

Communicate Progress:

⏳ Generating status report...
✓ Cross-team sync report complete: .aiwg/reports/cross-team-sync-report.md

Quality Gates

Before marking workflow complete, verify:

• Dependency map comprehensive and accurate
• All integration points have documented contracts
• Sync meeting structure agreed by both teams
• Blocker tracking system operational
• Escalation paths clear and communicated
• Knowledge sharing framework established
• First meetings/demos scheduled

User Communication

At start: Confirm understanding and list deliverables

Understood. I'll orchestrate cross-team synchronization between {team-a} and {team-b}.

This will establish:
- Dependency mapping and integration points
- Sync meeting cadence ({frequency})
- Blocker tracking with escalation
- API contracts and change protocol
- Knowledge sharing framework

Expected duration: 20-30 minutes.

Starting orchestration...

During: Update progress with clear indicators

✓ = Complete
⏳ = In progress
❌ = Error/blocked
⚠️ = Warning/attention needed

At end: Summary report with status and next steps (see Step 6.2 above)

Error Handling

Teams Not Found:

❌ Team not found in project roster

Teams specified: {team-a}, {team-b}
Missing: {team-name}

Action: Verify team names or add to project roster
Command: /team-roster add {team-name}

No Architecture Available:

⚠️ No architecture documentation found

Cannot automatically map dependencies without:
- Software Architecture Document
- Component diagrams
- Service definitions

Recommendation: Conduct manual dependency mapping workshop
Alternative: Create architecture first with /flow-inception-to-elaboration

Time Zone Conflict:

⚠️ Significant time zone difference detected

Team A: {timezone-1}
Team B: {timezone-2}
Overlap: {hours} hours

Recommendations:
1. Emphasize async communication
2. Rotate meeting times
3. Record all sync meetings
4. Use written updates heavily

High Blocker Volume:

⚠️ High blocker volume detected

Active blockers: {count} (threshold: 10)
P0/P1 blockers: {count}

Recommendations:
1. Increase sync frequency to daily
2. Dedicated blocker resolution session
3. Executive escalation for resource allocation
4. Consider team reorganization

Success Criteria

This orchestration succeeds when:

• Dependencies fully mapped with criticality
• Integration points documented with contracts
• Sync cadence established and agreed
• First sync meeting scheduled
• Blocker tracking operational
• Escalation paths defined and communicated
• Knowledge sharing framework in place
• Both teams trained on processes

Metrics to Track

During orchestration, track:

• Dependency coverage: % of components analyzed
• Integration documentation: % with contracts
• Blocker age: Average days open
• Meeting attendance: % of required attendees
• Knowledge sharing: Patterns documented

Ongoing metrics (post-setup):

• Blocker resolution velocity
• Integration stability (breaking changes)
• Meeting effectiveness scores
• Cross-team collaboration index
• Knowledge reuse rate

Common Failure Modes

Dependency Drift

Symptoms: Teams unaware of each other's changes, integration breaks Remediation:

1. Enforce change notification protocol
2. Increase sync frequency
3. Add pre-integration testing gate
4. Review and update dependency map quarterly

Meeting Fatigue

Symptoms: Attendance drops, meetings feel unproductive Remediation:

1. Reduce frequency if dependencies stable
2. Shorten meeting duration
3. Focus on blockers only, move other topics async
4. Rotate facilitator to share ownership

Blocker Stagnation

Symptoms: Blockers remain unresolved for weeks Remediation:

1. Escalate immediately per escalation matrix
2. Assign dedicated resources
3. Executive intervention if needed
4. Consider architectural changes to reduce dependencies

API Contract Violations

Symptoms: Breaking changes deployed without notice Remediation:

1. Implement contract testing in CI/CD
2. Enforce change management protocol
3. Post-mortem on violation
4. Improve contract governance

One-Way Communication

Symptoms: One team dominates sync, other team passive Remediation:

1. Rotate meeting facilitator between teams
2. Require equal time allocation
3. Use structured agenda strictly
4. Private check-in with passive team

References

Templates (via $AIWG_ROOT):

• Dependency Map: templates/analysis-design/dependency-map-template.md
• Integration Contract: templates/analysis-design/integration-contract-template.md
• Blocker Card: templates/management/blocker-card.md
• Escalation Matrix: templates/management/escalation-matrix-template.md
• Sync Agenda: templates/management/cross-team-sync-agenda-template.md
• Demo Agenda: templates/management/demo-agenda-template.md

Related Flows:

• flow-risk-management-cycle.md (for dependency risks)
• flow-architecture-evolution.md (for integration architecture)
• flow-change-control.md (for API changes)

Multi-Agent Patterns:

• docs/multi-agent-coordination-pattern.md
• docs/orchestrator-architecture.md