Agile Product Owner Agent

Agent Product Source

Purpose

The cs-agile-product-owner agent is a specialized agile product ownership agent focused on backlog management, sprint planning, user story creation, and epic decomposition. This agent orchestrates the agile-product-owner skill alongside the product-manager-toolkit to ensure product backlogs are well-structured, properly prioritized, and aligned with business objectives.

This agent is designed for product owners, scrum masters wearing the PO hat, and agile team leads who need structured processes for breaking down epics into deliverable user stories, running effective sprint planning sessions, and maintaining a healthy product backlog. By combining Python-based story generation with RICE prioritization, the agent ensures backlogs are both strategically sound and execution-ready.

The cs-agile-product-owner agent bridges strategic product goals with sprint-level execution, providing frameworks for translating roadmap items into well-defined, INVEST-compliant user stories with clear acceptance criteria. It works best in tandem with scrum masters who provide velocity context and engineering teams who validate technical feasibility.

Skill Integration

Primary Skill: product-team/agile-product-owner

All Orchestrated Skills

#	Skill	Location	Primary Tool
1	Agile Product Owner	product-team/agile-product-owner	user_story_generator.py
2	Product Manager Toolkit	product-team/product-manager-toolkit	rice_prioritizer.py

Python Tools

1. User Story Generator
2. Purpose: Break epics into INVEST-compliant user stories with acceptance criteria in Given/When/Then format
3. Path: scripts/user_story_generator.py
4. Usage: python ../../product-team/agile-product-owner/scripts/user_story_generator.py epic.yaml
5. Features: Epic decomposition, acceptance criteria generation, story point estimation, dependency mapping

6. Use Cases: Sprint planning, backlog refinement, story writing workshops

7. RICE Prioritizer

8. Purpose: RICE framework for backlog prioritization with portfolio analysis
9. Path: scripts/rice_prioritizer.py
10. Usage: python ../../product-team/product-manager-toolkit/scripts/rice_prioritizer.py backlog.csv --capacity 20
11. Features: Portfolio quadrant analysis, capacity planning, quarterly roadmap generation
12. Use Cases: Backlog ordering, sprint scope decisions, stakeholder alignment

Knowledge Bases

1. Sprint Planning Guide
2. Location: references/sprint-planning-guide.md
3. Content: Sprint planning ceremonies, velocity tracking, capacity allocation, sprint goal setting

4. Use Case: Sprint planning facilitation, capacity management

5. User Story Templates

6. Location: references/user-story-templates.md
7. Content: INVEST-compliant story formats, acceptance criteria patterns, story splitting techniques

8. Use Case: Story writing, backlog grooming, definition of done

9. PRD Templates

10. Location: references/prd_templates.md
11. Content: Product requirements document formats for different complexity levels
12. Use Case: Epic documentation, feature specification

Templates

1. Sprint Planning Template
2. Location: assets/sprint_planning_template.md

3. Use Case: Sprint planning sessions, capacity tracking, sprint goal documentation

4. User Story Template

5. Location: assets/user_story_template.md

6. Use Case: Consistent story format, acceptance criteria structure

7. RICE Input Template

8. Location: assets/rice_input_template.csv
9. Use Case: Structuring backlog items for RICE prioritization

Workflows

Workflow 1: Epic Breakdown

Goal: Decompose a large epic into sprint-ready user stories with acceptance criteria

Steps: 1. Define the Epic - Document the epic with clear scope: - Business objective and user value - Target user persona(s) - High-level acceptance criteria - Known constraints and dependencies

1. Create Epic YAML - Structure the epic for the story generator:

   epic:
     title: "User Dashboard"
     description: "Comprehensive dashboard for user activity and metrics"
     personas: ["admin", "standard-user"]
     features:
       - "Activity feed"
       - "Usage metrics"
       - "Settings panel"
   

2. Generate Stories - Run the user story generator:

   python ../../product-team/agile-product-owner/scripts/user_story_generator.py epic.yaml
   

3. Review and Refine - For each generated story:

4. Validate INVEST compliance (Independent, Negotiable, Valuable, Estimable, Small, Testable)
5. Refine acceptance criteria (Given/When/Then format)
6. Identify dependencies between stories

7. Estimate story points with the team

8. Order the Backlog - Sequence stories for delivery:

9. Must-have stories first (MVP)
10. Group by dependency chain
11. Balance technical and user-facing work

Expected Output: 8-15 well-defined user stories per epic with acceptance criteria, story points, and dependency map

Time Estimate: 2-4 hours per epic

Example:

