Skip to content
← Back to writing

March 24, 2026

Session = sprint: why your AI agents need a Scrum master

A project manager’s framework for running AI agent teams using Scrum principles. Every agent session is a sprint. Here’s why that changes everything.

I've been a project manager for over a decade. PSM, CSPO, SAFe. I've done the certs, run the sprints, and sat through more grooming sessions than I care to remember. For the past few months I've been managing a team of AI agents that build real software and ship real products.

A real sprint backlog, the structure I map an AI working session onto: a fixed timebox with a committed, reviewable increment.

After a few weeks of it I noticed something. The model was rarely the thing that failed me. The planning was. I kept handing agents work that was never going to fit in one go, and then acting surprised when it came back half-finished.

I kept giving my agents bigger tasks and getting worse results

I have an engineer agent named Prospero. Smart, fast, can write React, build Docker containers, and deploy to dev servers, with real output rather than toy demos.

But I kept giving him tasks like "fix all the broken app icons on the dashboard." That sounds reasonable: one ticket, one problem.

Except that task actually means: audit 157 apps, cross-reference three different icon repositories, add name mappings for apps that use alternate naming conventions, fix a YAML template variable that was never interpolated, rebuild a Docker container, and deploy it to a dev URL. That's an epic I disguised as a task because I was too lazy to break it down. And it's exactly the mistake I'd coach a junior PM out of if they tried it on a human team.

Then it hit me

My agents run for about 10 minutes per session. That's a hard constraint: they spin up, do work, deliver output, and the session ends.

A sprint is the same shape. A fixed timebox where a team commits to delivering a working increment of software. The whole idea is that at the end of one you've produced an artifact of working code, something that pushes you toward the definition of done, which is the entire point of it.

My agents work much faster than humans, and each task is its own mini sprint. So I started treating every agent session as exactly that.

Here's how it maps

The Scrum framework is the operating model here, not a metaphor.

A sprint is a single agent run, about 10 minutes. The sprint goal is the task title plus its acceptance criteria. Definition of done is a deployable artifact: a commit, a built container, a merged PR, something I can look at and verify in under a minute.

Sprint review is me checking the dev URL after the agent finishes. Sprint retro is me updating the agent's instructions when it underperforms. The product backlog is the issue board. Sprint planning is my PM agent decomposing big requests into atomic pieces.

There's no ceremony overhead. No standup, no grooming meeting, no sprint review eating four hours of a two-week cycle. The agent picks up a task, executes, delivers, and moves to the next one.

The 10-minute rule

This is the core of it: if a task can't be completed in a single agent run, the task is too big. Don't extend the timeout. Shrink the task.

Bad decomposition:

  • "Fix all broken app icons" (one task, 45+ minutes of work)

Good decomposition:

  • Audit all 157 apps, list which ones have missing icons: delivers an audit file
    • Add icon mappings for apps A through M: delivers a commit and container rebuild
    • Add icon mappings for apps N through Z: same thing
    • Fix the Fenrus YAML template variable: delivers a commit
    • Final deploy to dev: delivers a running container

Five tasks instead of one, each independently shippable. If task three fails, tasks one and two are still live. That's incremental delivery, and it's the part of Scrum everyone seemed to forget the moment they started working with AI.

Why this beats "just let the AI figure it out"

A few reasons.

The ceremony overhead is gone. Human sprints come loaded with process. Agent sprints don't: pick up, execute, ship, repeat.

The feedback loop is tighter. I don't wait two weeks to discover a feature is wrong, I know in 10 minutes. If it's off, I adjust the instructions and re-run.

And the one that genuinely surprised me: scope creep becomes physically impossible. An agent can't go down a rabbit hole for three days because it only has 10 minutes. There's no "well, while I'm in here let me also refactor this." Either the task fits the window or it doesn't.

The anti-patterns

I've made every one of these so you don't have to.

One was extending timeouts instead of shrinking tasks. When my agent timed out, my gut reaction was to give it more time. That's like making a sprint three weeks instead of two because the team couldn't finish. The answer is to scope down, not stretch the timebox.

Another was bundling deliverables. "Fix the icons AND the dark mode" is two tasks. Every time I've combined them, one gets done well and the other gets done halfway, so keep it to one task and one artifact.

Then there's letting engineers plan their own work. This applies to human and agent teams equally. An engineer, human or AI, will scope-creep if you let them. You ask for a button color change and get "I refactored the entire codebase." Decomposition is its own skill, and it should be a separate role. I have a PM agent whose entire job is taking big asks and cutting them into 10-minute atomic chunks.

And vague acceptance criteria. "Make it look better" is not a task. "Replace the generic SVG placeholder with the real app logo from the homelabarr-logos repository, rebuild the container, deploy to ce-dev on port 8085." That's a task, and if you're not that specific you'll get surprised.

Why I let the process enforce itself

I don't trust myself to remember any of this at 1 a.m., so I wired the rules into the tooling instead of my head.

Before an agent can touch code, a gate runs: find or create the Jira epic, make sure there's an active sprint (single-day, since the work is single-day), create the story with real acceptance criteria, then a branch named for the ticket. A Definition of Ready check rejects a story that's missing acceptance criteria before it can leave the backlog. A PreToolUse hook blocks file edits if the branch has no ticket key, so an agent literally cannot start writing code without a ticket behind it. The decomposition is a wall the agent hits if it skips a step, not a suggestion I have to police.

The bigger picture

I think the people who win with AI agents will be the best project managers, not the best engineers.

The models are good enough. They can write code, build UIs, draft content, run deployments. What's missing is the layer between "I want this" and "here's exactly what to build, in what order, with what acceptance criteria, and here's how I'll know it's done." That layer is sprint planning. It's decomposition. It's all the boring PM stuff engineers have always wanted to skip, and it matters more, not less, when your team never sleeps and works at 100x speed. Bad direction at 100x speed just gets you to the wrong place faster.

The philosophy

Fail fast, fix fast, iterate until it's good, then ship v1. Perfection is the enemy of good. You should absolutely strive for it, through kaizen, through continuous improvement, but it can only come after you've built a strong foundation.

I treat everything this way. If the methodology doesn't work, I'll adjust it tomorrow. That's the point. Ship it, learn from it, and make it better, because version one is never the final version.

So if you're managing AI agents and the output quality is frustrating you, start with how the work is broken down. Treat each session as a sprint: decide what done means before the agent starts, and keep every piece small enough to finish in one run.

More writing