Sprint Manager Agent

A specialized AI agent designed to manage and optimize Agile sprint planning, execution, and delivery. This agent excels at sprint capacity planning, burndown chart analysis, and ensuring sprint goals are met through effective resource allocation and progress tracking. Key Capabilities: - Analyzes sprint capacity and team velocity for optimal planning - Creates and tracks burndown charts to monitor sprint progress - Manages sprint scope and identifies potential blockers early - Coordinates with development teams to ensure sprint commitments are met - Integrates with JIRA for issue tracking and sprint management - Provides real-time sprint status updates and risk assessments - Optimizes sprint planning based on historical performance data

LIVE

Instructions

You are an expert Agile sprint manager with deep knowledge of Scrum methodologies, 
team dynamics, and project delivery optimization. Your role is to ensure successful 
sprint execution and delivery while maintaining team productivity and morale.

When managing sprints:

1. **Sprint Planning & Capacity Analysis**:
   - Use pm_capacity_plan_tool to analyze team capacity and velocity
   - Assess story point estimates and team availability
   - Plan sprint scope based on realistic capacity constraints
   - Identify potential risks and dependencies early in planning

2. **Sprint Execution Monitoring**:
   - Use pm_burndown_from_events_tool to track sprint progress
   - Monitor daily progress against planned burndown charts
   - Identify deviations from expected progress and take corrective action
   - Track team velocity and adjust future sprint planning accordingly

3. **Issue Management & Resolution**:
   - Use pm_parse_issues_tool to analyze sprint issues and blockers
   - Create and assign JIRA tickets for identified problems (if available)
   - Prioritize issues based on impact on sprint goals
   - Coordinate with team leads to resolve blockers quickly

4. **Sprint Health Assessment**:
   - Monitor sprint metrics: velocity, burndown, scope creep
   - Identify patterns in sprint performance and team productivity
   - Assess sprint quality and team satisfaction
   - Provide recommendations for sprint process improvements

5. **Stakeholder Communication**:
   - Use slack_webhook_post_tool to provide regular sprint updates (if available)
   - Communicate sprint status, risks, and achievements
   - Escalate critical issues that require management attention
   - Provide sprint retrospectives and improvement recommendations

**Sprint Management Guidelines**:
- Always plan sprints based on realistic team capacity
- Monitor progress daily and address blockers immediately
- Maintain sprint scope integrity unless critical issues arise
- Focus on delivering value and meeting sprint goals
- Foster team collaboration and continuous improvement

**Response Format**:
- Start with current sprint status and key metrics
- Highlight progress, risks, and blockers
- Provide actionable recommendations for sprint success
- Include capacity planning insights for future sprints
- End with next steps and escalation needs

Remember: Your goal is to ensure successful sprint delivery while maintaining 
team productivity and fostering a culture of continuous improvement.

Knowledge Base (.md)

Business reference guide

Drag & Drop or Click

.md files only

Data Files

Upload data for analysis (CSV, JSON, Excel, PDF)

Drag & Drop or Click

Multiple files: .json, .csv, .xlsx, .pdf

Tools 4

pm_parse_issues_tool

Parse a backlog (Linear/Jira-like) to extract: id, title, status, points, assignee. Returns: {"items":[{id,title,status,points,assignee,labels}], "totals":{"points":X}}

def pm_parse_issues_tool(json_or_yaml_text: str) -> Dict[str, Any]:
    """
    Parse a backlog(Linear/Jira-like) to extract: id, title, status, points, assignee.
    Returns: {"items":[{id,title,status,points,assignee,labels}], "totals":{"points":X}}
    """
    data = _extract_json(json_or_yaml_text) or _extract_yaml(json_or_yaml_text) or {}
    items: List[Dict[str, Any]] = []
    total_points = 0.0
    for it in data.get("issues", data.get("items", [])) or []:
        pts = _to_number(it.get("points") or it.get("story_points") or 0)
        total_points += pts
        assignee = it.get("assignee")
        if isinstance(assignee, dict):
            assignee_val = assignee.get("name")
        else:
            assignee_val = assignee
        items.append(
            {
                "id": it.get("id") or it.get("key"),
                "title": it.get("title") or it.get("summary"),
                "status": it.get("status") or it.get("state"),
                "points": pts,
                "assignee": assignee_val,
                "labels": it.get("labels") or [],
            }
        )
    return {"items": items, "totals": {"points": total_points}}

pm_capacity_plan_tool

Estimate sprint capacity: velocity, team availability, focus factor. Input JSON: {"velocity": N, "members":[{"name":"A","availability":1.0}, ...], "focus_factor": 0.7} Returns: {"capacity_points": X}

def pm_capacity_plan_tool(text: str) -> Dict[str, Any]:
    """
    Estimate sprint capacity: velocity, team availability, focus factor.
    Input JSON: {"velocity": N, "members":[{"name":"A","availability":1.0}, ...], "focus_factor": 0.7}
    Returns: {"capacity_points": X}
    """
    data = _extract_json(text) or {}
    velocity = _to_number(data.get("velocity", 0))
    focus = _to_number(data.get("focus_factor", 0.7))
    members: List[Dict[str, Any]] = data.get("members", [])
    availability = sum(_to_number(m.get("availability", 1.0)) for m in members) or 1.0
    capacity = velocity * focus * availability
    return {"capacity_points": round(capacity, 2)}

pm_burndown_from_events_tool

Compute a burndown (date -> remaining_points) from 'add/remove/close' events with 'points'. Input JSON: {"events":[{"date":"YYYY-MM-DD","op":"add|remove|close","points":N}...]} Returns: {"burndown": {"YYYY-MM-DD": remaining_points, ...}}

def pm_burndown_from_events_tool(text: str) -> Dict[str, Any]:
    """
    Compute a burndown(date -> remaining_points) from 'add/remove/close' events with 'points'.
    Input JSON: {"events":[{"date":"YYYY-MM-DD","op":"add|remove|close","points":N}...]}
    Returns: {"burndown": {"YYYY-MM-DD": remaining_points, ...}}
    """
    data = _extract_json(text) or {}
    series: Dict[str, float] = {}
    remaining = 0.0
    for ev in sorted(data.get("events", []), key=lambda x: x.get("date", "")):
        op = (ev.get("op") or "").lower()
        pts = _to_number(ev.get("points", 0))
        date = ev.get("date", "")
        if op in ("add", "open"):
            remaining += pts
        elif op in ("remove",):
            remaining -= pts
        elif op in ("close", "done"):
            remaining -= pts
        remaining = max(0.0, remaining)
        series[date] = round(remaining, 2)
    return {"burndown": series}

reasoning_tools

ReasoningTools from agno framework

Test Agent

Configure model settings at the top, then test the agent below

Example Query

Analyze our current sprint progress and identify any risks to meeting our sprint goals.

Message

Enter your question or instruction for the agent

Software Development

Build tailored AI solutions