or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

examples

edge-cases.md real-world-scenarios.md

guides

brownfield.md development-phase.md error-recovery.md planning-phase.md quick-start.md

reference

agent-teams.md agents.md api-patterns.md cli.md configuration.md expansion-packs.md programmatic-api.md tasks.md templates.md workflows.md

index.md

tile.json

Agent Teams

Pre-configured bundles of AI agents optimized for different project types and development phases. Agent teams simplify deployment by packaging related agents with their workflows, making it easy to load the right capabilities for your use case.

Quick Reference

Available Teams

Team ID	Agents	Use Case	Platform
`team-fullstack`	6 planning agents	Full lifecycle planning	Web platforms
`team-ide-minimal`	4 dev agents	Development only	Desktop IDEs
`team-no-ui`	5 planning agents	Backend/service planning	Web platforms
`team-all`	All 10 agents	Maximum flexibility	Any

Team Structure

interface AgentTeam {
  id: string;                       // Team identifier
  name: string;                     // Display name
  description: string;              // Purpose and use case
  recommended_platform: string;     // Best platform for this team
  workflow_coverage: string[];      // Supported workflows
  phase_coverage: string[];         // Planning, Development, Both
  agents: string[];                 // Agent IDs included
  when_to_use: string;              // Usage guidance
}

Core Teams

team-fullstack

Complete full-stack development team for all greenfield and brownfield workflows.

interface TeamFullStack {
  id: 'team-fullstack';
  name: 'Team Fullstack';
  icon: '🚀';
  description: 'Team capable of full stack, front end only, or service development';
  
  agents: [
    'bmad-orchestrator',  // Master coordinator
    'analyst',            // Business Analyst
    'pm',                 // Product Manager
    'ux-expert',          // UX/UI Design Specialist
    'architect',          // Software Architect
    'po'                  // Product Owner
  ];

  platform: 'Web platforms (ChatGPT, Claude, Gemini)';
  phase: 'Planning + Validation';
  
  workflows: [
    'greenfield-fullstack',
    'greenfield-service',
    'greenfield-ui',
    'brownfield-fullstack',
    'brownfield-service',
    'brownfield-ui'
  ];

  output: [
    'project-brief.md',
    'prd.md',
    'front-end-spec.md',
    'fullstack-architecture.md',
    'Sharded documents'
  ];

  whenToUse: [
    'Full product development lifecycle',
    'Both planning and implementation phases',
    'Web or mobile applications',
    'Need complete team capabilities',
    'Multiple project types supported'
  ];
}

Team Composition:

Agent	Role	Phase
BMad Orchestrator	Master coordinator, workflow guidance	All
Analyst (Mary)	Market research, brainstorming, project briefs	Planning
PM	Product requirements, PRD creation	Planning
UX Expert	UI/UX specifications, frontend design	Planning
Architect	System architecture, technical specs	Planning
PO (Sarah)	Document validation, sharding, backlog management	Planning/Development

Typical Workflow:

Planning Phase (Web UI): Orchestrator → Analyst → PM → UX Expert → Architect → PO
Development Phase (IDE): SM → Dev → QA (Note: SM, Dev, QA not included, use IDE agents)

Use Cases:

Building production applications from scratch
Extending existing applications
Full-stack web applications
SaaS platforms
Enterprise applications
APIs and microservices
Frontend-only applications

Usage:

# Load from web-bundles/ directory
# Contains all 6 agents in single file
# Use on ChatGPT, Claude, or Gemini

team-ide-minimal

Minimal development team for IDE-based development phase only.

interface TeamIDEMinimal {
  id: 'team-ide-minimal';
  name: 'Team IDE Minimal';
  icon: '⚡';
  description: 'Only the bare minimum for the IDE PO SM dev qa cycle';
  
  agents: [
    'po',   // Product Owner
    'sm',   // Scrum Master
    'dev',  // Developer
    'qa'    // QA Engineer
  ];

  platform: 'Desktop IDEs (Cursor, Claude Code, Windsurf)';
  phase: 'Development + QA';
  
