Thoughts7 min read
Does Agile have a place in the agentic world?
Scrum controls work by permission: what you may start, how much, and when. With coding agents, developer effort is cheap and verification is scarce, so the control has to move.

Scrum controls work by permission: what you may start, how much of it, and when. Agentic development needs the opposite. Let developers start freely, and move the control to verification.
The argument rests on one premise: coding agents drastically speed up the act of writing software. Accept that and the rest follows. The process most Scrum teams run was built to ration scarce developer effort, and it spends plenty of other people's time doing so. When developer effort is cheap, the scarce thing is verification, and process built to ration developer effort gets in the way.
What survives
User stories still earn their keep. An agent needs to know who wants what and why, and a well-written story with acceptance criteria is close to a spec. It just needs to be precise enough for a machine, not a planning poker session.
Short release cycles survive too. Getting working software in front of people quickly matters more than ever when you can produce it faster.
Notice where both came from. User stories and small, frequent releases are Extreme Programming practices, later absorbed into the Agile brand. The engineering survives the agentic shift. What doesn't is the management layer that Scrum built on top of it.
Permission: gates before the work
Scrum as practised is a system for stopping developers from doing things. Refinement decides what may be started. Estimation decides how much. Sprint commitments decide when. Work-in-progress limits, sometimes as strict as one story per person, decide how many. Every control is a permission, and it sits in front of the work.
That made a kind of sense when the developer was the engine. Starting the wrong thing wasted days of a scarce person. Limiting starts protected that time.
With agents, the gates protect nothing. An agent working on a story spends much of its time on things that don't need you: running tests, waiting on a build, working through a task. Under a one-story limit, the developer sits and watches a progress bar. The process that was meant to protect the developer's time now wastes it.
Since working with agents, I have repeatedly spent more effort getting a change into a sprint than making it. The work shrank. The paperwork around it didn't.
Estimation is waste
If you already have the user story, give it to the agent. It is cheaper to begin and back out than to spend several people's hours in a meeting where everyone just guesses. The attempt also tells you more than the guess: you end up with working code to look at, or a concrete reason the story was harder than it seemed.
Estimation existed because developer time was the scarce resource, and you needed to know how much of it a story would consume. Story points were always days. When an agent does the building and the days shrink to hours, there is little left to estimate.
What stays expensive is choosing the right thing. Importance to the business should decide the order, not developer effort. Keep the backlog ordered that way and the next item to pick up is simply the one at the top. No planning session required.
What is still worth sizing is risk. Some changes are cheap to build and expensive to get wrong: payments, data migrations, anything regulated. The question to ask is how hard the change will be to verify and how bad it is if it slips through, rather than how long it will take. That is a conversation about verification, and story points add nothing to it.
A fleet of container ships
A single agent run is like a container ship: once it sets off, it takes a while to arrive. But you still have your developer, and they are not the one at sea. The only thing that has changed is that they can talk to you while several user stories are being built at the same time.
A fleet arriving staggered looks like steady flow. From the shore you don't see individual voyages. You see something arriving all the time. So long-running work and frequent releases are not in conflict.
The first step is to fill the idle time. While one agent runs the tests, talk to another about something that doesn't depend on it. The old objection to multitasking was the cost of switching context, but here the spec and the agent hold the state. Coming back is cheap.
Then pipeline it. Spec the next item while the current one is being verified, and the one before it is being released. Every stage stays busy, which is flow rather than a sprint.
Verification: the port
A fleet only helps if you can unload it. In software, unloading is review, testing and integration. Send more ships to a port that can't keep up and you get a longer queue in the harbour, not faster delivery.
Scrum puts its controls before the work and asks whether you may start. Agentic flow lets the developer start as much as they can, and puts its investment into evidence that a change can ship, and into getting that evidence fast.
Refinement, estimation, sprint commitment, a limit on work in progress.
Automated checks, AI review, approval scaled to risk, fast rollback.
Anthropic's Claude Code team is a good example of what that looks like in practice. In How the Claude Code team does code review, they describe a goal of most pull requests merging with at most one human in the loop, with no rise in reverts or incidents. They get there with layers of automated checks, AI review on every change, approvals scaled to risk, and rollback underneath for whatever still gets through.
Much of the review now happens before a pull request even exists, by asking the agent to show test output rather than claim it's done. They also accept that when starting is cheap, some work gets started that should never merge, and that throwing it away costs little. The gates they added are automated, and the aim is to need fewer people in the loop. They built a better port.
Where the speed actually comes from
Agentic development cannot keep getting faster if you keep the same humans in the loop for the same amount of time. There are only so many meetings anyone can attend in a day, while the number of agents you can run is close to limitless. This is Amdahl's law applied to a team. However fast the coding gets, the stand-ups, refinement, approvals and hand-offs you leave as they are end up setting the pace, and every further gain disappears into the human waits.
More agents is not the goal either. Past a point, every extra agent is another ship queuing outside the harbour, and you are the harbour master. When that happens, don't hold the ships back. Improve the part of the pipeline they are queuing for: build a better port. The aim is a full pipeline where the human never becomes the bottleneck.
That is why nobody needs a hard limit on work in progress. A limit treats the bottleneck as fixed. The team watches the pipeline, keeps the flow steady, and acts when work starts to pile up in front of a stage. The Phoenix Project made this argument about IT work over ten years ago: find the bottleneck and manage around it. A static process assumes that following it produces the best result. Looking for the bottleneck assumes nothing.
Back to the manifesto
The Agile Manifesto valued individuals and interactions over processes and tools. It was written against gatekeeping, not for it. The gates came later, with certified Scrum and enterprise rollouts.
So does Agile have a place in the agentic world? The sprint doesn't. The ceremony doesn't. Story points certainly don't. But short feedback loops, working software, and trusting the people doing the work fit better than ever.
Continuous flow, with control moved from permission to verification, is closer to what the manifesto asked for than most Scrum teams have been in years.
Related reading