AI Agent System

interface AgentCommand {
  prefix: '*';  // All commands use asterisk prefix
  format: '*<command> [arguments]';
  examples: ['*help', '*create-prd', '*develop-story', '*agent pm'];
}

interface ActivationProtocol {
  steps: {
    1: 'Read complete agent definition file';
    2: 'Adopt persona from agent configuration';
    3: 'Load .bmad-core/core-config.yaml';
    4: 'Greet user with name/role + auto-run *help';
    5: 'Stay in character throughout';
  };

  dependencyResolution: {
    pattern: '{root}/{type}/{name}';
    types: ['tasks', 'templates', 'checklists', 'data', 'utils'];
    loading: 'On-demand when command executed';
  };
}

interface BmadOrchestrator {
  id: 'bmad-orchestrator';
  role: 'Master Orchestrator & BMad Method Expert';
  icon: '🎭';

  commands: {
    '*help': 'Show guide with agents and workflows';
    '*agent [name]': 'Transform into specialized agent';
    '*chat-mode': 'Start conversational mode';
    '*kb-mode': 'Load full BMad knowledge base';
    '*status': 'Show context, agent, progress';
    '*exit': 'Return to BMad or exit';
    '*task [name]': 'Run specific task';
    '*checklist [name]': 'Execute checklist';
    '*workflow [name]': 'Start workflow';
    '*workflow-guidance': 'Help select workflow';
    '*plan': 'Create detailed workflow plan';
    '*plan-status': 'Show plan progress';
    '*plan-update': 'Update plan status';
    '*yolo': 'Toggle skip confirmations';
    '*party-mode': 'Group chat with all agents';
    '*doc-out': 'Output full document';
  };

  useCase: 'Workflow coordination, multi-agent tasks, role switching, when unsure which specialist';
}

# Basic usage
*help                       # Get available commands
*agent pm                   # Transform to Product Manager
*workflow-guidance          # Get workflow selection help
*workflow greenfield-fullstack  # Start specific workflow
*plan                       # Create workflow plan
*status                     # Check current status

# Step 1: Load Orchestrator in web platform
# Copy web-bundles/teams/team-fullstack.txt to ChatGPT

# Step 2: Get workflow guidance
*workflow-guidance
# Orchestrator asks:
# - New project or existing?
# - Full-stack, backend-only, or frontend-only?
# - Provides recommendation

# Step 3: Create detailed plan
*plan
# Orchestrator creates step-by-step plan:
# - Phase 1: Planning (Analyst → PM → UX → Architect → PO)
# - Phase 2: Development (SM → Dev → QA)
# - Estimated artifacts and timeline

# Step 4: Start workflow
*workflow greenfield-fullstack
# Orchestrator guides through each step:
# - Transforms to Analyst for project brief
# - Transforms to PM for PRD
# - Manages handoffs between agents

# Step 5: Check progress
*plan-status
# Shows:
# - Completed steps
# - Current step
# - Remaining steps
# - Artifacts created

# Orchestrator can transform into any agent
*agent pm
# Now operating as Product Manager
# All PM commands available
*create-prd
# ... work with PM ...

*agent dev
# Transforms to Developer
# PM context preserved in documents
*develop-story
# ... work with Dev ...

*exit
# Returns to Orchestrator mode

# Party mode enables multi-agent consultation
*party-mode

# Orchestrator: "Party mode activated! All agents are now available for discussion."
# You can now ask questions and get perspectives from all agents simultaneously

# Example use cases:
# 1. Validate architectural decisions
User: "Should we use microservices or monolith for this project?"
# Gets input from Architect, Dev, PO, and PM perspectives

# 2. Resolve conflicts or uncertainties
User: "The PRD says real-time updates, but architect suggested polling. Which approach?"
# PM and Architect discuss trade-offs together

# 3. Brainstorm solutions
User: "How should we handle file uploads over 100MB?"
# UX Expert, Architect, and Dev collaborate on solution

# Exit party mode
*exit  # Returns to standard Orchestrator mode

# Output complete document content bypassing token limits
*doc-out