  workflows: null;  // Assumes planning done elsewhere

  assumptions: [
    'Planning completed separately',
    'Focus on implementation only',
    'Working from existing PRD and architecture',
    'IDE-based development workflow',
    'Lean, focused development team'
  ];

  workflow: {
    1: 'Prerequisites: PRD and architecture documents already exist';
    2: 'Story Preparation: PO shards docs → SM creates story files';
    3: 'Development Cycle: Dev implements → QA reviews → repeat';
  };

  whenToUse: [
    'Development-only phase',
    'Working from completed planning',
    'Small teams or solo developers',
    'Quick prototyping',
    'Brownfield development where specs exist'
  ];
}

Team Composition:

Agent	Role	Primary Activity
PO (Sarah)	Product Owner	Validate stories, shard documents, process stewardship
SM (Bob)	Scrum Master	Create story files with complete context
Dev (James)	Developer	Implement stories, update code
QA (Quinn)	QA Engineer	Review implementation, quality gates

Note: This team assumes planning (Analyst, PM, Architect) was done elsewhere. If you need planning capabilities, use Team Fullstack or Team No-UI.

Usage:

# Load agents individually in IDE
# Or reference in .cursorrules, .claude/, etc.

team-no-ui

Backend and service development team without UI components.

interface TeamNoUI {
  id: 'team-no-ui';
  name: 'Team No-UI';
  icon: '🔧';
  description: 'Backend/service development team without UX Expert';
  
  agents: [
    'bmad-orchestrator',  // Master coordinator
    'analyst',            // Business Analyst
    'pm',                 // Product Manager
    'architect',          // Software Architect (backend-focused)
    'po'                  // Product Owner
  ];

  platform: 'Web platforms';
  phase: 'Planning + Validation';
  
  workflows: [
    'greenfield-service',
    'brownfield-service'
  ];

  output: [
    'project-brief.md',
    'prd.md',
    'architecture.md',
    'Sharded documents'
  ];

  whenToUse: [
    'Backend/API development only',
    'Microservices architecture',
    'Data processing pipelines',
    'CLI tools and utilities',
    'No user interface required',
    'Service-to-service integrations'
  ];
}

Team Composition:

Agent	Role	Focus
BMad Orchestrator	Master coordinator	Workflow guidance
Analyst (Mary)	Business Analyst	Market research, requirements
PM	Product Manager	API requirements, PRD
Architect	Software Architect	Backend architecture, API design
PO (Sarah)	Product Owner	Validation, sharding

Omitted: UX Expert (no UI design needed)

Typical Workflow:

Planning Phase: Orchestrator → Analyst → PM → Architect → PO
Development Phase: SM → Dev → QA (use IDE agents)

Use Cases:

REST APIs
GraphQL services
Microservices
Background jobs and workers
Data pipelines
Integration services
System utilities
Command-line tools

Architecture Focus:

API design and contracts
Service integration patterns
Database architecture
Authentication/authorization
Performance and scalability
No frontend architecture needed

team-all

Complete agent bundle with all available agents for maximum flexibility.

interface TeamAll {
  id: 'team-all';
  name: 'Team All';
  icon: '🌟';
  description: 'All agents bundled together for maximum flexibility';
  
  agents: [
    'bmad-orchestrator',  // Master coordinator
    'analyst',            // Business Analyst
    'pm',                 // Product Manager
    'architect',          // Software Architect
    'ux-expert',          // UX/UI Design Specialist
    'po',                 // Product Owner
    'sm',                 // Scrum Master
    'dev',                // Developer
    'qa',                 // QA Engineer
    'bmad-master'         // Legacy (backward compatibility)
  ];

  platform: 'Any';
  phase: 'All phases';
  workflows: 'All workflows';

  features: [
    'Orchestrator for workflow coordination',
    'Complete planning team',
    'Complete development team',
    'Role-switching capability',
    'Maximum flexibility'
  ];

