ros/BMAD-METHOD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

agent team workflows

Browse Source
This commit is contained in:
Brian Madison
2025-06-08 17:34:38 -05:00
parent 54406fa871
commit f1fa6256f0
31 changed files with 2280 additions and 938 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
bmad-core/data/bmad-kb.md
View File

@@ -18,7 +18,7 @@
- [Business Analyst](#business-analyst)
- [Product Manager](#product-manager)
- [Architect](#architect)
- [Design Architect](#design-architect)
- [UI Architect](#ui-architect)
- [Product Owner](#product-owner)
- [Scrum Master](#scrum-master)
- [Developer](#developer)
@@ -370,7 +370,7 @@ npm run validate
- Technology selection
- Integration planning
### Design Architect
### UI Architect
**Name**: Jane (Web) / Millie (IDE)
**Purpose**: UI/UX and frontend architecture
@@ -581,8 +581,8 @@ bmad-core/
├── data/ # Knowledge bases and preferences
└── ide-agents/ # Standalone IDE agent files
agents/ # YAML agent configurations
bundles/ # Bundle configurations (team-*.yml)
agents/ # Individual agent YAML configurations
agent-teams/ # Team bundle configurations (team-*.yml)
tools/ # Build tooling and scripts
dist/ # Build output
```

28
bmad-core/ide-agents/bmad.ide.md Normal file
View File

@@ -0,0 +1,28 @@
# /bmad
You are BMad, the BMAD Method orchestrator and expert guide.
## Expertise
- BMAD Method implementation
- Agent creation and configuration
- Team composition and dynamics
- Expansion pack development
## Approach
I provide hands-on guidance for customizing and extending BMAD to your specific needs.
## Focus
Making BMAD work perfectly for your project through thoughtful agent selection and configuration.
---
When activated with /bmad, I can help you:
- Create new agents or teams
- Build expansion packs
- Optimize your BMAD workflow
- Answer any BMAD Method questions
Available utilities: create-agent, create-ide-agent, create-team, create-expansion-pack

132
bmad-core/utils/create-agent.md Normal file
View File

@@ -0,0 +1,132 @@
# Create Agent Utility
This utility helps you create a new BMAD agent for web platforms (Gemini, ChatGPT, etc.).
## Process
Follow these steps to create a new agent:
### 1. Gather Basic Information
Ask the user for:
- **Agent ID**: A short, lowercase identifier (e.g., `data-analyst`, `security-expert`)
- **Agent Name**: The character name (e.g., "Elena", "Marcus")
- **Title**: Professional title (e.g., "Data Analyst", "Security Expert")
- **Description**: A brief description of the agent's role and primary focus
### 2. Define Personality and Expertise
Ask about:
- **Personality traits**: How should this agent behave? (professional, friendly, detail-oriented, etc.)
- **Communication style**: How do they speak? (formal, casual, technical, empathetic)
- **Expertise areas**: What are they exceptionally good at?
- **Years of experience**: How senior are they in their role?
- **Motivations**: What drives them to excel?
### 3. Identify Capabilities
Determine what the agent can do:
- **Existing tasks**: Which existing tasks from `/bmad-core/tasks/` should this agent know?
- **New tasks needed**: Does this agent need any specialized tasks that don't exist yet?
- **Templates used**: Which document templates will this agent work with?
- **Checklists**: Which quality checklists apply to this agent's work?
### 4. Create the Persona File
Create `/bmad-core/personas/{agent-id}.md` with this structure:
```markdown
# {Agent Name} - {Title}
## Character Profile
**Name:** {Agent Name}
**Title:** {Title}
**Experience:** {Years} years in {field}
## Personality
{Describe personality traits, communication style, and approach to work}
## Core Expertise
{List main areas of expertise and specialization}
## Responsibilities
{List key responsibilities in bullet points}
## Working Style
{Describe how they approach problems, collaborate, and deliver results}
## Motivations
{What drives them to excel in their role}
## Catchphrases
{Optional: Any signature phrases or ways of speaking}
```
### 5. Create the Agent Configuration
Create `/agents/{agent-id}.yml` with this structure:
```yaml
agent:
id: {agent-id}
name: {Agent Name}
title: {Title}
description: >-
{Full description of the agent's role and value}
persona: {agent-id}
customize: >-
{Any specific behavioral customizations}
dependencies:
tasks:
- {list of task IDs}
templates:
- {list of template IDs}
checklists:
- {list of checklist IDs}
data:
- {list of data file IDs}
utils:
- template-format
```
### 6. Create Any New Tasks
If new tasks were identified, create them in `/bmad-core/tasks/{task-name}.md`
### 7. Test and Validate
1. Run `npm run validate` to check configuration
2. Run `npm run build:agent -a {agent-id}` to build the agent
3. Review the generated output in `/dist/agents/{agent-id}.txt`
## Example Questions to Ask
1. "What will this agent be called? (ID like 'data-analyst')"
2. "What's their character name? (like 'Elena')"
3. "What's their professional title?"
4. "Describe their main role in 2-3 sentences."
5. "What personality traits should they have?"
6. "How many years of experience do they have?"
7. "What existing tasks should they know? (e.g., create-doc-from-template, execute-checklist)"
8. "Do they need any specialized tasks that don't exist yet?"
9. "Which document templates will they use?"
10. "What motivates them in their work?"
## Important Notes
- Keep personas engaging but professional
- Ensure all referenced tasks, templates, and checklists exist
- Web agents can be more detailed than IDE agents (no size constraints)
- Consider how this agent will collaborate with existing team members
- Run validation after creating to catch any issues

251
bmad-core/utils/create-expansion-pack.md Normal file
View File

@@ -0,0 +1,251 @@
# Create Expansion Pack Utility
This utility helps you create a comprehensive BMAD expansion pack that can include new agents, tasks, templates, and checklists for a specific domain.
## Understanding Expansion Packs
Expansion packs extend BMAD with domain-specific capabilities. They are self-contained packages that can be installed into any BMAD project.
## Process Overview
### Phase 1: Discovery and Planning
#### 1.1 Define the Domain
Ask the user:
- **Pack Name**: Short identifier (e.g., `healthcare`, `fintech`, `gamedev`)
- **Display Name**: Full name (e.g., "Healthcare Compliance Pack")
- **Description**: What domain or industry does this serve?
- **Key Problems**: What specific challenges will this pack solve?
- **Target Users**: Who will benefit from this expansion?
#### 1.2 Gather Examples
Request from the user:
- **Sample Documents**: Any existing documents in this domain
- **Workflow Examples**: How work currently flows in this domain
- **Compliance Needs**: Any regulatory or standards requirements
- **Output Examples**: What final deliverables look like
### Phase 2: Component Design
#### 2.1 Identify Required Agents
For each proposed agent:
- **Role**: What specialist is needed?
- **Expertise**: Domain-specific knowledge required
- **Interactions**: How they work with existing BMAD agents
- **Unique Value**: What can't existing agents handle?
#### 2.2 Design Specialized Tasks
For each task:
- **Purpose**: What specific action does it enable?
- **Inputs**: What information is needed?
- **Process**: Step-by-step instructions
- **Outputs**: What gets produced?
- **Agent Usage**: Which agents will use this task?
#### 2.3 Create Document Templates
For each template:
- **Document Type**: What kind of document?
- **Structure**: Sections and organization
- **Placeholders**: Variable content areas
- **Instructions**: How to complete each section
- **Standards**: Any format requirements
#### 2.4 Define Checklists
For each checklist:
- **Purpose**: What quality aspect does it verify?
- **Scope**: When should it be used?
- **Items**: Specific things to check
- **Criteria**: Pass/fail conditions
### Phase 3: Implementation
#### 3.1 Create Directory Structure
```
expansion-packs/
└── {pack-name}/
├── manifest.yml
├── README.md
├── agents/
│ └── {agent-id}.yml
├── personas/
│ └── {agent-id}.md
├── tasks/
│ └── {task-name}.md
├── templates/
│ └── {template-name}.md
├── checklists/
│ └── {checklist-name}.md
└── ide-agents/
└── {agent-id}.ide.md
```
#### 3.2 Create Manifest
Create `manifest.yml`:
```yaml
name: {Pack Name}
version: 1.0.0
description: >-
{Detailed description of the expansion pack}
author: {Your name or organization}
bmad_version: "4.0.0"
# Files to install
files:
- source: agents/{agent-id}.yml
destination: agents/{agent-id}.yml
- source: personas/{agent-id}.md
destination: bmad-core/personas/{agent-id}.md
- source: tasks/{task-name}.md
destination: bmad-core/tasks/{task-name}.md
# ... more files
# Optional: Update existing teams
team_updates:
- team: team-technical.yml
add_agent: {new-agent-id}
# Post-install message
post_install_message: >-
{Pack Name} installed successfully!
New agents available: {list agents}
New tasks available: {list tasks}
Run 'npm run build' to generate bundles.
```
### Phase 4: Content Creation
#### 4.1 Agent Creation Checklist
For each new agent:
1. Create persona file with domain expertise
2. Create agent configuration YAML
3. Create IDE-optimized version (optional)
4. List all task dependencies
5. Define template usage
6. Add to relevant teams
#### 4.2 Task Creation Guidelines
Each task should:
1. Have a clear, single purpose
2. Include step-by-step instructions
3. Provide examples when helpful
4. Reference domain standards
5. Be reusable across agents
#### 4.3 Template Best Practices
Templates should:
1. Include clear section headers
2. Provide inline instructions
3. Show example content
4. Mark required vs optional sections
5. Include domain-specific terminology
### Phase 5: Testing and Documentation
#### 5.1 Create README
Include:
- Overview of the pack's purpose
- List of all components
- Installation instructions
- Usage examples
- Integration notes
#### 5.2 Test Installation
1. Run `node tools/install-expansion-pack.js {pack-name}`
2. Verify all files copied correctly
3. Build agents to test configurations
4. Run sample scenarios
## Example: Healthcare Expansion Pack
```
healthcare/
├── manifest.yml
├── README.md
├── agents/
│ ├── clinical-analyst.yml
│ └── compliance-officer.yml
├── personas/
│ ├── clinical-analyst.md
│ └── compliance-officer.md
├── tasks/
│ ├── hipaa-assessment.md
│ ├── clinical-protocol-review.md
│ └── patient-data-analysis.md
├── templates/
│ ├── clinical-trial-protocol.md
│ ├── hipaa-compliance-report.md
│ └── patient-outcome-report.md
└── checklists/
├── hipaa-checklist.md
└── clinical-data-quality.md
```
## Interactive Questions Flow
### Initial Discovery
1. "What domain or industry will this expansion pack serve?"
2. "What are the main challenges or workflows in this domain?"
3. "Do you have any example documents or outputs? (Please share)"
4. "What specialized roles/experts exist in this domain?"
### Agent Planning
5. "For agent '{name}', what is their specific expertise?"
6. "What unique tasks would this agent perform?"
7. "How would they interact with existing BMAD agents?"
### Task Design
8. "Describe the '{task}' process step-by-step"
9. "What information is needed to complete this task?"
10. "What should the output look like?"
### Template Creation
11. "What sections should the '{template}' document have?"
12. "Are there any required formats or standards?"
13. "Can you provide an example of a completed document?"
### Integration
14. "Which existing teams should include these new agents?"
15. "Are there any dependencies between components?"
## Important Considerations
- **Domain Expertise**: Ensure accuracy in specialized fields
- **Compliance**: Include necessary regulatory requirements
- **Compatibility**: Test with existing BMAD agents
- **Documentation**: Provide clear usage instructions
- **Examples**: Include real-world scenarios
- **Maintenance**: Plan for updates as domain evolves
## Tips for Success
1. **Start Small**: Begin with 1-2 agents and expand
2. **Get Examples**: Real documents make better templates
3. **Test Thoroughly**: Run complete workflows
4. **Document Well**: Others will need to understand the domain
5. **Iterate**: Refine based on usage feedback

139
bmad-core/utils/create-ide-agent.md Normal file
View File

@@ -0,0 +1,139 @@
# Create IDE Agent Utility
This utility helps you create a new BMAD agent optimized for IDE environments (Cursor, Windsurf, etc.).
## Important Constraints
IDE agents must be **compact and efficient** (target: under 2000 characters) to work well as slash commands.
## Process
### 1. Gather Essential Information
Ask the user for:
- **Agent ID**: Short, lowercase identifier (e.g., `api-expert`, `test-engineer`)
- **Slash command**: The command to activate (e.g., `/api`, `/test`)
- **Core purpose**: ONE primary function (IDE agents should be focused)
### 2. Define Minimal Personality
Keep it brief:
- **One-line personality**: A single trait or approach (e.g., "Direct and solution-focused")
- **Expertise**: 2-3 core skills maximum
- **Style**: How they communicate (brief! e.g., "Concise, code-first responses")
### 3. Identify Essential Capabilities
Be selective - IDE agents should be specialized:
- **1-2 primary tasks**: Only the most essential tasks
- **1 template maximum**: Only if absolutely necessary
- **Skip checklists**: Usually too large for IDE agents
- **Reuse existing tasks**: Creating new tasks for IDE agents is rare
### 4. Create the Compact IDE Agent
Create `/bmad-core/ide-agents/{agent-id}.ide.md` with this structure:
```markdown
# {Slash Command}
You are {Agent Name}, a {title/role}.
## Expertise
- {Skill 1}
- {Skill 2}
- {Skill 3 if essential}
## Approach
{One sentence about how you work}
## Focus
{One sentence about what you prioritize}
---
When activated with {slash command}, immediately focus on {primary purpose}.
```
### 5. Size Optimization Techniques
To keep agents small:
1. **Remove fluff**: No backstory, minimal personality
2. **Use references**: Reference tasks rather than inline instructions
3. **Be specific**: One job done well is better than many done poorly
4. **Trim lists**: Maximum 3-5 bullet points for any list
5. **Avoid examples**: Let referenced tasks handle examples
### 6. Test the Agent
1. Check character count: `wc -c {agent-file}`
2. Ensure it's under 2000 characters
3. Test in your IDE with the slash command
4. Verify it can access referenced tasks
## Example Questions (Keep it Simple!)
1. "What's the slash command? (e.g., /api)"
2. "What's the ONE thing this agent does best?"
3. "In 5 words or less, describe their personality"
4. "What 1-2 existing tasks do they need?"
5. "Any special focus or constraints?"
## Example: Minimal API Expert
```markdown
# /api
You are Alex, an API design expert.
## Expertise
- RESTful API design
- OpenAPI/Swagger specs
- API security patterns
## Approach
I provide immediate, practical API solutions with example code.
## Focus
Clean, secure, well-documented APIs that follow industry standards.
---
When activated with /api, immediately help with API design, endpoints, or specifications.
```
## Size Comparison
❌ **Too Large** (persona-style):
```markdown
Alex is a seasoned API architect with over 10 years of experience
building scalable systems. They are passionate about clean design
and love to share their knowledge. Alex believes that good APIs
are like good conversations - clear, purposeful, and respectful
of everyone's time...
```
(Too much personality, not focused)
✅ **Just Right** (IDE-style):
```markdown
You are Alex, an API design expert.
Focus: RESTful design, OpenAPI specs, security patterns.
Style: Direct solutions with example code.
```
(Minimal, focused, actionable)
## Important Notes
- **One agent, one job** - Don't try to do everything
- **Reference, don't repeat** - Use task dependencies
- **Test the size** - Must be under 2000 characters
- **Skip the story** - No background needed for IDE agents
- **Focus on action** - What they DO, not who they ARE

174
bmad-core/utils/create-team.md Normal file
View File

@@ -0,0 +1,174 @@
# Create Team Utility
This utility helps you create a new BMAD team bundle by combining existing agents.
## Process
### 1. Define Team Basics
Ask the user for:
- **Team ID**: Filename without extension (e.g., `team-frontend`, `team-planning`)
- **Team Name**: Display name (e.g., "Frontend Development Team")
- **Team Description**: What this team is designed to accomplish
- **Target Environment**: Usually "web" for team bundles
### 2. List Available Agents
Show all available agents from `/agents/`:
```
Available agents:
- analyst (Mary) - Project Analyst and Brainstorming Coach
- architect (Fred) - System Architecture Expert
- bmad (BMad) - BMAD Method Orchestrator
- ui-architect (Jane) - UI/UX Architecture Expert
- dev (James) - Full Stack Developer
- devops (Alex) - Platform Engineer
- fullstack-architect (Winston) - Holistic System Designer
- pm (John) - Product Manager
- po (Sarah) - Product Owner
- qa (Quinn) - Test Architect
- sm (Bob) - Scrum Master
- ux-expert (Sally) - UX Design Expert
```
### 3. Select Team Members
For each agent the user wants to include:
1. Confirm the agent ID
2. Ask if they want to customize the persona for this team context
3. Note any special team dynamics or relationships
### 4. Optimize Team Composition
Consider:
- **Role coverage**: Does the team have all necessary skills?
- **Team size**: 3-7 agents is usually optimal
- **Collaboration**: How will these agents work together?
- **Use cases**: What problems will this team solve?
### 5. Create Team Configuration
Create `/agent-teams/{team-id}.yml`:
```yaml
bundle:
name: {Team Name}
description: >-
{Detailed description of the team's purpose and capabilities}
target_environment: web
agents:
- {agent-id-1}
- {agent-id-2}
- {agent-id-3}
# ... more agents
```
#### Using Wildcards
You can use `"*"` (quoted) to include all available agents:
```yaml
agents:
- bmad # Always include bmad first
- "*" # Include all other agents
```
Or mix specific agents with wildcard:
```yaml
agents:
- pm # Product Manager first
- architect # Then Architect
- "*" # Then all remaining agents
```
### 6. Validate and Build
1. Run `npm run validate` to check configuration
2. Run `npm run build` to generate the team bundle
3. Review output in `/dist/teams/{team-filename}.txt`
## Example Teams
### Development Team
```yaml
bundle:
name: Development Team Bundle
description: >-
Core development team for building features from story to deployment
target_environment: web
agents:
- sm # Sprint coordination
- dev # Implementation
- qa # Quality assurance
- devops # Deployment
```
### Planning Team
```yaml
bundle:
name: Planning Team Bundle
description: >-
Strategic planning team for project inception and architecture
target_environment: web
agents:
- analyst # Requirements gathering
- pm # Product planning
- architect # System design
- po # Validation
```
### Full-Stack Team
```yaml
bundle:
name: Full-Stack Team Bundle
description: >-
Complete team for full-stack application development
target_environment: web
agents:
- fullstack-architect # Holistic design
- design-architect # Frontend architecture
- dev # Implementation
- qa # Testing
- devops # Infrastructure
```
## Questions to Ask
1. "What should this team be called? (e.g., 'team-mobile')"
2. "What's the team's display name?"
3. "Describe the team's primary purpose"
4. "Which agents should be on this team? (list agent IDs)"
5. "Any special dynamics between team members?"
6. "What types of projects will this team handle?"
## Tips for Good Teams
- **Start small**: Begin with 3-4 core agents
- **Clear purpose**: Each team should have a specific focus
- **Complementary skills**: Agents should cover different aspects
- **Avoid redundancy**: Don't include agents with overlapping roles
- **Consider workflow**: Order agents by typical workflow sequence
## Common Team Patterns
1. **Scrum Team**: sm, dev, qa, po
2. **Planning Team**: analyst, pm, architect, po
3. **Design Team**: ux-expert, ui-architect, dev
4. **Full Organization**: All agents (for complex projects)
5. **Technical Team**: architect, dev, devops, qa
## Important Notes
- Teams reference existing agents - create agents first
- Keep team descriptions clear and purpose-driven
- Consider creating multiple focused teams rather than one large team
- Test team dynamics by running sample scenarios

8
bmad-core/utils/orchestrator-commands.md
View File

@@ -15,6 +15,14 @@ When these commands are used, perform the listed action:
- `/{agent} {query}`: Ever been talking to the PM and wanna ask the architect a question? Well just like calling bmad, you can call another agent - this is not recommended for most document workflows as it can confuse the LLM.
- `/party-mode`: This enters group chat with all available agents. The AI will simulate everyone available and you can have fun with all of them at once. During Party Mode, there will be no specific workflows followed - this is for group ideation or just having some fun with your agile team.
## Workflow Commands
- `/workflows`: List all available workflows for the current team with descriptions
- `/workflow-start {id}`: Start a specific workflow (use workflow ID or number from list)
- `/workflow-status`: Show current workflow progress, completed artifacts, and next steps
- `/workflow-resume`: Resume a workflow from where you left off (useful after starting new chat)
- `/workflow-next`: Show the next recommended agent and action in current workflow
## Agent-Specific Commands
The `/{agent}` command switches to any agent included in the bundle. The command accepts either:

178
bmad-core/utils/workflow-management.md Normal file
View File

@@ -0,0 +1,178 @@
# Workflow Management
This utility enables the BMAD orchestrator to manage and execute team workflows.
## Workflow Commands
### /workflows
Lists all available workflows for the current team.
Example response:
```
Available workflows:
1. greenfield-mvp - Complete workflow for building a new MVP from scratch
2. fullstack-app - Comprehensive workflow for production-ready applications
3. api-only - API-first development workflow
4. brownfield-enhancement - Enhance existing applications
5. frontend-only - Frontend application development
Use /workflow-start {number or id} to begin a workflow.
```
### /workflow-start {workflow-id}
Starts a specific workflow and transitions to the first agent.
Example: `/workflow-start greenfield-mvp`
### /workflow-status
Shows current workflow progress, completed artifacts, and next steps.
Example response:
```
Current Workflow: Greenfield MVP Development
Stage: Product Planning (2 of 6)
Completed:
✓ Discovery & Requirements
- project-brief (completed by Mary)
In Progress:
⚡ Product Planning
- Create PRD (John) - awaiting input
Next: Technical Architecture
```
### /workflow-resume
Resumes a workflow from where it left off, useful when starting a new chat.
User can provide completed artifacts:
```
User: /workflow-resume greenfield-mvp
I have completed: project-brief, PRD
BMad: I see you've completed Discovery and part of Product Planning.
Based on the greenfield-mvp workflow, the next step is:
- UX Strategy with Sally (ux-expert)
Would you like me to load Sally to continue?
```
### /workflow-next
Shows the next recommended agent and action in the current workflow.
## Workflow Execution Flow
### 1. Starting a Workflow
When a workflow is started:
1. Load the workflow definition
2. Identify the first stage and step
3. Transition to the required agent
4. Provide context about expected inputs/outputs
5. Guide artifact creation
### 2. Stage Transitions
After each artifact is completed:
1. Mark the step as complete
2. Check transition conditions
3. If stage is complete, move to next stage
4. Load the appropriate agent
5. Pass relevant artifacts as context
### 3. Artifact Tracking
Track all created artifacts:
```yaml
workflow_state:
current_workflow: greenfield-mvp
current_stage: planning
current_step: 2
artifacts:
project-brief:
status: completed
created_by: analyst
timestamp: 2024-01-15T10:30:00Z
prd:
status: in-progress
created_by: pm
started: 2024-01-15T11:00:00Z
```
### 4. Workflow Interruption Handling
When user returns after interruption:
1. Ask if continuing previous workflow
2. Request any completed artifacts
3. Analyze provided artifacts
4. Determine workflow position
5. Suggest next appropriate step
Example:
```
User: I'm working on a new app. Here's my PRD and architecture doc.
BMad: I see you have a PRD and architecture document. Based on these artifacts,
it looks like you're following the greenfield-mvp workflow and have completed
stages 1-3. The next recommended step would be:
Stage 4: Validation & Refinement
- Load Sarah (Product Owner) to validate all artifacts
Would you like to continue with this workflow?
```
## Workflow Context Passing
When transitioning between agents, pass:
1. Previous artifacts created
2. Current workflow stage
3. Expected outputs
4. Any decisions or constraints identified
Example transition:
```
BMad: Great! John has completed the PRD. According to the greenfield-mvp workflow,
the next step is UX Strategy with Sally.
/ux-expert
Sally: I see we're in the Product Planning stage of the greenfield-mvp workflow.
I have access to:
- Project Brief from Mary
- PRD from John
Let's create the UX strategy and UI specifications. First, let me review
the PRD to understand the features we're designing for...
```
## Multi-Path Workflows
Some workflows may have multiple paths:
```yaml
conditional_paths:
- condition: "project_type == 'mobile'"
next_stage: mobile-specific-design
- condition: "project_type == 'web'"
next_stage: web-architecture
- default: fullstack-architecture
```
Handle these by asking clarifying questions when needed.
## Workflow Best Practices
1. **Always show progress** - Users should know where they are
2. **Explain transitions** - Why moving to next agent
3. **Preserve context** - Pass relevant information forward
4. **Allow flexibility** - Users can skip or modify steps
5. **Track everything** - Maintain complete workflow state
## Integration with Agents
Each agent should be workflow-aware:
- Know which workflow is active
- Understand their role in the workflow
- Access previous artifacts
- Know expected outputs
- Guide toward workflow goals
This creates a seamless experience where the entire team works together toward the workflow's objectives.