# Orchestrator prompts: "Which document would you like me to output?"
# Options automatically detected from docs/ directory:
# 1. docs/prd.md
# 2. docs/architecture.md
# 3. docs/front-end-spec.md
# 4. docs/project-brief.md
# 5. Other (specify path)

# User selects option or provides path
User: 2

# Orchestrator outputs full architecture.md content
# Useful for:
# - Reviewing complete documents without scrolling
# - Copying entire documents to other platforms
# - Validating document completeness
# - Sharing documents with stakeholders

interface Analyst {
  id: 'analyst';
  name: 'Mary';
  role: 'Business Analyst & Strategic Ideation Partner';
  icon: '📊';

  commands: {
    '*help': 'Show available commands';
    '*brainstorm': 'Structured brainstorming with advanced elicitation';
    '*create-project-brief': 'Create initial project brief document';
    '*perform-market-research': 'Conduct market research';
    '*create-competitor-analysis': 'Create competitive analysis';
    '*research-prompt': 'Generate deep research prompts';
  };

  deliverables: [
    'project-brief.md',
    'market-research.md',
    'competitor-analysis.md',
    'brainstorming-output.md'
  ];

  dependencies: {
    tasks: ['advanced-elicitation', 'facilitate-brainstorming-session', 'create-deep-research-prompt'];
    templates: ['project-brief-tmpl', 'market-research-tmpl', 'competitor-analysis-tmpl', 'brainstorming-output-tmpl'];
    data: ['elicitation-methods', 'brainstorming-techniques'];
  };

  useCase: 'Market research, brainstorming, competitive analysis, project briefs';
}

# Basic commands
*create-project-brief       # Create project brief
*perform-market-research    # Market research
*create-competitor-analysis # Competitive analysis
*brainstorm                 # Brainstorming session

# Step 1: Load Analyst agent (Mary)
# File: .bmad-core/agents/analyst.md

# Step 2: Create project brief
*create-project-brief
# Analyst uses project-brief-tmpl.yaml
# Interactive elicitation:
# - Project name and description
# - Target audience
# - Key features
# - Success metrics
# Output: docs/project-brief.md

# Step 3: Optional brainstorming session
*brainstorm
# Analyst uses facilitate-brainstorming-session task
# Presents techniques:
# - Classic Brainstorming
# - SCAMPER
# - Mind Mapping
# User selects technique
# Output: docs/brainstorming-output.md

# Step 4: Market research
*perform-market-research
# Analyst uses create-deep-research-prompt task
# Generates structured research prompts
# User can use prompts for web search
# Output: docs/market-research.md

# Step 5: Competitive analysis
*create-competitor-analysis
# Analyst uses competitor-analysis-tmpl.yaml
# Interactive elicitation for each competitor
# Output: docs/competitor-analysis.md

*brainstorm
# Analyst: "What brainstorming technique would you like to use?"
# Options:
# 1. Classic Brainstorming
# 2. SCAMPER
# 3. Mind Mapping
# 4. Round Robin
# 5. Brainwriting
# 6. Starbursting

# User selects: 2 (SCAMPER)
# Analyst guides through SCAMPER framework:
# - Substitute: What can we substitute?
# - Combine: What can we combine?
# - Adapt: What can we adapt?
# - Modify: What can we modify?
# - Put to other uses: Other uses?
# - Eliminate: What can we eliminate?
# - Reverse: What can we reverse?

# Output: docs/brainstorming-output.md with structured ideas

interface PM {
  id: 'pm';
  role: 'Product Manager';
  icon: '📝';

  commands: {
    '*help': 'Show available commands';
    '*create-prd': 'Create Product Requirements Document';
    '*update-prd': 'Update existing PRD';
    '*doc-out': 'Output complete PRD';
  };

  deliverables: ['prd.md'];

  dependencies: {
    tasks: ['shard-doc', 'index-docs'];
    templates: ['prd-tmpl', 'brownfield-prd-tmpl'];
    checklists: ['pm-checklist'];
  };

  useCase: 'Product requirements, PRD creation, epic/story management';
}

