a2host/.agents/skills/scrum-multi-agent-orchestration/SKILL.md

10 KiB

name description
scrum-multi-agent-orchestration Multi-agent orchestration framework implementing Scrum agile methodology for software development. Coordinates specialized agent roles (Product Owner, Scrum Master, Tech Lead, Frontend, Backend, QA, and Code Reviewer) using hierarchical, sequential, and parallel workflows, contract-first handoffs, and Antigravity subagents.

Scrum Multi-Agent Orchestration

A specialized multi-agent engineering framework that applies Scrum Agile Methodology to coordinated AI agent teams. Each agent is assigned a dedicated software development role with clear boundaries, responsibilities, and communication protocols.

This skill builds upon the foundational multi-agent patterns from qodex-ai/ai-agent-skills (MessageBroker, SharedMemory, WorkflowManager, and Benchmarking) and connects them directly with Antigravity's subagent capabilities (define_subagent, invoke_subagent, and send_message).


1. Scrum Multi-Agent Roles

In this methodology, the master orchestrator decomposes user requests into sprints and delegates execution across 7 specialized roles:

                      [ User / Stakeholder ]
                               │
                               ▼
                    [ Product Owner (PO) ]
                  (Stories & Acceptance Criteria)
                               │
                               ▼
               [ Scrum Master / Orchestrator ]
               (Sprint Planning & Task DAG)
                               │
                               ▼
                   [ Tech Lead / Architect ]
               (API Contracts & System Design)
                               │
                ┌──────────────┴──────────────┐
                ▼                             ▼
      [ Backend Developer ]         [ Frontend Developer ]
    (APIs, Logic, Data models)    (UI, UX, Components, A11y)
                └──────────────┬──────────────┘
                               │
                               ▼
                     [ QA / Test Engineer ]
                 (Automated Tests & AC Verif.)
                               │
                               ▼
                 [ Code Reviewer & Auditor ]
               (Security, Clean Code, DoD)

Role Breakdown

Role Responsibility Tools Required Output Deliverable
Product Owner (PO) Clarifies user requests, writes User Stories with Gherkin Acceptance Criteria (Given/When/Then), prioritizes backlog. Codebase inspection, Read files User Story specification & AC checklist
Scrum Master (Orchestrator) Builds the execution DAG, handles dependency handoffs, unblocks agents, tracks sprint status. Subagent tools, Messaging tools Sprint Workflow Plan & Task assignments
Tech Lead / Architect Designs data models, API schema contracts, interface specifications, and component hierarchies. Read files, Codebase search Contract specification (contract.json / TypeScript types)
Backend Developer Implements backend routes, services, database migrations, and business logic adhering to the contract. Write files, Edit files, Terminal Tested API endpoints & backend logic
Frontend Developer Builds responsive UI components, state management, and animations adhering to the design system. Write files, Edit files, Terminal Modern, accessible UI components
QA / Test Engineer Writes unit and integration tests; runs automated test suites to verify all acceptance criteria. Terminal, Read/Write files Test report & coverage validation
Code Reviewer Audits code for security (OWASP), accessibility (WCAG 2.1 AA), linting, and Definition of Done. Read files, Codebase search PR approval & DoD sign-off

2. Orchestration Patterns Applied to Scrum

This framework combines the 4 key multi-agent patterns from qodex-ai:

A. Hierarchical Pattern (Scrum Master Supervision)

The Scrum Master acts as the central coordinator, delegating tasks and listening to notifications without polling loops. When a subtask finishes, the orchestrator triggers the next dependent subagent.

B. Sequential Pattern (Contract-First Flow)

Certain stages must execute sequentially:

  1. Product Owner defines requirements.
  2. Tech Lead publishes the contract specification.
  3. Developers write code.
  4. QA tests the code.
  5. Reviewer signs off.

C. Parallel Pattern (Concurrent Development)

Once the Tech Lead defines the API contract in shared memory:

  • Backend Developer implements the server endpoints.
  • Frontend Developer mocks or consumes the endpoints and builds the UI. Both agents execute concurrently without blocking each other.

D. Consensus & Verification Pattern (Definition of Done)