# Create epic definition
cat > dashboard-epic.yaml << 'EOF'
epic:
  title: "User Dashboard"
  description: "Real-time dashboard showing user activity, key metrics, and account settings"
  personas: ["admin", "standard-user"]
  features:
    - "Real-time activity feed"
    - "Key metrics display with charts"
    - "Quick settings access"
    - "Notification preferences"
EOF

# Generate user stories
python ../../product-team/agile-product-owner/scripts/user_story_generator.py dashboard-epic.yaml

# Review the sprint planning guide for context
cat ../../product-team/agile-product-owner/references/sprint-planning-guide.md

Workflow 2: Sprint Planning

Goal: Plan a sprint with clear goals, selected stories, and identified risks

Steps: 1. Calculate Capacity - Determine team availability: - List team members and available days - Account for PTO, on-call, training, meetings - Calculate total person-days - Reference historical velocity (average of last 3 sprints)

1. Review Backlog - Ensure stories are ready:
2. Check Definition of Ready for top candidates
3. Verify acceptance criteria are complete
4. Confirm technical feasibility with engineers

5. Identify any blocking dependencies

6. Set Sprint Goal - Define one clear, measurable goal:

7. Aligned with quarterly OKRs
8. Achievable within sprint capacity

9. Valuable to users or business

10. Select Stories - Pull from prioritized backlog:

    # Prioritize candidates if not already ordered
    python ../../product-team/product-manager-toolkit/scripts/rice_prioritizer.py sprint-candidates.csv --capacity 12
    

11. Document the Plan - Use the sprint planning template:

    cat ../../product-team/agile-product-owner/assets/sprint_planning_template.md
    

12. Identify Risks - Document potential blockers:

13. External dependencies
14. Technical unknowns
15. Team availability changes
16. Mitigation plans for each risk

Expected Output: Sprint plan document with goal, selected stories (within velocity), capacity allocation, dependencies, and risks

Time Estimate: 2-3 hours per sprint planning session

Example:

# Prepare sprint candidates
cat > sprint-candidates.csv << 'EOF'
feature,reach,impact,confidence,effort
User Dashboard - Activity Feed,500,3,0.8,3
User Dashboard - Metrics Charts,500,2,0.9,5
Notification Preferences,300,1,1.0,2
Password Reset Flow Fix,1000,2,1.0,1
EOF

# Run prioritization
python ../../product-team/product-manager-toolkit/scripts/rice_prioritizer.py sprint-candidates.csv --capacity 8

# Reference sprint planning template
cat ../../product-team/agile-product-owner/assets/sprint_planning_template.md

Workflow 3: Backlog Refinement

Goal: Maintain a healthy backlog with properly sized, prioritized, and well-defined stories

Steps: 1. Triage New Items - Process incoming requests: - Customer feedback items - Bug reports - Technical debt tickets - Feature requests from stakeholders

1. Size and Estimate - Apply story points:
2. Use planning poker or T-shirt sizing
3. Reference team estimation guidelines
4. Split stories larger than 13 story points

5. Apply story splitting techniques from references

6. Prioritize with RICE - Score backlog items:

   python ../../product-team/product-manager-toolkit/scripts/rice_prioritizer.py backlog.csv
   

7. Refine Top Items - Ensure top 2 sprints worth are ready:

8. Complete acceptance criteria
9. Resolve open questions with stakeholders
10. Add technical notes and implementation hints

11. Verify designs are available (if applicable)

12. Archive or Remove - Clean the backlog:

13. Close items older than 6 months without activity
14. Merge duplicate stories
15. Remove items no longer aligned with strategy

Expected Output: Refined backlog with top 20 stories fully defined, estimated, and ordered

Time Estimate: 1-2 hours per weekly refinement session

Example:

# Export backlog for prioritization
cat > backlog-q2.csv << 'EOF'
feature,reach,impact,confidence,effort
Search Improvement,800,3,0.8,5
Mobile Responsive Tables,600,2,0.7,3
API Rate Limiting,400,2,0.9,2
Onboarding Wizard,1000,3,0.6,8
Export to PDF,200,1,1.0,1
Dark Mode,300,1,0.8,3
EOF

# Run full prioritization with capacity
python ../../product-team/product-manager-toolkit/scripts/rice_prioritizer.py backlog-q2.csv --capacity 15

# Review user story templates for refinement
cat ../../product-team/agile-product-owner/references/user-story-templates.md

Workflow 4: Story Writing Workshop

Goal: Collaboratively write high-quality user stories with the team

Steps: 1. Prepare the Session - Gather inputs: - Epic or feature description - User personas involved - Design mockups or wireframes - Technical constraints

1. Identify User Personas - Map stories to personas:
2. Who are the primary users?
3. What are their goals?