# Basic commands
*create-prd                 # Create new PRD
*update-prd                 # Update existing PRD
*doc-out                    # Output complete PRD

# Step 1: Load PM agent
# File: .bmad-core/agents/pm.md

# Step 2: Create PRD
*create-prd
# PM loads prd-tmpl.yaml template
# Uses create-doc task with interactive mode

# Interactive elicitation for each section:
# Section 1: Project Overview
# PM drafts content, presents with rationale
# Options:
# 1. Proceed to next section
# 2. SCAMPER elicitation
# 3. 5 Whys
# 4. Jobs-to-be-Done
# ... (8 methods total)
# User selects or provides feedback

# Section 2: Epics and Stories
# PM creates epic structure:
# Epic 1: User Authentication
#   Story 1.1: User registration
#   Story 1.2: User login
#   Story 1.3: Password reset
# Epic 2: Product Catalog
#   Story 2.1: Product listing
#   Story 2.2: Product search
# ...

# Section 3: Technical Requirements
# PM gathers tech stack preferences
# References project-brief.md for context

# Output: docs/prd.md (v4 format)
# Contains:
# - Complete project overview
# - All epics with stories
# - Acceptance criteria
# - Technical requirements
# - Non-functional requirements

# Scenario: Architecture suggests PRD changes
*update-prd
# PM:
# - Loads existing docs/prd.md
# - Reviews architecture.md for inconsistencies
# - Identifies sections needing updates
# - Updates PRD with architecture feedback
# - Preserves existing content where appropriate
# Output: Updated docs/prd.md

interface Architect {
  id: 'architect';
  role: 'Software Architect';
  icon: '🏗️';

  commands: {
    '*help': 'Show available commands';
    '*create-architecture': 'Create architecture document';
    '*review-architecture': 'Review for completeness';
  };

  deliverables: [
    'architecture.md',
    'fullstack-architecture.md',
    'front-end-architecture.md'
  ];

  dependencies: {
    tasks: ['shard-doc', 'index-docs'];
    templates: ['architecture-tmpl', 'fullstack-architecture-tmpl', 'brownfield-architecture-tmpl', 'front-end-architecture-tmpl'];
    checklists: ['architect-checklist'];
    data: ['technical-preferences'];
  };

  useCase: 'System design, architecture documents, technical specifications';
}

*create-architecture        # Create architecture document
*review-architecture        # Review for completeness

interface UXExpert {
  id: 'ux-expert';
  role: 'UX/UI Design Specialist';
  icon: '🎨';

  commands: {
    '*help': 'Show available commands';
    '*create-frontend-spec': 'Create frontend specification';
    '*generate-ui-prompt': 'Generate v0/Lovable prompts';
  };

  deliverables: [
    'front-end-spec.md',
    'ui-generation-prompts'
  ];

  dependencies: {
    tasks: ['generate-ai-frontend-prompt'];
    templates: ['front-end-spec-tmpl', 'front-end-architecture-tmpl'];
  };

  useCase: 'UI/UX specifications, frontend design, v0/Lovable prompt generation';
}

*create-frontend-spec       # Create frontend spec
*generate-ui-prompt         # Generate v0/Lovable prompts

interface PO {
  id: 'po';
  name: 'Sarah';
  role: 'Product Owner & Process Steward';
  icon: '🗂️';

  commands: {
    '*help': 'Show available commands';
    '*shard-doc': 'Split large documents';
    '*validate-story-draft': 'Validate story drafts';
    '*correct-course': 'Adjust when off track';
  };

  keyFunctionality: 'Document sharding, backlog preparation';

  dependencies: {
    tasks: ['shard-doc', 'validate-next-story', 'correct-course'];
    checklists: ['po-master-checklist', 'story-draft-checklist'];
  };

  useCase: 'Backlog management, document sharding, artifact validation';
}

*shard-doc                  # Shard PRD/architecture
*validate-story-draft       # Validate story draft
*correct-course             # Correct when off track

interface SM {
  id: 'sm';
  name: 'Bob';
  role: 'Technical Scrum Master - Story Preparation Specialist';
  icon: '📋';