  whenToUse: [
    'Unsure which agents you'll need',
    'Maximum flexibility required',
    'Learning BMad Method',
    'Exploratory projects',
    'Switching between different workflows',
    'Working across multiple project types'
  ];
}

All 10 agents included:

BMad Orchestrator - Master coordinator
Analyst (Mary) - Business Analyst
PM - Product Manager
Architect - Software Architect
UX Expert - UX/UI Design Specialist
PO (Sarah) - Product Owner
SM (Bob) - Scrum Master
Dev (James) - Developer
QA (Quinn) - QA Engineer
BMad Master - Legacy agent (backward compatibility)

Trade-offs:

Pros: Complete flexibility, all capabilities available, no agent switching needed
Cons: Larger bundle size, potentially overwhelming for beginners, may include unused agents

Use Cases:

Learning and exploration
Multi-phase projects with changing needs
Consulting work across different project types
Educational purposes
Rapid prototyping with changing requirements

Note: For production use, consider using a focused team (Fullstack, IDE Minimal, or No-UI) for better organization and smaller bundle sizes.

Team Selection Guide

interface TeamSelectionGuide {
  // Web Platform Planning
  webPlatformPlanning: {
    fullStack: 'Use team-fullstack';
    backendOnly: 'Use team-no-ui';
    needOrchestration: 'Use team-all';
  };

  // Desktop IDE Development
  ideDevelopment: {
    developmentOnly: 'Use team-ide-minimal';
    needPlanning: 'Use team-fullstack or team-all';
    fullLifecycle: 'Use team-all';
  };

  // Project Type
  byProjectType: {
    webApp: 'team-fullstack';
    api: 'team-no-ui';
    spa: 'team-fullstack';
    microservice: 'team-no-ui';
    fullStack: 'team-fullstack';
  };

  // Phase Focus
  byPhase: {
    planningOnly: 'team-fullstack or team-no-ui';
    developmentOnly: 'team-ide-minimal';
    allPhases: 'team-all';
  };
}

Team Loading

Web Platforms

interface WebPlatformLoading {
  location: 'web-bundles/teams/{team-id}.txt';
  platforms: ['ChatGPT', 'Claude', 'Gemini'];
  
  process: {
    1: 'Find team bundle file';
    2: 'Copy entire file contents';
    3: 'Paste into platform';
    4: 'All agents available immediately';
  };

  features: [
    'All agents in single file',
    'All dependencies included',
    'No separate loading needed'
  ];
}

Desktop IDEs

interface IDELoading {
  method: 'Individual agent files or team configuration';
  
  cursor: {
    option1: 'Reference team in .cursorrules';
    option2: 'Load individual agents as needed';
  };

  claudeCode: {
    option1: 'Team files in .claude/ directory';
    option2: 'Individual agent files';
  };

  windsurf: {
    option1: 'Reference team in .windsurfrules';
    option2: 'Load agents individually';
  };
}

Team Dependencies

Teams automatically include all agent dependencies:

interface TeamDependencies {
  // When loading a team, all dependencies are bundled
  included: [
    'Agent definitions',
    'Task files (from agent dependencies)',
    'Template files (from agent dependencies)',
    'Checklist files (from agent dependencies)',
    'Data files (from agent dependencies)'
  ];

  // Example: team-fullstack includes
  agents: ['orchestrator', 'analyst', 'pm', 'ux-expert', 'architect', 'po'];
  tasks: [
    'shard-doc', 'advanced-elicitation',
    'facilitate-brainstorming-session', 'create-deep-research-prompt',
    'generate-ai-frontend-prompt', 'correct-course'
  ];
  templates: [
    'project-brief-tmpl', 'prd-tmpl', 'brownfield-prd-tmpl',
    'market-research-tmpl', 'competitor-analysis-tmpl',
    'architecture-tmpl', 'fullstack-architecture-tmpl',
    'brownfield-architecture-tmpl', 'front-end-spec-tmpl',
    'front-end-architecture-tmpl', 'brainstorming-output-tmpl'
  ];
  checklists: [
    'po-master-checklist', 'pm-checklist', 'architect-checklist'
  ];
  data: [
    'bmad-kb', 'technical-preferences', 'elicitation-methods',
    'brainstorming-techniques'
  ];
}

