Scrum rules do not change when a coworker is not a person
Agentic AI teams introduce a coworker that can generate a pull request, but the Scrum Guide's rule about accountability does not bend to accommodate it: agents multiply output, they do not multiply judgement, and judgement is exactly what a Definition of Done is made of. This module opens with that distinction and does not let it go. A post-incident review that concludes the model hallucinated has identified a cause, not a finding. The actual finding is almost always a missing policy, a missing review step, or an ambiguous backlog item that should never have been handed to an agent in that state.
A large part of the module is spent on writing backlog items an agent can safely execute, which turns out to be the same discipline good refinement always required: if an item is too ambiguous for an agent to execute safely, it was also too ambiguous to estimate for a human, and the fix is to clarify the item, not to engineer a better prompt around its ambiguity. Scenarios include triaging a batch of agent-generated pull requests under time pressure, and a decision lab where an agent shipped a defect overnight with no human awake to catch it, forcing the team to examine where the review gate actually was.
The module closes on running the Scrum events with non-human contributors without letting the Daily Scrum collapse into a review-queue triage meeting, and on the capacity conversation that leadership inevitably raises: throughput went up, so should headcount go down. The module's answer is that the team did not get faster, it moved the constraint, and the honest question is where the team wants that constraint to sit now, not whether the constraint disappeared.
Mistakes teams make with this material
Stopping the analysis at a description of what the agent did, instead of identifying the missing policy, review gate, or ambiguous backlog item that actually let the mistake reach production.
Spending the fifteen minutes sorting through a backlog of agent-generated pull requests instead of inspecting progress toward the Sprint Goal, which is what the event exists to protect.
Treating a green pipeline as sufficient evidence of correctness when the same assistant wrote both the implementation and the tests, and a human reviewer spent only seconds confirming it.
Reading an increase in output as headcount that can be reduced, without first establishing that the constraint moved rather than disappeared, and that quality held at the new pace over multiple Sprints.
Questions people ask
Who is accountable when an autonomous agent introduces a defect?
The Developers, exactly as the Scrum Guide already states. Accountability never transfers to a tool. A review that concludes only that the agent made an error has identified a cause but not the actual finding, which is the missing policy or review step.
How do you write backlog items that an agent can execute safely?
Apply the same refinement discipline good teams already use: if the item is too ambiguous for an agent to execute without risky guesses, it was too ambiguous to estimate reliably for a human either. Fix the item's clarity rather than trying to compensate with a better prompt.
What is wrong with an agent writing both the implementation and its tests?
A green pipeline in that setup proves internal consistency, not correctness, since the same source generated both halves of the check. A human needs to independently verify the tests actually validate the intended behaviour, not just that they pass.
How should a Scrum Master respond when leadership wants to cut the team after seeing agent-driven throughput gains?
Reframe the conversation around the constraint rather than the headcount. Explain that the team did not become faster in an unlimited way, the bottleneck moved, usually to review capacity, and ask leadership where they want that constraint to sit before making a staffing decision.
A question from this module's assessment
One sample question with the reasoning, so you can judge the level before you start. The rest of the assessment stays inside the module.
An autonomous agent auto-merges a change that breaks production. Who is accountable for the Increment?
- The agent
- The vendor who supplied the model
- The Developers on the team
- Nobody, it was automated
Accountability for the Increment sits with the Developers regardless of who or what produced the code. An agent cannot be answerable.