  commands: {
    '*help': 'Show available commands';
    '*draft': 'Create next story with full context';
    '*story-checklist': 'Execute story validation checklist';
    '*correct-course': 'Adjust when off track';
  };

  deliverables: ['Story files with complete implementation context'];

  dependencies: {
    tasks: ['create-next-story', 'create-brownfield-story', 'brownfield-create-epic', 'correct-course'];
    templates: ['story-tmpl'];
    checklists: ['story-draft-checklist'];
  };

  useCase: 'Story creation, epic management, agile process guidance';
}

*draft                      # Draft next story with full context
*story-checklist            # Execute validation checklist
*correct-course             # Correct when off track

interface Dev {
  id: 'dev';
  name: 'James';
  role: 'Expert Senior Software Engineer & Implementation Specialist';
  icon: '💻';

  commands: {
    '*help': 'Show numbered list of commands';
    '*develop-story': 'Implement story tasks sequentially';
    '*explain': 'Explain implementation for learning';
    '*review-qa': 'Apply QA feedback and fixes';
    '*run-tests': 'Execute linting and tests';
  };

  workflowOrder: [
    'Read (first or next) task',
    'Implement task and subtasks',
    'Write tests',
    'Execute validations',
    'Update checkbox with [x] if ALL pass',
    'Update File List',
    'Repeat until complete'
  ];

  criticalRules: [
    'Story contains ALL needed info - never load PRD/architecture',
    'ONLY update Dev Agent Record sections',
    'Never modify Status, Story, Acceptance Criteria, Dev Notes, Testing',
    'Follow develop-story workflow exactly'
  ];

  authorizedEdits: [
    'Task/Subtask checkboxes',
    'Dev Agent Record section',
    'Agent Model Used',
    'Debug Log References',
    'Completion Notes List',
    'File List',
    'Change Log'
  ];

  dependencies: {
    tasks: ['apply-qa-fixes', 'validate-next-story'];
    checklists: ['story-dod-checklist'];
  };

  useCase: 'Code implementation, debugging, refactoring';
}

# Basic commands
*develop-story              # Start implementing story
*explain                    # Explain implementation
*review-qa                  # Apply QA feedback
*run-tests                  # Run tests

# Step 1: Load Dev agent (James)
# File: .bmad-core/agents/dev.md

# Step 2: Start story implementation
*develop-story
# Dev agent workflow:

# 1. Loads story file: docs/stories/1.1.user-authentication.md
#    Story contains ALL context:
#    - Requirements from PRD
#    - Architecture context (selective sections)
#    - Previous story learnings
#    - Technical specifications
#    - Source references

# 2. Reads first task:
#    [ ] Task 1: Create user model
#        [ ] Sub-task 1.1: Define User schema
#        [ ] Sub-task 1.2: Add validation rules
#        [ ] Sub-task 1.3: Create migration

# 3. Implements Task 1:
#    - Creates src/models/User.js
#    - Adds validation
#    - Creates migration file
#    - Writes tests

# 4. Executes validations:
#    - Runs linter
#    - Runs tests
#    - Checks against coding standards

# 5. If ALL validations pass:
#    Updates checkbox: [x] Task 1: Create user model
#    Updates File List in story:
#      - Created: src/models/User.js
#      - Created: src/migrations/001_create_users.js
#      - Created: src/tests/models/User.test.js

# 6. Moves to next task
#    Repeats until all tasks complete

# 7. Updates Dev Agent Record:
#    - Agent Model Used: claude-sonnet-4
#    - Debug Log: .ai/debug-log.md#story-1.1
#    - Completion Notes:
#      * Implemented user model with email validation
#      * Added password hashing with bcrypt
#      * Created comprehensive test suite

# Output: Updated story file with implementation details

# Scenario: QA review found issues
*review-qa
# Dev agent:

# 1. Reads QA feedback in story file:
#    QA Review:
#    - Issue: Missing input validation on email field
#    - Issue: Password strength not enforced
#    - Gate Decision: CONCERNS

