--- name: scrum-multi-agent-orchestration description: 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`](https://github.com/qodex-ai/ai-agent-skills/tree/main/skills/multi-agent-orchestration) (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 ```python # 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 ```python # 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`: ```python 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: - [`scripts/scrum_orchestrator.py`](scripts/scrum_orchestrator.py): Scrum team state manager, persona definitions, and DAG workflow planner. - [`scripts/agent_communication.py`](scripts/agent_communication.py): `MessageBroker`, `SharedMemory`, and `Message` passing protocol. - [`scripts/workflow_management.py`](scripts/workflow_management.py): `WorkflowExecutor`, `Task`, and DAG dependency scheduler. - [`scripts/benchmarking.py`](scripts/benchmarking.py): Metric tracking for agent performance, token cost, and execution duration. - [`examples/scrum_feature_sprint.py`](examples/scrum_feature_sprint.py): Runnable Python simulation of a full Scrum sprint. - [`examples/orchestration_patterns.py`](examples/orchestration_patterns.py): Pattern templates for Sequential, Parallel, and Hierarchical agent teams. --- ## 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.