Four of the five roles come straight from Scrum. The fifth — the Agent — is new, but it fits cleanly alongside the others. The bigger change isn't the org chart; it's what each role is now responsible for.

Product Owner

Same accountability as Scrum: owns the backlog, sets priorities, defines what gets built and why. The one addition is phase approval. Before Build begins on any phase, the PO signs off on the scope — not the implementation, but the "what done looks like" definition. A phase that starts without clear completion criteria is the PO's failure as much as the Developer's.

Scrum Master

Still the process guardian. In Agentic Agile they gain a concrete new ceremony: the Escalation Ceremony. When Reviews surface questions the Developer couldn't answer, those questions accumulate. The SM inspects them, judges the right resolution path, and assigns accordingly — Three Amigos, a domain expert, a PO decision, whatever fits. The SM doesn't resolve the questions themselves; they own the routing.

Developer

The role that changes most. The Developer is no longer primarily a code author — they're an execution director and an ownership enforcer. They decompose tickets into phases, direct the agent during Build, and — critically — must be able to explain everything that shipped before a phase closes. Velocity is no longer the measure. Ownership is.

If the Developer can't explain it, the phase isn't done.

Stakeholder

Unchanged. Not in the day-to-day workflow, but present at sprint reviews. The difference is what sprint review now surfaces: agent-built output evaluated against a Spec File, with a record of every Review and every escalated question. Stakeholders get more visible signal on what was built and what gaps remain.

The Agent

A named collaborator with defined responsibilities. The Agent executes phases within the scope defined by the Developer. It leads Reviews — not the Developer. It asks the questions, surfaces the gaps, records the decisions. It flags divergences between completed work and the spec. It does not make scope decisions, and it does not close a Review without Developer sign-off.

Treating the Agent as a collaborator rather than a tool changes what you expect from it. A tool executes. A collaborator is accountable for surfacing what it knows — including when the Developer doesn't understand what was just built.

In practice

Here's a ticket in progress — a question surfaced during a Review and escalated to the Scrum Master. The SM routes it in the Escalation Ceremony below.