# 2. Prioritizes issues:
#    Critical: Password strength (security)
#    Medium: Email validation (data quality)

# 3. Applies fixes:
#    - Adds email regex validation
#    - Implements password strength rules
#    - Updates tests

# 4. Runs tests to verify:
#    npm test
#    All tests pass

# 5. Updates Dev Agent Record:
#    QA Resolutions:
#    - Fixed email validation (added regex)
#    - Added password strength enforcement
#    - All tests passing

# 6. Updates story status:
#    Status: Review (ready for QA re-review)

# Dev agent NEVER:
# - Loads PRD or architecture directly
#   (story contains all needed context)

# - Modifies story sections:
#   * Status
#   * Story description
#   * Acceptance Criteria
#   * Dev Notes
#   * Testing section

# Dev agent ONLY updates:
# - Task checkboxes
# - Dev Agent Record section
# - File List
# - Change Log

# Example of correct behavior:
*develop-story
# Dev reads story, sees:
# Dev Notes:
#   [Source: docs/architecture/tech-stack.md#frameworks]
#   Use Express.js for API routes
# Dev implements using Express (from story context)
# Does NOT load architecture file directly

interface QA {
  id: 'qa';
  name: 'Quinn';
  role: 'Test Architect & Quality Advisor';
  icon: '🧪';

  commands: {
    '*help': 'Show available commands';
    '*review': 'Comprehensive quality review';
    '*gate': 'Quality gate decision (PASS/CONCERNS/FAIL/WAIVED)';
    '*trace': 'Requirements traceability';
    '*risk-profile': 'Risk assessment';
    '*test-design': 'Create test scenarios';
    '*nfr-assess': 'Non-functional requirements assessment';
  };

  gateDecisions: {
    PASS: 'All quality criteria met';
    CONCERNS: 'Issues found but not blocking';
    FAIL: 'Critical issues, must address';
    WAIVED: 'Issues waived by stakeholder';
  };

  deliverables: [
    'Quality gate decisions',
    'Test scenarios',
    'Traceability matrices',
    'Risk profiles',
    'NFR assessments'
  ];

  dependencies: {
    tasks: ['qa-gate', 'trace-requirements', 'risk-profile', 'test-design', 'nfr-assess'];
    templates: ['qa-gate-tmpl'];
    checklists: ['change-checklist'];
    data: ['test-levels-framework', 'test-priorities-matrix'];
  };

  useCase: 'Test architecture, quality gates, requirements traceability, NFR validation';
}

# Basic commands
*review                     # Quality review
*gate                       # Quality gate decision
*trace                      # Requirements traceability
*risk-profile               # Risk assessment
*test-design                # Design test scenarios
*nfr-assess                 # NFR assessment

# Step 1: Load QA agent (Quinn)
# File: .bmad-core/agents/qa.md

# Step 2: Comprehensive review
*review
# QA agent:

# 1. Loads story file: docs/stories/1.1.user-authentication.md
# 2. Reviews implementation:
#    - Checks all tasks completed
#    - Verifies acceptance criteria met
#    - Reviews code quality
#    - Checks test coverage
#    - Validates against architecture

# 3. Executes test-design task:
#    *test-design
#    Creates test scenarios:
#    - Unit tests: User model validation
#    - Integration tests: Auth flow
#    - System tests: End-to-end login
#    Output: docs/qa/1.1-test-scenarios.md

# 4. Performs requirements traceability:
#    *trace
#    Maps:
#    - Story requirements → Implementation
#    - Implementation → Tests
#    - Tests → Acceptance criteria
#    Output: docs/qa/1.1-traceability-matrix.md

# 5. Risk assessment:
#    *risk-profile
#    Identifies risks:
#    - Security: Password storage
#    - Performance: Auth token validation
#    - Maintainability: Code complexity
#    Output: docs/qa/1.1-risk-profile.md

# 6. NFR assessment:
#    *nfr-assess
#    Validates:
#    - Performance: Response time < 200ms
#    - Security: Password hashing
#    - Scalability: Token management
#    Output: docs/qa/1.1-nfr-assessment.md

