Roles and decision rights
- Status
- Approved
- Version
- 0.3.0
- Authority
- UASK standard
- Applies to
- Core
Summary
Seven roles carry a UASK project: the owner, the technical lead, the client, the lead, the builder, the verifier and the automated gate. Each is defined here once; every playbook, template and project document refers to this item and does not define the roles again. The owner decides only what R9 lists: the bet and the appetite, the scope and the roadmap priorities, the tier, hard-to-reverse architecture decisions, acceptance of delivered work, the acceptance of a risk of Medium severity or higher, and irreversible or outward actions such as licences, publication, hosting and production. The lead and the builder decide everything else and log it. An agent escalates before an owner-level action that no standing rule covers, at a fork that no recorded decision covers, and at drift from the goal, and always with options and a default.
Rules
Roles
- R1. A project MUST name who holds each role it uses, in the file where it keeps its rules (its
AGENTS.md, or its Blueprint when there is none). One holder MAY hold several roles, except where R5 and R6 forbid it. - R2. Roles MUST be taken from the table under Guidance. A project document or an item MUST NOT define a role in its own words; it MUST use the role’s name from here.
- R3. The owner decides what R9 lists. The owner MUST NOT be asked about a reversible or governance detail; the lead or the builder decides it and logs it (R10).
- R4. The technical lead is an adviser. Its strategic briefs and architecture reviews reach the agents as the owner’s instruction, through the owner, and it MUST NOT decide alone.
- R5. The builder MUST NOT change an ADR or the scope, and MUST NOT merge a change whose gate is red.
- R6. The verifier MUST be a person or a session that did not build what it verifies, and MUST NOT fix what it reviews. It re-runs the checks itself and grades each finding by severity.
- R7. The client, when the client is not the owner, MUST act through the owner. The client accepts the look and the scope through the owner and approves a release spec on a client project; the client MUST NOT instruct agents directly.
- R8. The automated gate (the project’s check script, linters and fitness functions) MUST run on every merge and MUST NOT be bypassed.
Decision rights
- R9. These decisions are owner-level and MUST be taken by the owner, in writing and with a date: (a) the bet and
the appetite; (b) the scope, including the boundary of the first release and the roadmap priorities; (c) the tier;
(d) every ADR marked owner-level, which means a hard-to-reverse architecture choice, the technology stack included
(proposed by ADR, accepted by the owner); (e) acceptance of delivered work; (f) the acceptance of a risk of Medium
severity or higher (
arch.risks-and-technical-debt#R4,arch.architecture-review#R15), and at the high-assurance tier the sign-off of the risk and debt registers at each release (arch.risks-and-technical-debt#R14); and (g) any irreversible or outward action, which means production of a live or client system, money and budget, licences, publication and visibility of a repository, a page or any other material, hosting, domain names and DNS, keys and access, deletion of data, and real external markets. - R10. Every other decision MUST be taken by the lead or the builder, whichever holds the work, and MUST be logged where the project logs its work, with the reason.
- R11. A decision that an accepted ADR or a rule of the project already covers MUST NOT be raised again with the owner, except a decision of R9: an action of R9 needs the owner’s written yes for that action, or a standing rule (R17) that names it.
- R12. An agent MUST stop and ask the owner in three cases and no others: before an action of R9 that no standing rule (R17) covers; at a fork that no ADR covers and that is hard to reverse; and at drift from the goal. The question MUST give the options, the consequences of each and a default that applies if nobody answers. Where the work can go on without the answer, the agent MUST go on with the default, except that it MUST NOT take an action of R9 by default.
- R13. The lead MUST record every owner decision with its date and its words in the artefact it concerns, and not only in a chat.
Who may do what in the lifecycle
- R14. At each gate of
process.project-lifecyclethe decider named there MUST decide. Where the item says “lead”, the lead MAY decide alone; an agent MUST NOT take a gate that is the owner’s, whatever the tier, except an action that a standing rule (R17) names. - R15. A change to this item, or to the roles and principles of a project’s rules file, MUST be approved by the owner.
Adding to the owner’s decisions, and standing rules
- R16. A project MAY add owner-level decisions in its rules file. It MUST NOT remove any decision that R9 lists.
- R17. A standing rule is a written, dated instruction of the owner that names a kind of action and its limits and applies until the owner withdraws it. A standing rule MUST be recorded in the project’s rules file or in the artefact it concerns, and MUST NOT be inferred from an ADR, a log entry or a chat.
Guidance
The roles
| Role | Who | Does | Never |
|---|---|---|---|
| Owner | The owner; also the client on the owner’s own projects | Takes G0, G1 and G3; sets the tier and the appetite; answers the questions that block work | Is asked about reversible or governance details |
| Technical lead (adviser) | An outside reviewer who works through the owner | Writes strategic briefs; reviews architecture and risks; its input reaches agents as the owner’s instruction | Decides alone |
| Client | The external customer, when not the owner | Accepts the look and the scope through the owner; approves a release spec on client projects | Talks to the agents directly |
| Lead | The project’s lead session, an agent or a person | Writes briefs, release specs and ADR drafts; takes G2; merges; keeps the project’s state file; escalates | Builds large changes itself |
| Builder | Executor sessions or subagents, each on its own branch | Builds one work package to its Done criterion; adds the checks first; reports in a few lines and a file | Changes ADRs or scope; merges a red change |
| Verifier | A fresh session or a person who did not build | Re-runs the checks; reviews against the release spec and the ADRs; grades findings | Fixes what it reviews |
| Automated gate | The check script, linters and fitness functions | Stops a bad change at every merge | Is bypassed |
On a small project one holder can take several roles: an owner can be the technical lead too, or the lead can build a small change itself. The limit is independence: the verifier is never the builder, and a design is never checked only by its author.
What the old role words mean now
The Hub used to define roles four times. The old names map onto the table so that no document needs rewriting at once.
| Old name | Where | Role here |
|---|---|---|
| Product Owner, owner | The rules file; the playbooks | Owner |
| Technical Lead, Architecture Reviewer, technical lead | The rules file; the foundation playbook | Technical lead, or Verifier when it reviews as a fresh session from the evidence alone |
| Lead Developer, lead developer | The rules file; the three playbooks | Lead, or Builder when it implements a work package |
| Decision owner | The review playbook | Owner (the client’s say goes through the owner, R7) |
| Reviewer | The review playbook | Lead or Builder: it gathers the evidence and writes the report |
| Independent reviewer | The review playbook | Verifier |
| Reviewer | The release playbook | Verifier: it reviews changes against the Definition of Done |
| Release approver | The release playbook | Owner, or a person the owner names by a standing rule (R17) |
| Client | The foundation playbook | Client |
Decision rights at a glance
| Decision | Who | Recorded in |
|---|---|---|
| Bet, appetite, tier | Owner | The G0 record |
| Scope, MVP boundary, a change of scope | Owner | The PRD or the release spec |
| An ADR marked owner-level | Owner | The ADR’s owner decision |
| Acceptance of delivered work | Owner (the client’s say goes through the owner) | The release record |
| Production release of a live or client system; money and budget; licences; publication and visibility; hosting; DNS; keys; data deletion; a real external market | Owner, or a standing rule that names the action | The release record |
| Readiness of a release | Lead | The release spec |
| Which design inside an accepted ADR; how to build a work package | Lead or builder | The log of the work |
| An ADR that is not owner-level | Lead drafts and accepts; the owner accepts only where the project’s rules say so | The ADR |
| Merge of a green change within an approved task | Lead or builder | The pull request |
Escalation in practice
Stop in one of two situations. The first is a choice that no accepted ADR or project rule decides and that is hard to reverse. The second is an action of R9, such as a production deployment or a change of licence, that no standing rule names: an accepted ADR can settle which host to use, but not that today’s deployment may go ahead. Otherwise decide, log, and go on. A question to the owner carries the following, in this order, in a few lines.
- The question, in one sentence.
- The options, each with what it costs and what it forecloses.
- The default: what the lead will do if the owner does not answer, and by when.
- What continues in the meantime.
A standing rule is how an owner says “this kind of action may go ahead without asking” once: for example, “a release that passed its checklist may be deployed to the staging host on any day”. It names the action and its limits, it is written and dated, and it stays in force until the owner withdraws it. Without one, the owner’s yes is asked each time.
A drift from the goal is a different trigger: the work is still moving, but away from what the owner asked for. Name the drift and the goal in the first line, and stop that line of work.
Working with agents
An agent session has a context that fills up; a brief that fits on one screen keeps it small. Boundaries between sessions follow interactions, as in Team Topologies: a lead collaborates with the owner, uses tools as a service, and facilitates builders by giving each a brief and a check. A builder gets what it needs and nothing else, so its load stays low. Reports are short, with the detail in a file.
Tailoring by tier
The tier is defined in mgmt.governance-tiers. At the lightweight tier one person can hold every role but the owner’s
gates, and the author can check the work against the Definition of Done. At the standard tier the verifier is another
person or session. At the high-assurance tier a second verifier checks the design and each release.
Explanation
Why one place. Roles drifted when each playbook defined its own: “reviewer” meant the author in one place and the independent checker in another. A role defined once, with a short list of what it never does, is cheaper to apply and easier to audit than four similar tables.
Why the owner decides little. The owner’s attention is the scarcest input. GOV.UK states the same idea for service governance: take decisions when they are needed and at the right level, do not slow delivery down, and do governance only where it adds value. The owner keeps what cannot be taken back or what leaves the project: the bet, the scope, the tier, hard-to-reverse architecture, and outward and irreversible actions. A service owner in GOV.UK has decision-making authority over all aspects of a project; here that authority is shared, because agents do the work, and the line is drawn at harm that cannot be undone.
Why a default with every question. A question without a default stops work until someone answers. A question with a default lets the work go on and lets the owner overrule it later at a known cost. This is also why a question about a reversible choice is not asked at all.
Why a verifier is separate. A builder shares the blind spots of what it built. A fresh session, or a person who did not write the change, reads it cold. When writer and verifier are the same kind of model, the lead adds a spot check of its own, because they share blind spots.
What this item does not do. It does not set the stages of the lifecycle (that is process.project-lifecycle), the
tier definitions (mgmt.governance-tiers) or the work-package rules. It says who acts and who decides.
Examples
Good. An agent building a theme finds that two designs of a filter would both pass the checks. No ADR covers it and either is easy to change, so the agent takes the simpler one, logs it with the reason and goes on. Later it meets a choice between two hosting providers for the production site: money and keys are involved and the choice is hard to undo. The agent stops that line of work, writes three lines to the owner (the question; two options with costs; the default “stay on the current host until you decide”), and continues with the unrelated work packages.
Bad. An agent asks the owner whether to name a variable price or unit_price, and the next day deploys to the
client’s production site because “the checks were green”. The first question was a reversible detail (R3, R10); the
deployment was an outward action that only the owner decides (R9, R14).
Sources
- GOV.UK Service Manual, “Governance principles for agile service delivery” — Open Government Licence v3.0; the principles “decisions when they’re needed, at the right level”, “do not slow down delivery” and “do it only if it adds value”. Accessed 2026-11-21.
- GOV.UK Service Manual, “What each role does in a service team” — Open Government Licence v3.0; the service owner’s decision-making authority. Accessed 2026-11-21.
- Team Topologies, key concepts — all rights reserved; the interaction modes and cognitive load, paraphrased, not copied. Accessed 2026-11-21.
- ISO/IEC/IEEE 12207:2017 (software life cycle processes) — referenced by name only.