Team Workflows

Each team defines compatible workflows:

interface TeamWorkflows {
  // Team Fullstack workflows (all 6)
  fullstack: [
    'greenfield-fullstack',
    'greenfield-service',
    'greenfield-ui',
    'brownfield-fullstack',
    'brownfield-service',
    'brownfield-ui'
  ];

  // Team No-UI workflows (service-focused)
  noUI: [
    'greenfield-service',
    'brownfield-service'
  ];

  // Team IDE Minimal workflows (none - uses existing docs)
  ideMinimal: null;  // Assumes PRD and architecture exist

  // Team All workflows (all workflows)
  all: [
    'All greenfield and brownfield workflows'
  ];
}

Team File Locations

IDE Installation

Agent team definitions are stored in:

.bmad-core/agent-teams/
├── team-fullstack.yaml
├── team-ide-minimal.yaml
├── team-no-ui.yaml
└── team-all.yaml

Web Bundles

Pre-built team bundles for web platforms:

dist/teams/
├── team-fullstack.txt
├── team-ide-minimal.txt
├── team-no-ui.txt
└── team-all.txt

# Or in your project after installation:
web-bundles/teams/
├── team-fullstack.txt
├── team-ide-minimal.txt
├── team-no-ui.txt
└── team-all.txt

Custom Teams

Creating Custom Teams

# my-custom-team.yaml
id: my-custom-team
name: My Custom Team
description: Specialized team for my workflow
recommended_platform: web
phase_coverage: [planning, development]
workflow_coverage: [greenfield-fullstack]

agents:
  - analyst
  - pm
  - architect
  - dev

when_to_use: "My specific use case"

Building Team Bundles

# Build team bundles (creates web bundles)
npx bmad-method build --teams-only

# Output: dist/teams/{team-id}.txt

Team Best Practices

Planning vs Development

Planning Phase: Use comprehensive teams

Team Fullstack (with UI)
Team No-UI (without UI)
Load in web platforms (ChatGPT, Claude, Gemini)

Development Phase: Use focused teams

Team IDE Minimal
Individual agents (SM, Dev, QA)
Load in desktop IDEs

Team Sizing

Larger teams (Fullstack, All):

More capabilities
Larger context window required
Slower to load
Better for planning

Smaller teams (IDE Minimal):

Focused capabilities
Faster to load
Lighter context
Better for development

Workflow Alignment

Always ensure team includes agents needed for chosen workflow:

Greenfield Fullstack → requires UX Expert → use Team Fullstack
Greenfield Service → no UX needed → use Team No-UI
Development only → no planning agents → use Team IDE Minimal

Context Window Management

For AI platforms with limited context:

Use smaller, focused teams
Load agents individually as needed
Start with orchestrator, add specialists on demand
Clear context between major phase transitions

Expansion Pack Teams

interface ExpansionPackTeams {
  // Expansion packs include domain-specific teams
  godotGameTeam: {
    pack: 'bmad-godot-game-dev';
    team: 'godot-game-team';
    agents: 'Game-specific agents';
  };

  creativeWritingTeam: {
    pack: 'bmad-creative-writing';
    team: 'agent-team';
    agents: 'Writing-specific agents';
  };

  // Located in expansion pack directories
  location: '.{pack-name}/agent-teams/{team-id}.yaml';
}

Version

Tile

Files

agent-teams.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/reference/

Agent Teams

Quick Reference

Available Teams

Team Structure

Core Teams

team-fullstack

team-ide-minimal

team-no-ui

team-all

Team Selection Guide

Team Loading

Web Platforms

Desktop IDEs

Team Dependencies

Team Workflows

Team File Locations

IDE Installation

Web Bundles

Custom Teams

Creating Custom Teams

Building Team Bundles

Team Best Practices

Planning vs Development

Team Sizing

Workflow Alignment

Context Window Management

Expansion Pack Teams

agent-teams.mddocs/reference/