*gate
# QA agent makes gate decision:

# Scenario 1: All criteria met
# Gate Decision: PASS
# Rationale:
#   - All acceptance criteria satisfied
#   - Test coverage > 80%
#   - Code quality standards met
#   - No security vulnerabilities
#   - Performance requirements met
# Output: docs/qa/1.1-user-authentication-qa-gate.md
# Story status updated to: Done

# Scenario 2: Minor issues found
# Gate Decision: CONCERNS
# Rationale:
#   - Missing input validation on optional fields
#   - Test coverage at 75% (target: 80%)
#   - Can proceed with monitoring
# Issues:
#   1. Add validation for optional email field
#   2. Increase test coverage to 80%
# Output: Story updated with QA feedback
# Dev must address before production

# Scenario 3: Critical issues
# Gate Decision: FAIL
# Rationale:
#   - Security vulnerability: Plain text password storage
#   - Missing authentication middleware
#   - No error handling for failed login
#   - Must address before proceeding
# Output: Story updated with critical issues
# Dev must fix all issues before re-review

# Scenario 4: Issues waived
# Gate Decision: WAIVED
# Rationale:
#   - Performance slightly below target (220ms vs 200ms)
#   - Stakeholder decision: Acceptable for MVP
#   - Documented for future improvement
# Output: Story marked as waived with rationale

interface BmadMaster {
  id: 'bmad-master';
  role: 'Legacy agent';
  icon: '🎓';
  status: 'Superseded by bmad-orchestrator';
  useCase: 'Backward compatibility with older workflows';
  note: 'Included in team-all bundle for backward compatibility';
}

interface SequentialWorkflow {
  greenfieldFullstack: ['Analyst', 'PM', 'UX Expert', 'Architect', 'PO', 'SM', 'Dev', 'QA'];
  greenfieldService: ['Analyst', 'PM', 'Architect', 'PO', 'SM', 'Dev', 'QA'];
  brownfield: ['PM', 'Architect', 'PO', 'SM', 'Dev', 'QA'];
}

interface HandoffPattern {
  pattern: 'Agent creates artifact → hands off to next agent';
  flow: {
    1: 'Analyst → project-brief.md → PM';
    2: 'PM → prd.md → Architect';
    3: 'Architect → architecture.md → PO';
    4: 'PO → sharded docs → SM';
    5: 'SM → story files → Dev';
    6: 'Dev → implementation → QA';
    7: 'QA → validation → Dev (if fixes needed)';
  };
}

interface AgentTransformation {
  // Orchestrator can transform into any agent
  orchestratorCommand: '*agent <agent-id>';

  examples: {
    1: '*agent pm      // Orchestrator → Product Manager';
    2: '*agent dev     // Orchestrator → Developer';
    3: '*exit          // Return to Orchestrator';
  };
}

.bmad-core/agents/
├── bmad-orchestrator.md
├── analyst.md
├── pm.md
├── architect.md
├── ux-expert.md
├── po.md
├── sm.md
├── dev.md
├── qa.md
└── bmad-master.md

interface DesktopIDELoading {
  cursor: {
    method: 'Reference in .cursorrules or load directly via @ symbol';
    example: '@.bmad-core/agents/dev.md';
    config: 'Add agent file paths to .cursorrules';
  };
  claudeCode: {
    method: 'Agent files in .claude/ directory';
    example: '.claude/dev.md';
    activation: 'Reference agent in conversation';
  };
  windsurf: {
    method: 'Reference in .windsurfrules';
    example: 'Include .bmad-core/agents/dev.md content';
    activation: 'Agent automatically loaded on start';
  };
  vscodeExtensions: {
    method: 'Configure in .vscode/settings.json';
    extensions: ['Cline', 'Roo Code', 'GitHub Copilot'];
    example: '{"cline.customInstructions": "@.bmad-core/agents/dev.md"}';
  };

  filePattern: '.bmad-core/agents/{agent-name}.md';
}

# Method 1: Add to .cursorrules
echo "Load .bmad-core/agents/dev.md" >> .cursorrules