4. What are their constraints?

5. Write Stories Collaboratively - Use the template:

   cat ../../product-team/agile-product-owner/assets/user_story_template.md
   

6. "As a [persona], I want [capability], so that [benefit]"
7. Focus on user value, not implementation details

8. One story per distinct user action or outcome

9. Add Acceptance Criteria - Define "done":

10. Given/When/Then format for each scenario
11. Cover happy path, edge cases, and error states

12. Include performance and accessibility requirements

13. Validate INVEST - Check each story:

14. Independent: Can be delivered without other stories
15. Negotiable: Implementation details flexible
16. Valuable: Delivers user or business value
17. Estimable: Team can estimate effort
18. Small: Fits within a single sprint

19. Testable: Clear pass/fail criteria

20. Estimate as a Team - Story point consensus:

21. Use planning poker or fist of five
22. Discuss outlier estimates
23. Re-split if estimate exceeds 13 points

Expected Output: Set of INVEST-compliant user stories with acceptance criteria and estimates

Time Estimate: 1-2 hours per workshop (covering 1 epic or feature area)

Example:

# Generate initial story candidates from epic
python ../../product-team/agile-product-owner/scripts/user_story_generator.py feature-epic.yaml

# Reference story templates for format guidance
cat ../../product-team/agile-product-owner/references/user-story-templates.md

# Reference sprint planning guide for estimation practices
cat ../../product-team/agile-product-owner/references/sprint-planning-guide.md

Integration Examples

Example 1: End-to-End Sprint Cycle

#!/bin/bash
# sprint-cycle.sh - Complete sprint planning automation

SPRINT_NUM=14
CAPACITY=12  # person-days equivalent in story points

echo "Sprint $SPRINT_NUM Planning"
echo "=========================="

# Step 1: Prioritize backlog
echo ""
echo "1. Backlog Prioritization:"
python ../../product-team/product-manager-toolkit/scripts/rice_prioritizer.py backlog.csv --capacity $CAPACITY

# Step 2: Generate stories for top epic
echo ""
echo "2. Story Generation for Top Epic:"
python ../../product-team/agile-product-owner/scripts/user_story_generator.py top-epic.yaml

# Step 3: Reference planning template
echo ""
echo "3. Sprint Planning Template:"
echo "See: ../../product-team/agile-product-owner/assets/sprint_planning_template.md"

Example 2: Backlog Health Check

#!/bin/bash
# backlog-health.sh - Weekly backlog health assessment

echo "Backlog Health Check - $(date +%Y-%m-%d)"
echo "========================================"

# Count stories by status
echo ""
echo "Backlog Items:"
wc -l < backlog.csv
echo "items in backlog"

# Run prioritization
echo ""
echo "Current Priorities:"
python ../../product-team/product-manager-toolkit/scripts/rice_prioritizer.py backlog.csv --capacity 20

# Check story templates
echo ""
echo "Story Template Reference:"
echo "Location: ../../product-team/agile-product-owner/references/user-story-templates.md"

Success Metrics

Backlog Quality: - Story Readiness: >80% of sprint candidates meet Definition of Ready - Estimation Accuracy: Actual effort within 20% of estimate (rolling average) - Story Size: <5% of stories exceed 13 story points - Acceptance Criteria: 100% of stories have testable acceptance criteria

Sprint Execution: - Sprint Goal Achievement: >85% of sprints meet their stated goal - Velocity Stability: Velocity variance <20% sprint-to-sprint - Scope Change: <10% scope change after sprint planning - Completion Rate: >90% of committed stories completed per sprint

Stakeholder Value: - Value Delivery: Every sprint delivers demonstrable user value - Cycle Time: Average story cycle time <5 days - Lead Time: Epic to delivery <6 weeks average - Stakeholder Satisfaction: >⅘ on sprint review feedback

Related Agents

• cs-product-manager - Full product management lifecycle (RICE, interviews, PRDs)
• cs-product-strategist - OKR cascade and strategic planning for roadmap alignment
• cs-ux-researcher - User research to inform story requirements and acceptance criteria
• Scrum Master - Velocity context and sprint execution (see project-management/scrum-master)

References

• Primary Skill: ../../product-team/agile-product-owner/SKILL.md
• RICE Framework: ../../product-team/product-manager-toolkit/SKILL.md
• Product Domain Guide: ../../product-team/CLAUDE.md
• Agent Development Guide: ../CLAUDE.md
• Scrum Master Skill: ../../project-management/scrum-master/SKILL.md

---

Last Updated: March 9, 2026 Status: Production Ready Version: 1.0