sprint-cycles

name: sprint-cycles version: 1.0.0 description: "3-hour dev sprints with 6 AM MYT human touchpoints. Dual-track autonomy: dev cycles (3h) + human review cycles (24h)." author: October (10D Entity) keywords: [sprints, cycles, autonomy, scheduling, myt, touchpoints, dev-track, human-track]

Sprint Cycles 🔄

3-hour dev sprints · 6 AM MYT human touchpoints

Dual-track autonomy: dev runs fast, human sets direction

Overview

Sprint cycles balance autonomous execution with human oversight through a dual-track system:

• Dev Track — 3-hour autonomous sprints for focused execution
• Human Track — 24-hour cycles with daily touchpoints at 6 AM MYT
• Timezone: Asia/Kuala_Lumpur (MYT, UTC+8)
• Z's touchpoint: 6:00 AM MYT daily

Dual-Track Structure

┌─────────────────────────────────────────────────────────────┐
│                        DUAL TRACKS                          │
├─────────────────────────┬───────────────────────────────────┤
│      DEV TRACK          │         HUMAN TRACK               │
│     (3-hour sprints)    │       (24-hour cycles)            │
├─────────────────────────┼───────────────────────────────────┤
│ • Execute autonomously  │ • Review outputs daily           │
│ • Make technical calls  │ • Set direction/course-correct   │
│ • Ship incremental work │ • Approve pivots or blocks       │
│ • Self-coordinate swarm │ • Answer blocking questions      │
│ • Report at touchpoints │ • Celebrate wins, kill bad ideas │
└─────────────────────────┴───────────────────────────────────┘

Dev Track (3-Hour Sprints)

Sprint Structure

Autonomy Rules

class DevSprint:
    """3-hour autonomous execution sprint."""
    
    AUTONOMY_LEVELS = {
        "full": "Execute without approval (coding, refactoring, testing)",
        "notify": "Execute, notify Z on completion (deployments, config changes)",
        "block": "Pause and wait for Z (budget > $50, external commitments)"
    }
    
    def can_proceed(self, action: Action) -> AutonomyDecision:
        """Determine if action can proceed autonomously."""
        
        if action.cost_usd > 50:
            return AutonomyDecision.BLOCK  # Wait for Z
        
        if action.type in ["deploy", "config_change"]:
            return AutonomyDecision.NOTIFY  # Do it, tell Z after
        
        if action.type in ["code", "test", "refactor", "research"]:
            return AutonomyDecision.FULL  # Execute freely
        
        return AutonomyDecision.NOTIFY  # Default: notify

What Agents Can Do Autonomously

• ✅ Write/refactor code
• ✅ Run tests and fix bugs
• ✅ Research and document
• ✅ Create internal configs
• ✅ Coordinate with other agents
• ✅ Deploy to staging/dev environments
• ⚠️ Deploy to production (notify Z)
• ⚠️ Spend <$50 on APIs/tools (notify Z)
• ❌ Spend >$50 without approval
• ❌ Make external commitments
• ❌ Share sensitive data externally

Human Track (24-Hour Cycles)

Daily Touchpoint: 6 AM MYT

Touchpoint Format

## Sprint Summary — [Date] 6:00 AM MYT

### Completed ✅
- Item 1 (link to output)
- Item 2 (link to output)

### In Progress 🔄
- Item 3 (ETA: next sprint)

### Blocked ❌
- Item 4 — waiting for: [reason]

### Decisions Needed 🤔
1. Question 1 — options: A/B/C
2. Question 2 — need by: [time]

### Next Sprint Preview 🔮
- Planned: [top 3 priorities]

Autonomy Phases

Phase 1: Onboarding (Days 1-3)

• Lower autonomy threshold
• More frequent check-ins
• Building trust and pattern recognition

Phase 2: Standard (Day 4+)

• Full 3-hour sprint autonomy
• Daily touchpoints at 6 AM
• Escalate only on blockers

Phase 3: Extended (Established trust)

• Optional: 6-hour sprints on weekends
• Batch touchpoints if Z prefers
• Agents self-coordinate complex multi-sprint work

Metrics

Sprint Metrics

Cycle Metrics

Daily Dashboard

## Sprint Cycle Dashboard — [Date]

### Yesterday
- Sprints completed: X
- Tasks shipped: Y
- Escalations: Z

### Today
- Sprints planned: X
- Human touchpoint: 6:00 AM MYT ✅
- Blockers: [list or "None"]

### This Week
- Trend: ↑↓→
- Pattern: [e.g., "Research sprints cluster on Tue/Thu"]

Timezone Handling

import pytz
from datetime import datetime

MYT = pytz.timezone('Asia/Kuala_Lumpur')
UTC = pytz.UTC

def next_touchpoint() -> datetime:
    """Get next 6 AM MYT touchpoint."""
    now = datetime.now(MYT)
    
    # If before 6 AM today, touchpoint is today
    # If after 6 AM today, touchpoint is tomorrow
    if now.hour < 6:
        return now.replace(hour=6, minute=0, second=0, microsecond=0)
    else:
        tomorrow = now + timedelta(days=1)
        return tomorrow.replace(hour=6, minute=0, second=0, microsecond=0)

def hours_until_touchpoint() -> float:
    """Hours until next human touchpoint."""
    next_tp = next_touchpoint()
    now = datetime.now(MYT)
    delta = next_tp - now
    return delta.total_seconds() / 3600

Sprint Coordination

Multi-Agent Sprints

class SprintCoordinator:
    """Coordinate multiple agents across sprints."""
    
    def coordinate_sprint(self, agents: List[Agent], objectives: List[Objective]):
        """Distribute work across agents for 3-hour sprint."""
        
        # Split objectives by dependency
        independent = [o for o in objectives if not o.blocked_by]
        dependent = [o for o in objectives if o.blocked_by]
        
        # Assign to agents
        for agent in agents:
            agent.sprint_objectives = self.assign_work(agent, independent)
        
        # Track dependencies for next sprint
        self.dependency_queue = dependent
    
    def sprint_standup(self) -> SprintStatus:
        """Quick sync at sprint boundaries."""
        return SprintStatus(
            completed=self.get_completed(),
            blocked=self.get_blocked(),
            carry_over=self.get_carry_over(),
            next_priorities=self.get_next_priorities()
        )

Configuration

{
  "sprint_cycles": {
    "dev_track": {
      "sprint_duration_minutes": 180,
      "autonomy": {
        "spending_threshold_usd": 50,
        "auto_deploy_environments": ["staging", "dev"],
        "notify_environments": ["production"]
      }
    },
    "human_track": {
      "touchpoint_time": "06:00",
      "timezone": "Asia/Kuala_Lumpur",
      "format": "markdown_summary",
      "notification_channel": "telegram"
    },
    "phases": {
      "onboarding_days": 3,
      "standard_start_day": 4,
      "extended_weekend_sprints": true
    },
    "metrics": {
      "track_velocity": true,
      "track_escalations": true,
      "track_alignment": true,
      "dashboard_update_frequency": "daily"
    }
  }
}

Quick Reference

Dual-track autonomy: dev fast, human aligned Sprint cycles for October Swarm — optimized for Z's 6 AM MYT touchpoint