# Method 2: Load directly in chat
@.bmad-core/agents/dev.md

# Method 3: Use in instructions
# "Follow the instructions in @.bmad-core/agents/dev.md"

# Agent files automatically discovered in .claude/ directory
# Reference agent in chat:
# "Act as the Dev agent from .claude/dev.md"

// .vscode/settings.json
{
  "cline.customInstructions": [
    "Load instructions from .bmad-core/agents/dev.md",
    "Follow the Dev agent protocol"
  ],
  "roo.agentPath": ".bmad-core/agents/dev.md"
}

interface WebPlatformLoading {
  platforms: ['ChatGPT', 'Claude', 'Gemini', 'Codex Web'];
  format: 'Pre-built web bundles from dist/ or web-bundles/';
  location: 'web-bundles/agents/{agent-name}.txt';
  contents: 'Agent + all dependencies in single file';

  loading: {
    chatgpt: 'Upload .txt file or paste contents';
    claude: 'Upload .txt file as Project Knowledge';
    gemini: 'Paste contents or upload file';
    codexWeb: 'Load via custom instructions';
  };
}

# Step 1: Locate web bundle
# web-bundles/agents/dev.txt

# Step 2: Upload to ChatGPT
# Click '+' button → Upload file → Select dev.txt

# Step 3: Or paste content
# Copy content of dev.txt → Paste in chat → Send

# Step 4: Activate agent
# Agent automatically greets and runs *help

# Step 1: Create or open project
# Click "Projects" → "New Project"

# Step 2: Add agent to Project Knowledge
# Click "Add Knowledge" → Upload web-bundles/agents/dev.txt

# Step 3: Start conversation
# Agent context automatically available
# Type: "Activate Dev agent"

interface CLIToolLoading {
  auggieCLI: {
    globalCommands: '~/.config/augment/commands/';
    workspaceCommands: '.augment/commands/';
    format: 'Custom command files';
  };
  iflowCLI: {
    method: 'Load via configuration file';
    config: 'iflow.config.json';
  };
  geminiCLI: {
    method: 'Paste agent content or reference file';
    activation: 'Include in prompt';
  };
}

## Usage Patterns

### Planning Phase (Web UI)

```typescript { .api }
interface PlanningPhase {
  platform: 'Web-based AI platforms (ChatGPT, Claude, Gemini)';
  sequence: {
    1: 'Load Analyst → conduct research, create project brief';
    2: 'Load PM → create PRD with epics and stories';
    3: 'Load UX Expert (if UI) → create frontend specifications';
    4: 'Load Architect → create technical architecture';
    5: 'Load PO → validate and shard documents';
  };
}

interface DevelopmentPhase {
  platform: 'Desktop IDEs (Cursor, Claude Code, Windsurf)';
  sequence: {
    1: 'Load SM → create detailed story files with context';
    2: 'Load Dev → implement stories sequentially';
    3: 'Load QA → validate, gate, provide feedback';
  };
}

interface FullLifecycle {
  platform: 'Any';
  sequence: {
    1: 'Load Orchestrator';
    2: '*workflow-guidance → select workflow';
    3: 'Orchestrator transforms through agent sequence';
    4: 'Orchestrator manages handoffs and tracks progress';
  };
}

interface AgentDependency {
  resolutionPattern: '{root}/{type}/{name}';

  types: {
    tasks: '.bmad-core/tasks/{task-name}.md';
    templates: '.bmad-core/templates/{template-id}.yaml';
    checklists: '.bmad-core/checklists/{checklist-name}.md';
    data: '.bmad-core/data/{data-file}.md';
  };

  loadingStrategy: 'On-demand when agent executes command';
}

interface CommandExecution {
  // Agent command processing
  steps: {
    1: 'Parse command with * prefix';
    2: 'Load required dependencies';
    3: 'Execute command logic';
    4: 'Update artifacts';
    5: 'Report results to user';
  };

  // Error handling
  errors: {
    unknownCommand: 'Report available commands via *help';
    missingDependency: 'Report missing file path and halt';
    invalidInput: 'Prompt user for correct input';
  };
}