CyclePilot

Close a sprint. Ship a release. Bootstrap the next sprint. One trigger.

Comment

The Inspiration: The AI Paradox

Every two weeks, the same ritual plays out across thousands of engineering teams: manual sprint ceremonies. Checking if issues are closed, verifying merged MRs, writing changelogs, tagging releases, moving unfinished work, and writing retrospectives. This takes 85+ minutes per sprint.

AI writes code 10x faster now, but shipping is still entirely manual. This creates the "AI Paradox": faster coding creates bottlenecks in release orchestration. We built CyclePilot to completely automate the sprint boundary.

What it does

CyclePilot is an autonomous AI Scrum Master built on the GitLab Duo Agent Platform. Mention @ai-cyclepilot on any sprint issue, and three specialized agents cascade through the release lifecycle:

  1. Release Gatekeeper: Reads all planned sprint issues. It checks pipeline states, verifies merged MRs, and flags blockers. Crucially, it has the agency to halt a release to protect production if quality gates (like missing code for closed issues) are not met.
  2. Changelog Architect: If the release passes, it fetches all merged MRs, semantically categorizes them (features vs. bug fixes), and commits a formatted CHANGELOG.md directly to the repository.
  3. Cycle Commander: Creates the release tag, bootstraps the next sprint's planning issue, carries forward deferred work, and generates a smart retrospective with actionable AI insights.

How we built it

CyclePilot leverages a multi-agent sequential flow on the GitLab Duo Agent Platform.

  • Anthropic Claude powers the reasoning engine, allowing the agents to make complex judgments under ambiguity (e.g., distinguishing a true blocker from a deferred feature, or semantically categorizing code diffs).
  • Python Backend: We built a custom Python architecture supporting the agents, including config_parser.py for team rules, and a robust Pytest suite.
  • SCI Sustainability Framework: We built a dedicated sustainability_calculator.py that tracks token usage and estimates the exact carbon footprint (CO₂e) of the AI execution, posting an energy audit in every retrospective.

Challenges we ran into

The biggest challenge was orchestrating a multi-agent handoff. Unlike other agents that just analyze a single Merge Request, CyclePilot operates on the entire sprint (10-20+ MRs and issues). Getting the Gatekeeper to pass structured JSON context to the Architect, and then to the Commander, required deep prompt engineering and strict schema validation.

Accomplishments that we're proud of

In our test runs, CyclePilot demonstrated incredible reasoning capabilities. It successfully caught issues that were marked as "closed" but had no actual code attached, and it identified a critical database blocker. It autonomously made the executive decision to block the release to protect production, carried the blocker over to the next sprint, and generated a retrospective warning the team about prioritizing "velocity over value."

What's next for CyclePilot

We plan to expand CyclePilot's integrations to automatically update external ticketing systems (like Jira) and post sprint summaries directly into team Slack channels.

Built With

  • anthropic-claude
  • gitlab
  • gitlab-duo
  • json
  • pytest
  • python
  • yaml
Share this project:

Updates