Before marking a story as DONE:

  • The QA Engineer checks test passes.
  • The Code Reviewer verifies security and coding standards.
  • The Product Owner confirms all acceptance criteria are met.

3. Implementation with Antigravity Subagents

In Antigravity, subagents are defined using define_subagent and executed using invoke_subagent.

1. Defining Roles Dynamically

# Tech Lead / Architect (Read-only tools)
define_subagent(
    Name="scrum-tech-lead",
    Role="Software Architect",
    Description="Designs API contracts, data schemas, and component architecture.",
    EnableWriteTools=False,
    EnableSubagentTools=False,
    EnableMCPTools=False,
    SystemPrompt="You are the Tech Lead. Generate precise TypeScript interfaces and API specs before coding starts."
)

# Backend Developer (Write & command tools)
define_subagent(
    Name="scrum-backend-dev",
    Role="Backend Developer",
    Description="Implements backend endpoints, business logic, and database models.",
    EnableWriteTools=True,
    EnableSubagentTools=False,
    EnableMCPTools=False,
    SystemPrompt="You are the Backend Developer. Implement endpoints strictly adhering to the Tech Lead contract."
)

# Frontend Developer (Write & command tools)
define_subagent(
    Name="scrum-frontend-dev",
    Role="Frontend Developer",
    Description="Implements UI components, styling, animations, and state management.",
    EnableWriteTools=True,
    EnableSubagentTools=False,
    EnableMCPTools=False,
    SystemPrompt="You are the Frontend Developer. Build mobile-first, accessible, responsive components matching design standards."
)

2. Invoking Parallel Subagents

# Launch Backend in parallel
invoke_subagent(
    TypeName="scrum-backend-dev",
    Role="Backend Developer",
    Prompt="Implement the login endpoint in src/api/auth.py using the contract at contracts/auth_contract.json",
    Workspace="inherit"
)

# Launch Frontend in parallel
invoke_subagent(
    TypeName="scrum-frontend-dev",
    Role="Frontend Developer",
    Prompt="Implement the LoginForm component in src/components/LoginForm.tsx using the contract at contracts/auth_contract.json",
    Workspace="inherit"
)

3. Asynchronous Messaging & Handoff

Agents communicate using Antigravity's send_message or the internal MessageBroker and SharedMemory:

from agent_communication import MessageBroker, Message, MessageType, SharedMemory

memory = SharedMemory()
memory.write("api_contract", {
    "endpoint": "/api/v1/auth/login",
    "method": "POST",
    "payload": {"username": "string", "password": "string"}
})

4. End-to-End Sprint Workflow

Step 1: Sprint Planning & User Story Creation

  1. Product Owner receives user requirement.
  2. Generates User Story with Gherkin acceptance criteria:
    • Given preconditions
    • When user action
    • Then expected result
  3. Estimates story points.

Step 2: Architecture & Contract Specification

  1. Tech Lead inspects the existing codebase.
  2. Creates contract files (e.g., OpenAPI schemas or TypeScript .d.ts types).
  3. Posts contracts to shared workspace or artifact.

Step 3: Concurrent Sprint Execution

  1. Scrum Master triggers Frontend and Backend agents simultaneously.
  2. Both agents write code, run linters, and verify against the shared contract.

Step 4: QA & Automated Testing

  1. QA Engineer writes integration tests that simulate user workflows.
  2. Executes tests in terminal (npm test, pytest, etc.).
  3. Verifies each acceptance criterion. If a test fails, sends feedback message to the responsible dev agent.

Step 5: Code Review & Definition of Done (DoD)

The Code Reviewer verifies:

  • All acceptance criteria pass.
  • No regression or broken builds.
  • Code follows project style & architectural conventions.
  • Accessibility (WCAG 2.1 AA) and security requirements met.
  • Story status transitions to DONE.

5. Scripts and Utilities

The skill includes the utilities from qodex-ai plus the Scrum orchestrator:


6. Proactive Recommendations

Tip

When executing complex, multi-component features with this skill, recommend the user trigger the /teamwork-preview slash command to visualize agent roles and tasks dynamically in the chat interface.