Accountability and Ownership
Hold provenance and accountability apart on purpose: four named accountabilities per product, a human owner for every agent change, seven named seats, a signed Build/Run RACI and a first-line/second-line boundary that survives consolidation.
- Version
- 0.2.0
- Owner
- DEIXEI
- Last reviewed
- Reading time
- 40 min
For Cto · Product Leader · Ai Architect · Platform Engineer · Risk And Assurance · Internal Audit
Sources and details
- Section
- Govern and prove
- Source works
- Book 1 · Book 2 · Book 3 · Book 09 · Research Series · ADD proposal · Whitepaper · Supporting Tools
- Source chapters
- 1, 3, 5, 7, 8, 9, 11, 12, 13, 18, 19, 20, 24
- Source appendices
- 01:G, 04:F
- Tool specifications
- audit_evidence_schema@0.1.0, cab_decision_record@0.1.0, deployer_manifest@0.1.0
- Refresh trigger
- source change
When an agent writes a change, two things that used to travel together in one engineer come apart: authorship (who or what produced the artefact) and accountability (which person understands it, stands behind it and answers for it). The factory can record authorship perfectly and still leave accountability blank. The books land on the same model, in different words: provenance is not accountability, and a named human always holds each accountability, including control accountability.
This page sets out that model as decisions you can make and checks you can run: who owns a product, who owns an agent’s change, which seats must be filled, who signs at management-body level, how the Build/Run RACI is assigned and kept current, and where the first line stops and the second line begins.
Reading the labels. Source claim means a book states it. Author model means a framework the books propose (the four accountabilities, the seven names, the RACI) rather than a regulatory or industry standard. Recommendation is this page’s operating advice. Asset Manager X, Bank A, Insurer I and Bank D are composite firms written for the books; their figures and people illustrate a mechanism and are not benchmarks.
The model in one table
| Question | Answer the model gives | Where it is set |
|---|---|---|
| Who is accountable for a product? | Four named accountabilities (business, technical, operational, control), never blank | Four accountabilities |
| Who owns a change an agent wrote? | The person who dispatched it and merged it; the owner field never names the agent | The sign-off rule |
| Who owns a change nobody merged? | The books leave this open; this page proposes the agent’s named owner, with sight and stop rights | The dispatch-and-gate gap |
| Who owns an agent that never opens a change? | Its named owner on the registry; no owner means the agent stops | Every agent has a findable owner |
| Which seats make it a factory rather than a pilot? | Seven named seats, tested by commits, not interviews | Seven names |
| Who signs for the framework at the top? | A management-body member, with second-line countersignature | Management-body signatory |
| Who decides each recurring decision? | One Accountable per row of a 28-decision Build/Run RACI | The RACI |
| Where does engineering authority stop? | First line federates and builds; second line adjudicates and owns the boundaries | Lines of defence |
Provenance is not accountability
Agents carry throughput; humans carry accountability. A product team now contains both kinds of worker, and only one can be interrogated six months later by an auditor, a client or an incident review (source claim, Book 2 Ch 7 §3–§4; Book 09 Ch 5).

One accountable product team, two classes of worker; agent output is owned by a named wrangler. Source: The AI Delivery Factory, Chapter 7.
If the operating model still assumes that the author is the owner, accountability does not transfer to the agent. It disappears, and nothing looks different: the tests pass and the dashboard stays green. This is the default outcome of adding agents to an unchanged team, not a rare drift.
The response is not to slow agents or to pretend a human wrote the code. It is to keep two records on purpose:
| Record | What it answers | Held by | Typical evidence |
|---|---|---|---|
| Provenance (attribution) | Which agent, under which identity and version, produced this artefact, and from which instruction | The factory: workload identity, change record, evidence pipeline | Agent workload identity on the commit and pull request; executing_agent and initiator in the Audit Evidence Schema |
| Accountability | Which named person stands behind it and can explain it in a meeting | The product team | Named owner on the change record and on the agent’s registry entry |
A complete provenance trail with no accountable name is still a finding. Equally, a named owner with no provenance cannot tell a human mistake from a machine mistake a human missed, and those need different fixes (Book 09 Ch 5).
The four-question test for any shipped change
Pick a change shipped last week and ask (author model, Book 2 Ch 7 §5; Book 09 Ch 5):
- Which team owns it?
- Which person signs for it?
- If an agent wrote it, which named person stands behind that agent?
- Where is the evidence?
All four answered means the product team is working as the unit of accountability. In the composite firm, most squads could answer questions 1 and 4; the gaps sat in 2 and 3, which is where authorship had taken accountability with it.
Four accountabilities for every product
The product team is the unit a supervisor interrogates, and the agent does not move that boundary (source claim, Book 2 Ch 7 §3; Book 3 Ch 13 §5). Within it, four accountabilities are held by named people for every product (author model, Book 2 Ch 7 §5; Book 09 Ch 5):
| Accountability | Question it answers | Agent failure it catches | Usually held by |
|---|---|---|---|
| Business | Why the product exists and whom it serves | A plausible feature nobody needed | Product lead / business owner |
| Technical | Whether the design will hold and can be maintained within enterprise boundaries | An integration wired in a way that will not scale | Lead engineer or technical owner |
| Operational | Whether it stays up, is supported and kept current | A change with no runbook, alert or on-call answer | Service owner / support rota |
| Control | Which controls apply, and whether evidence shows they operated | An agent that quietly steps round a control; the failure the other three cannot see and a supervisor finds first | A named person with a named second-line partner |
Rules.
- One person may hold several of the four. None may be unassigned, and each holder knows which ones they hold. Record the assignment where an auditor would look, not in team memory.
- Do not collapse them into a single “product owner”. At agent volume, one name for all four becomes a single point of understanding that no one can hold.
- Expect control to be the blank one. It used to live inside the act of authorship (the engineer knew which rules the change touched because they wrote it). When authorship moved to agents, the job was left behind. In the composite firm, control was the empty accountability on most products in one family.
What control accountability means concretely (Book 09 Ch 5). The control owner:
- keeps the list of controls that apply to the product (for example, who can see which client’s data, how long a downloaded statement is kept, what must never be shown before a correction clears);
- knows which of those the pipeline checks on every change and which it does not;
- receives every change that touches one of them, whoever dispatched it. Route these by rule (see change governance). Classify configuration values such as tolerances, thresholds, retention periods and limits by what they decide, not by file name.
Data products are inside the boundary. The team that owns the software also owns the data that the product produces, as products: each has a data contract, an owner, a version and a declared quality SLO. Book 2 Ch 7 §5 deliberately takes a stronger position than data-mesh practice, which allows a separate data-product team next to the producing team. The reason given is that the seam between “makes the data” and “owns the data” is where accountability leaks, and agents act on stale or unowned data at machine speed. This page follows Book 2. Contract mechanics: data, API and integration.
The work moves up the stack, and three roles sharpen (Book 2 Ch 7 §4). The humans spend less time typing and more on specifying (intent.md, spec.md), reviewing for product fitness, and wrangling agents. Standing behind change you did not write is harder work, not easier. Three roles become more important:
| Role | Job in an agent team |
|---|---|
| Agent wrangler | The named human to whom an agent’s output is attached; owns its bounded-agency envelope |
| Business analyst | Manages how business expectations change once people can use working slices within days |
| Adoption lead | Reads usage telemetry and steers what the product does next; value comes from use, not from shipping |
Do not read the handover of typing to agents as a headcount plan. The volume of change rises, and the people standing behind it need time for specifying and review (Book 2 Ch 7 §4 and §8).
Who owns an agent’s change
The rule (source claim, Book 09 Ch 5; Book 2 Ch 7 §6): whoever dispatched an agent’s change and merged it is its accountable owner. That person’s name goes in the owner or sign-off field. The agent’s identity never does.
Why the dispatcher, not the reviewer. In a four-eyes control the second signature usually counts most. With an agent as author, intent enters at dispatch: the instruction, the specification it points to, and the boundaries the dispatcher set or forgot. The reviewer judges what came back. The dispatcher knows what should have come back. Accountability sits with the person who holds both ends. The reviewer still signs for the review.
What the reviewer signs for. Without this, the reviewer’s approval half-implies ownership. The composite firm changed its review template to make the reviewer:
- confirm they read the change against its plan, not only against itself;
- state where the tests came from, and say so explicitly if they came only from the authoring agent;
- name, in their own words, the first thing they would check if the change went wrong.
Record two facts, not one. Update change and pull-request templates wherever they still assume the author is the owner:
| Capture | Where it lands today (AES v0.1.0) | Note |
|---|---|---|
| Agent identity that authored the change (provenance) | Commit trailer and pull request carry the agent’s workload identity; cab_change.submitter.agent_id; evidence executing_agent.agent_id, agent_version, system_prompt_version | Each agent runs under its own identity, never a borrowed human sign-in |
| Human who dispatched and will merge (accountability) | cab_change.submitter.user_upn when a person submits; in the evidence record, approval.approvers[].upn and role, and initiator of type human with user_upn | See the schema gap below |
| Named owner of the agent itself | Registry record, linked from the change record; Deployer Manifest metadata.agent_wrangler_upn and metadata.owner_team (both required) | Anyone reading a change can see who wrote it and who answers for the machine that wrote it |
| Product-fitness questions | Review template | Correct? Built the way we build here? Serves the business need? |
Schema gap to close locally (observation on the published schemas, not a source claim). In cab_change.json the submitter carries exactly one of user_upn or agent_id (a oneOf). In the Audit Evidence Schema the initiator can be agent or scheduled, and approval.required may be false if a policy is cited. That allows the gate-approved, workflow-dispatched case below. It means v0.1.0 does not, by itself, enforce a human accountable owner on every change. Enforce it in local policy (a required named-owner field on the change record, or a pipeline check that resolves the agent’s registered owner) until the schema carries it. Do not invent a field name in shared artefacts without versioning the schema; see schemas and tools.
Put the rule where the agents read it. The composite squad placed the one-sentence rule in each repository’s standing-context file (for Claude Code, CLAUDE.md) before it went into policy, so agents operating in the repository see it. The firm then added it to its change policy. Note Book 3 Ch 13 §4.2’s caution: a CLAUDE.md line steers behaviour but is not a control. The enforcing control is the change template, the pipeline check and the merge protection.
Impersonation is refused by name. An agent running on its launcher’s own credentials (for example, a coding agent on a laptop signed in as the engineer) makes the history claim the person wrote lines they did not write. It also lets the agent reach everything the person can, including approval rights. Give every agent its own identity, register it with a named owner, scope it narrowly, and keep it from approving anything (Book 09 Ch 5). Delegated (on-behalf-of) action is a separate pattern with its own mechanics. Identity mechanics: identity and secrets.
Merge ownership in vendor terms (as of August 2026, per Book 3 Ch 13 §4.3). Anthropic describes automated code review on every pull request. Book 3’s position is that agentic review helps the reviewer but does not discharge four-eyes, and that one named human is accountable for each merge. The dispatch pattern is Define → Dispatch → Review & Merge: the wrangler defines and dispatches, agents work, and a person owns the merge. Loop detail: agent-speed SDLC. [FACT-CHECK: Anthropic code-review statistics quoted in Book 3 Ch 13 §4.3 (substantive comments on 16% rising to 54% of pull requests; under 1% of findings marked incorrect) against Anthropic’s current published figures.]
The gap when a workflow dispatches and a gate merges
The dispatcher-and-merger rule assumes a human merges. Once a routing gate approves changes without a reviewer, and a workflow dispatches the agent for a requester who never sees the change, the rule has nobody to point at (source claim, Book 09 Ch 8–9).
Composite example (Asset Manager X, Book 09 Ch 8). An analyst raised a standard request to add a new custodian feed. The workflow dispatched the reconciliations agent. The agent changed four lines of matching configuration, with fourteen tests it had generated itself. The routing gate scored it low-risk and merged it. The owner field read auto-approved (routing gate). The analyst had not chosen the agent, seen the change or merged anything, so she was not the owner. The agent’s named owner had been routed out of her own agent’s change and could not stop it.
What the books settle and what they leave open.
- Settled: an owner field that names a mechanism, service account or team mailbox is an empty field that looks filled.
- Settled: a requester who dispatched nothing and merged nothing is not the owner (Book 09 Ch 9).
- Open in the source: the composite second-line head’s view is that the agent’s named owner stays on the record, and that what must change is that the owner can see and stop gate-approved changes. The book says explicitly that what an owner owns when no engineer merges is still unwritten.
This page’s proposal (recommendation). Until your policy says otherwise:
- For gate-merged changes, record the agent’s named owner as accountable owner, and record the requester separately as requester.
- Give that owner a feed of every change their agent ships without a human reviewer, and a working stop (pause the agent or close its auto-approval route) that does not need the gate’s owner.
- Send every change that touches a listed control value to a human reviewer, whatever its score. The gate may say yes or route to review; values that decide what someone will see are never decided by score alone. Routing mechanics: change governance.
- Treat moving the gate’s threshold as a change to a key control, governed by a documented procedure: how the line is set and moved, by whom, on what evidence, and where each move is recorded (Book 09 Ch 12). The chief risk officer signs the band within which the line may move; the CIO runs the line inside it. Operating detail lives on running the factory.
Monthly check (Book 09 Ch 8). Sample ten changes the gate approved without a person. For each, read the owner field: does it name someone who could explain the change in a meeting? Then ask who wrote the tests. A change tested only by tests generated alongside it should score riskier. A change that alters a test someone else wrote should score riskier still.
Every agent has a findable owner
The change rule covers agents that make changes. Agents that make none, such as a nightly classifier or a mailbox automation answering outside parties, need an owner too. The registry, not the change record, is where this is checked (source claim, Book 09 Ch 5 and Ch 8).
Composite example (Asset Manager X, Book 09 Ch 5). A hackathon document classifier ran nightly under a hurried pipeline account. It could read the whole inbound document store, and no access review ever listed it, because reviews listed people. Two squads each said the other owned it, so the platform head, with the CIO’s agreement, switched it off on a Friday evening. On the Monday, about three hundred documents a night arrived unsorted for a team that had relied on its labels without knowing it existed. An agent without an owner is an unowned dependency, and the people depending on it may not know it exists.
Rules for agent ownership.
| Rule | Detail | Source |
|---|---|---|
| Name the owner before the agent is built | Owners named after production are how the floating-agent incident happens | Book 1 Ch 12 §7 |
| No owner, no running | If no one will accept ownership, suspend or decommission. Hard pushback from the senior person in the function is a signal the agent should not exist | Book 1 Ch 12 §7; Book 09 Ch 5 |
| No dispatch without a wrangler | Refuse to dispatch an agent that has no attached wrangler; make it a precondition the factory enforces | Book 2 Ch 7 §7–§8 |
| Owner sits in the business, not platform engineering | At registration, the wrangler identity must resolve to a directory group outside platform engineering, or the envelope fails validation (Book 3 uses an Entra group) | Book 3 Ch 13 §7 |
| Certified before named | Book 3’s composite programme: four modules (envelope, Audit Evidence Schema, gateway and policy decision point, incident shapes), four hours’ reading plus a one-hour walkthrough, recertified annually. Registration fails without a certified wrangler | Book 3 Ch 13 §4.1 |
| Suspend authority is real and tested | Suspension hotline tested quarterly for every production envelope; exercise suspend at the first periodic review | Book 3 Ch 13 OD-1; Book 1 Ch 12 §7 |
| Route to the role, not the person | Routing rules name “whoever owns transforms”, not a specific person, so the work survives leave and turnover | Book 09 Ch 11 |
Route to role, and transfer knowledge by reading after (Book 09 Ch 11). In the composite migration, the obvious fix was to send every transform to the one engineer who knew the system. She refused. The work went to the role’s new holder, and she read his approvals after him for a month without overriding them. Queue time rose by about a day. He caught an account-number reuse defect she would have missed. A week later, a fee-balance check an analyst had built, running nightly, caught a defect in a transform they had both approved. Recommendation: when expertise sits in one person, keep the routing rule on the role, assign the successor, and run a time-boxed read-after period. Treat a miss as a defect in what let it through, not as a reason to re-centralise.
Wrangler span and load. The sources give two numbers. They are layered, not contradictory:
| Source | Number | What it limits |
|---|---|---|
| Book 1 Ch 1 §7.1 | No more than five to seven agents per wrangler (stated for a 50,000-employee firm with 50–200 agents on first count) | Overall span when naming wranglers across an inventory |
| Book 1 Ch 12 §7 | About three CIF agents per wrangler; five non-CIF (authors’ 2025–2026 experience) | Sustainable load where the agent supports a critical or important function |
| Book 1 Appendix G §G.4 | Breaching the three-CIF ceiling is named as the typical risk when the agent estate outgrows operations capacity | Advice: limit how fast agents are added by review capacity, not throughput |
This page follows the stricter Chapter 12 ceiling wherever any agent is CIF-supporting. For example, thirty CIF agents need at least ten CIF wranglers. Book 1 Ch 1 also gives a fifteen-minute test: if an agent acts wrongly today, can you name its accountable human within fifteen minutes?
Three tiers, not one (Book 3 Ch 13 §4.4). Show all three in the RACI:
| Tier | Owns | Boundary |
|---|---|---|
| Champion | Nothing in the control sense; a volunteer who multiplies adoption | Capped time; refers security and data-handling questions to administrators rather than improvising |
| Wrangler | One agent’s behaviour and envelope | Named, certified, holds suspend authority |
| Product owner | The workflow and its risk acceptance | Re-signs the workflow risk acceptance every six months; distinct person from the wrangler |
Making your most enthusiastic champion the wrangler for six agents builds a single point of failure. As of August 2026, per Book 3 Ch 13 §4.4, Anthropic’s published rollout guidance suggests a pilot of 20–50 developers already using AI tools, then converting pilot users into a champion network. Its champion kit suggests about forty minutes a week and a thirty-day playbook. Book 3 keeps the cohort size and the champion network, and rejects the broad hackathon launch for regulated firms (entitlement follows tier classification and second-line sign-off). It recommends pre-positioning an approved answer pack (residency, retention, training on data, contract terms) and, from Anthropic’s communications kit, having the data-handling answer signed by Legal and the DPO before the first announcement. [FACT-CHECK: current Anthropic rollout, champion-kit and communications-kit guidance on code.claude.com against the figures above.]
Vendor note. As of May 2026, per Book 1 Ch 12 §4.4.1, Microsoft was the only hyperscaler with a productised wrangler equivalent: the Entra ID Governance sponsor lifecycle workflow, integrated with Agent 365 and Entra Agent ID, which assigns a sponsor at agent creation, sets periodic review tasks and cascades revocation on departure. [FACT-CHECK: current GA status and feature set of Entra ID Governance sponsor workflows for agent identities, and any AWS or GCP equivalent released since.] Lifecycle detail: agent lifecycle.
Seven names and the blank test
The four accountabilities are per product. The seven names are the minimum set of seats a factory needs, each chosen by asking what breaks, and how fast, if nobody holds it (author model, Book 2 Ch 24 §7; Book 09 Closing). If any seat is blank, you have a pilot, not a factory.
Book 2 and Book 09 describe the same seven seats with different labels. This page gives both:
| Seat (Book 2 Ch 24 label / Book 09 label) | What breaks when it is empty |
|---|---|
| Agent wrangler / named owner of each agent | Change ships that no one stands behind; in a regulated firm that is a finding |
| Head of the factory / person accountable for delivery end to end | Priority goes to whoever shouts loudest; intake becomes a form; the roadmap discussion stops |
| Factory architect / architect who owns the standard designs and recipes | The pattern corpus rots by committee, and every agent copies the rot at full speed. “Diverges from the architecture” means nothing until someone owns the word |
| Product lead for each product | The factory optimises throughput and builds what was asked for, unused |
| Business analyst who specifies each product | Agents build plausible but wrong products from thin intent faster than anyone can catch them |
| Agent-fleet operator | Autonomy is granted on anecdote; runaway loops burn unwatched |
| Operational owner of each product in production | The factory can build but not run: playbooks, alerts and escalations belong to no one |
Deliberate omissions (Book 2 Ch 24 §7). Control accountability and adoption reading are required accountabilities, not required posts: in a small factory, control is a named hat backed by the evidence record, and the product lead reads adoption. Both become posts as the factory grows. The scrum master’s cadence work is essential, but the role can move to the team lead. Context-asset stewardship is a duty of the platform lead, not an eighth seat.
The blank test is a query, not an interview (Book 2 Ch 24 §7). The artefact chain intent.md → spec.md → plan.md is committed to each product repository. That makes three of the names checkable from history. For every product in production, show:
- the commit that accepted (or rejected) the
intent.md, and who made it: the product lead; - the commit that last amended the
spec.md, and who made it: the business analyst; - the wrangler’s approval of the
plan.mdbefore code was written.
A product with no committed intent has no name behind its intent, whatever the organisation chart says. Artefact chain detail: agent-speed SDLC.
Rules for holding seats.
- One person may hold several seats if it is declared in writing. A blank declared in advance is a staffing decision; a blank found in an audit is a finding (Book 09 Closing).
- In the 90-day sequence of Book 09 Closing, the delivery-end-to-end seat and the architect seat are held by people for whom it is the job, not a second job. The other five are named even where shared, and every agent owner is trained and appointed before the first agent reaches production.
- Refuse one combination at any size: a single person who builds the controls on the agents and also tests whether they work (Book 09 Closing).
- Book 2 also makes the seven names the owners of the Factory Charter’s values: every declared value belongs to one of the seven. A value with no named owner is a blank like any other.
- Human duties that recipes create (a supervisor for approvals and exceptions, an annotator of golden records, a feedback provider) are recorded on the recipe with hours against them and filled from existing people. A supervisor with no hours is an approval queue nobody reads (Book 2 Ch 24 §7).
The management-body signatory
Book 3 Ch 3 §4 reads DORA as placing responsibility for the ICT risk-management framework, including its AI components, on the management body. Its reading is that this cannot be passed down to the head of platform or carried by the CIO alone. A named management-body member must have signed for the framework, and that signature extends to the AI programme. The article-level text and its application dates are kept on the regulatory map. Do not restate them in local policy without checking there.
What to do (recommendation drawn from Book 3 Ch 3 §4 and Appendix F).
- Name, in writing, the management-body member who signs for the ICT risk framework covering AI agents, and the second-line owner who countersigns.
- Make that person the Executive Sponsor seat in the RACI below. In Book 3 they are Accountable for the deployment route, Tier 3 envelopes, landing-zone sign-off, the prohibited-use list, supervisor notification, TLPT scope and board reporting.
- Keep the RACI on one page, ready for a supervisory governance review.
Composite example (Bank A, Book 3 Ch 3). Asked in a corridor who on the management body had signed, the CIO had no name. By the end of the supervisory meeting the bank had one: the CFO, who held operational risk at board level, with the Group CRO countersigning as second-line owner. The supervisor did not need the document that day. It needed to know the document existed, carried a name, and that the name reported to the board.
The Build/Run RACI (28 decisions)
Book 3 Appendix F provides a reference composite RACI for a Claude operating model. It maps eleven named roles, plus three operational roles, against twenty-eight decisions. Adapt the roles to your structure and keep the conventions (author model; Claude-specific in places).
Roles and lines of defence
| Line | Roles (abbreviation) |
|---|---|
| Executive | Executive Sponsor (ES): holds the management-body signature |
| 1st line | AI Platform Owner (APO); AI Platform Product Owner (APPO, maintains the matrix); Business Owner per use case (BO); Agent Wrangler (AW, sits in the business function) |
| 2nd line | Head of Model Risk (MR); CISO; Chief Data Officer (CDO); Data Protection Officer (DPO, kept separate from CDO); Legal & Compliance (L&C); Procurement Lead (PROC) |
| Cross-line | Virtual CAB Chair (VCC): chairs a body spanning first-line owners and second-line challengers |
| 3rd line | Internal Audit (IA): receives the sign-off pack on copy, not for signature |
| Operational | SOC: in the CISO’s reporting line, operating with first-line speed; where SOC is Responsible, the CISO is the accountable equivalent |
Conventions
- One Accountable per row, no exceptions. If two functions claim A, the AI Steering Committee picks one and the other becomes Consulted, with sign-off recorded.
- Cross-line decisions name a chair, not two Accountables.
- Consulted means sign-off before the decision proceeds, and the Consulted role’s name appears on the artefact. Asking is not consulting.
- Informed within the agreed cadence: routine matters at the next monthly Agent Control Board; incidents immediately.
- Several Responsibles are allowed. Internal Audit is Informed on most rows and Consulted on red-team planning, TLPT scope and board reporting (rows 24–26); it never signs.
The matrix (Accountable and Responsible; Consulted in brief)
| # | Decision | A | R | C (summary) |
|---|---|---|---|---|
| 1 | Deployment route choice | ES | APO, APPO, PROC | MR, CISO, CDO, DPO, L&C |
| 2 | Identity integration baseline | APO | APPO | CISO |
| 3 | LLM gateway build vs buy | APO | APPO | CISO, L&C, PROC |
| 4 | MCP server intake, tier R0 | APPO | APO | AW |
| 5 | MCP server intake, tier R1 | APPO | APO, AW | BO, CISO, CDO |
| 6 | MCP server intake, tier R2 | VCC | APO, APPO, AW | BO, MR, CISO, CDO, DPO, L&C, PROC |
| 7 | Claude Code managed settings.json baseline | APPO | APO | CISO |
| 8 | API agent envelope, tier 0–1 | AW | APO, APPO | BO |
| 9 | API agent envelope, tier 2 | VCC | APO, APPO, AW | BO, MR, CISO, CDO, DPO |
| 10 | API agent envelope, tier 3 | ES | APO, APPO, AW | BO, MR, CISO, CDO, DPO, L&C, VCC |
| 11 | Data classification framework refresh | CDO | DPO | APO, MR, CISO, L&C |
| 12 | Audit Evidence Schema implementation | CISO | APO, APPO | MR, CDO |
| 13 | Landing-zone sign-off | ES | APO, MR, CISO, CDO, DPO | L&C |
| 14 | Wrangler assignment | BO | AW | APO |
| 15 | Risk-tier classification of a new use case | MR | BO | APO, APPO, AW, CISO, DPO, L&C |
| 16 | Prohibited-use list maintenance | ES | L&C | APO, MR, CISO, DPO |
| 17 | Agent Control Board: new agent to production | VCC | BO, AW | APO, APPO, MR, CISO, CDO, DPO, L&C |
| 18 | Virtual CAB: tier 2 change | VCC | AW | APO, APPO, BO, MR, CISO, CDO |
| 19 | Model upgrade, minor within a family | APPO | APO | AW, MR, VCC |
| 20 | Model upgrade, across families | VCC | APO, APPO | BO, AW, MR, CISO, CDO |
| 21 | Incident classification, major ICT-related | L&C | APO, CISO, SOC | ES, BO, AW, MR, DPO |
| 22 | Incident communication: supervisor notification | ES | L&C | DPO |
| 23 | Cost budget exception | APPO | BO | APO, AW, PROC |
| 24 | Red-team programme planning | CISO | SOC | APO, APPO, MR, IA |
| 25 | TLPT scope inclusion of AI agents | ES | CISO | APO, MR, L&C, IA |
| 26 | Board reporting cadence and content | ES | L&C | APO, MR, CISO, CDO, DPO, IA |
| 27 | Vendor concentration assessment | PROC | (none named) | ES, APO, MR, L&C |
| 28 | Exit rehearsal: supplier suspension drill | PROC | APO, APPO, SOC | CISO, L&C |
Rows 1–13 are Build and rows 14–28 are Run. Points to carry into your own version:
- Row 14: the business function names the wrangler, not engineering. The Business Owner is Accountable and the wrangler is Responsible. The same applies to suspension: the wrangler performs it under authority delegated through the envelope.
- Rows 4–6: MCP intake escalates by tier. R0 (internal, no egress) is approved at the platform; R2 (external, regulated data) goes to the Virtual CAB. See the MCP and connector broker.
- Row 13: each second-line head is Responsible for the design effectiveness of their own control area. The Executive Sponsor is the single Accountable seat the supervisor reads. Internal Audit follows in the next quarterly cycle and does not sign the design.
- Row 17’s evidence pack has seven sections, each with a named owner: envelope, tier classification, evaluation results, human-oversight design, evidence sample, support model and suspension criteria. The decision record carries the signatories’ directory UPNs and the date the decision was taken.
- Incident reporting clocks referenced in rows 21–22 are regulatory dates; check them on the regulatory map.
- Source difference. Book 3 places the CISO in the second line. Book 2 Ch 20 and Book 09 Ch 12 move security engineering into a first-line department and keep the CISO’s policy, refusal rules and incident command as a control function. These are compatible if the RACI’s CISO column means the policy owner. Re-map engineering rows to the platform owner when you consolidate.
Operate the RACI as a runtime asset
A matrix signed once and stored is theatre: names go stale and nobody notices (Book 3 Ch 13 §7). Run it like this (Book 3 Ch 13 §6 and OD-1; Appendix F §6):
| Control | Cadence | Owner |
|---|---|---|
| Sample three rows and check every name is current against the directory | Monthly (4th Friday in Book 3’s composite) | AI Platform Product Owner |
| Every named role resolves to an active directory group | Each quarterly review | AI Platform Product Owner |
| Version stamp on every Agent Control Board pack; the version in force on the action date is the one cited in evidence | Every pack | AI Platform Product Owner |
| Review and re-sign the matrix; close prior-year exceptions; record new ones with named remediation owners | Annually (Q1, with the Register of Information window in Book 3) | Executive Sponsor via AI Steering Committee |
| Publish on the policy portal: read for every named role, write for the maintainer, sign-off log for the committee | Continuous | AI Platform Product Owner |
Update outside the annual cycle on any of four triggers: a new named regulatory obligation; a new, merged or renamed role title (do not merge CDO and DPO); a major shift from Build to Run, such as landing-zone sign-off or the first production agent; or an incident review that finds two roles both felt Accountable, or a Consulted role was not consulted. Retain superseded versions for the firm’s evidence retention period (Book 3’s composite uses ten years). Acceptance: in a random sample of three rows, two stale names means the matrix is not being operated.
First line federates, second line adjudicates
Domain teams get real latitude inside declared boundaries, and enforcement must be computational. That half of data mesh’s federated governance holds. The other half, the second line as one member of a federation of domain owners, is refused in a regulated firm (source claim, Book 2 Ch 8 §4.6):
| Layer | Who | What they may do |
|---|---|---|
| First line federates | Product teams and the platform | Set their own practice inside declared boundaries; depart from a guideline on purpose and answer for it (see policy, audit and actuals) |
| Second line adjudicates | Risk, compliance, the CISO as policy owner | Own the boundaries, read the evidence, rule on exceptions; answerable to the supervisor, not to the domains |
| Non-negotiable floor | Regulatory obligations | Not open to a vote. A federation that can relax a retention rule by consensus is a control deficiency with a decision process |
The consolidation boundary: what moves and what stays
Book 2 Ch 19–20 and Book 09 Ch 12 argue for consolidating first-line platform engineering, because an agent going to production touches eight surfaces: identity, data, model, tool, network path, policy, record and pipeline. Spread across eight teams, every agent becomes an inter-team integration project. The argument holds only if a boundary is drawn first and defended harder than the consolidation itself:
| Moves into one first-line function | Stays outside it |
|---|---|
| Cloud platform, cloud operations and engineering; identity engineering and operations; network engineering and operations; security engineering (tooling, gateways, API management); model serving and MLOps; the agent delivery centre | CISO: security policy, refusal rules, threat intelligence, incident command for security incidents, audit liaison. CRO: all of second-line risk. DPO: unchanged. Business lines: ownership of every business product and decision |
Rules that make the boundary structural (Book 09 Ch 12; Book 2 Ch 19 §8, Ch 20 §4.3):
- Evidence goes to the second line, never instead of it. The second line reads the evidence record directly, through access granted under the CISO’s identity rules rather than by the department, which cannot revoke it, filter it or decide when it refreshes.
- The department runs the door; the CISO decides what it refuses. Restricted lists in the broker, which data class may go to which model, and gateway blocks are policy. The composite compromise was rules held as code in a repository the department deploys from, with the CISO’s team’s approval as the only gate and two working days as the turnaround.
- The second line tests against things the department did not make: the CISO’s refusal rules, the signed list of control values (tolerances, thresholds, limits), and the signed control-budget band.
- Sequence the moves. Write the stay-list first and take it to the CISO, the CRO and the DPO one at a time before tabling the consolidation (Book 2 Ch 20 §7). Move a smaller first phase, and move security engineering last, after identity engineering, once on-call arrangements for both are rewritten jointly and signed. In the composite, the board approved a smaller first phase and released later phases against evidence that the first worked, never against a date.
- Failure signature. A boundary drawn wide ends with the department signing the risk opinion on its own work, or owning a decision the business line should own, with nothing sent out for challenge.
- If you cannot draw the line convincingly, do not table the consolidation (Book 2 Ch 19 §8).
Never split specification from execution into separate departments (Research Paper 6, §3.5 and §4). An AI factory runs two cadences: a human-paced one where intent is written, and a machine-paced one where agents execute. Placed in two organisations, a specification department feeding an agent pool, they rebuild the design/construction split that undid the first software factories, with the feedback loop cut in the same place. Agent capacity may be a central platform service. The people who write intent and the people who read what came back must be the same product team.
Where agent governance does not belong. Do not route operating-model governance of agents through an AI ethics committee that meets monthly and issues position papers. Keep the committee on fairness, bias, model selection and customer impact, and run agent operating governance from the CIO’s organisation (Book 1 Ch 1 §8.4). Where a Chief AI Officer exists separately, the CAIO sets direction, the CIO enforces at runtime, and both agree the operating model before any agent ships (Book 1 Ch 1 §4.5). The whitepaper’s role architecture adds a policy engineer who turns intent into runtime rules, and names control-level competences (reviewing agent behaviour against a policy library; codifying business intent as enforceable rules; incident runbooks for agents that fan out across systems) as the real skills gap (Whitepaper Part II §4).
Team archetypes, pods and sizing
Four archetypes (author model, Book 1 Ch 18 §4.1, instantiated in Book 2 Ch 20 §5.4):
| Archetype | Owns | Indicative share of IT headcount (Book 1) |
|---|---|---|
| Business-facing product squads | Use cases end to end; every agent has a sponsoring squad and named wrangler; the adoption lead sits here | 60–70% |
| Platform and enablement | Landing zones, identity, network zoning, API management, model inventory, AI gateway, policy engine, evidence pipeline; Skills Library and ADR/GIP repositories | 15–20% |
| Control and assurance | Evidence engineering and regulatory mapping (see source difference below) | 8–12% |
| AI-agent operations | Agent estate lifecycle: registration, permissions, prompts and policies, tool access, evaluation, monitoring, drift, incidents, decommissioning; the wrangler community of practice. “SRE for agents” | 2–5% now, rising to 5–10% over 18–24 months |
Source difference. Book 1 Ch 18 describes control and assurance as bringing second-line risk, internal audit and operating governance onto one control plane, with read access to registry, decisions, evaluations and evidence. Book 2 Ch 20 §5.4 and the ADD proposal brief §7 define it as first-line evidence engineering that feeds the second line rather than replacing it. This page follows Book 2: the team sits in the first line, and second-line and audit access is granted, not owned, by it. That keeps the stay-list intact. The ADD proposal is a firm-specific proposal with open questions; its staffing figures are not reproduced here.
The pod (Book 2 Ch 24 §4.4). A pod is the working unit of seven to nine people and their agents, nested inside a product team. The product team is the accountability boundary; the pod is where work happens. A large product team runs several pods; a small one is a single pod. The shape follows the intake assessment (a low-code integration needs different people and agent tuning from a custom build). Pods usually include a team lead, a scrum master for the human cadence, DevOps, business analysis, and engineers who also wrangle agents. Treat communication within the pod as a control: a small misunderstanding can compound at agent speed before anyone reads the output.
Proportionality by size. The discipline stays the same; the number of people holding seats changes.
| Firm size (as the sources frame it) | How seats collapse | Source |
|---|---|---|
| A few hundred people, around seventy engineers | Seven seats shared among three or four people, declared; refuse builder-and-tester of controls in one person | Book 09 Closing |
| About 1,000 employees, 5–15 agents (Bank D composite) | One person may carry three of the four accountabilities and wrangle every agent, if written down (Book 2 states this for a small firm generally). Platform pillars: five owners across ten pillars is the floor; one owner for all ten is a single point of failure. Name a wrangler for every agent in week one, even at three agents | Book 2 Ch 7 §7; Book 1 Ch 5 §7.2; Book 1 App G §G.4 |
| Global, 50,000 employees | Each framework altitude and platform pillar has a dedicated team and accountable director; wrangler naming runs as a four-week programme | Book 1 Ch 5 §7.1; Book 1 Ch 12 §7 |
| A few thousand, technology already under one head | Organisational work is nearly free; borrow the operating model and size controls to risk | Book 09 Closing |
Proportionality changes how a control is implemented, not the need to show that it works. Regulatory proportionality provisions are on the regulatory map.
Make platform and product responsibilities meet cleanly
This section is operating advice (recommendation) built on the source rules cited inline; the hand-off table is this page’s synthesis, not a table from the books.
| Product or service team owns | Shared platform team owns | Joint hand-off |
|---|---|---|
| Product purpose, user outcomes, domain rules and service-level expectations | Supported runtime, identity and policy mechanisms, shared model/tool gateways, logging and evidence services | Agree supported patterns, service boundaries, dependency and escalation contacts before production. |
| Agent configuration and behaviour within approved boundaries; named wrangler | Tenant, network, identity, secrets, platform guardrails, platform availability and technical operations | Bind product identity and scopes to approved platform controls; document who can change each boundary. |
| Product tests, evaluations, release evidence, service runbooks and recovery plan | Reusable pipeline, policy enforcement, shared control evidence and platform incident response | Link product artefact versions to platform policy/configuration and deployment records. |
| Product-level incident triage, customer impact and remediation | Platform-level detection, containment and restoration for shared components | Agree severity, incident command transfer, notification path, evidence preservation and post-incident review. |
Platform owns the road, not the journey. When incident reviews keep routing product decisions to the platform team, accountability has drifted (Book 2 Ch 7 §8). Engineering may implement security controls without becoming the CISO. A platform owner may run data infrastructure without becoming accountable for what the data means or how it may be used.
Hand-offs as acceptance gates (recommendation). Before a product team accepts a shared platform dependency, agree the interface, supported configuration, service expectations, available evidence, operational contact and escalation route. Before platform operations accept a workload into a shared runtime, require from the product owner and wrangler: purpose, scope, dependencies, evaluation and test evidence, monitoring, recovery steps, support rota and an explicit stop route.
Build-to-run transfer. Do not hand over only a repository or a deployment ticket. Transfer the ownership record, agent and service inventory, versions, operational envelope, unresolved risks, evidence locations, runbooks, alert routing, known failure modes and planned changes. The receiving team acknowledges what it can operate. Gaps get a named owner and a due date, or block acceptance under local policy. Under Book 3’s RACI maintenance rules, this shift also triggers a matrix update.
During an incident. The detecting team raises it through the agreed route. The incident commander directs; the product owner assesses product and user impact; the wrangler supplies agent context and uses authorised suspension; platform responders contain shared services. For security incidents, command stays with the CISO even after consolidation. Record who took command and when. Return unresolved product changes through normal change governance.
Failure modes and recovery
| Failure mode | How you recognise it | Recovery |
|---|---|---|
| Accountability follows authorship | The owner field holds an agent identity, is blank, or says “the AI” | Record provenance and accountability as two fields; a named human signs every agent change |
| Owner names a mechanism | Owner reads “auto-approved”, a service account or a team mailbox | Monthly ten-change sample; apply the gate-merge proposal above |
| Agent with no wrangler | An agent identity in commit history with no human accountability line; an agent on logs but not on the register | Refuse dispatch without an attached wrangler; suspend unowned agents; register owners for non-change agents |
| Engineer-as-wrangler | The wrangler identity resolves to platform engineering; the suspension hotline rings someone who can fix the agent but not explain the business impact | Registry refuses an envelope whose wrangler resolves to platform engineering |
| Wrangler in name only | last_reviewed_at behind cadence; quarterly attestation signed in minutes with no working paper | Daily review as a signed registry entry, with a SOC rule alerting on its absence (Book 3 Ch 13 §7) |
| Product team without operational accountability | A post-incident review cannot name the product team’s contribution | Wrangler item on the team’s monthly review; product owner re-signs risk acceptance every six months; wrangler on the agent’s on-call rota |
| Two Accountables on a row | Count the A’s; more than one | AI Steering Committee picks one; the other becomes Consulted with sign-off |
| Platform made accountable for product outcomes | Incident reviews route product decisions to platform | Keep the four accountabilities inside the product team |
| Security and risk as a late gate | Review latency climbs with agent throughput | Bring control into specifying, so the recipe constrains the agent and the gate confirms rather than discovers |
| Skill shift announced but not resourced | Best engineers leave; review quality erodes under volume | Staff and time specifying, reviewing and wrangling as the real work |
| Champion made wrangler for many agents | One volunteer appears as wrangler on many envelopes | Enforce the three tiers; apply the span and CIF load ceiling |
| Hero routing | All of one change type routed to one expert “until things settle” | Route to the role, assign the successor, read after for a fixed period |
| Specification department | Intent writers and agent operators in different organisations | Rejoin them in one product team; centralise only agent capacity |
| Wide consolidation boundary | The department signs risk opinions on its own work | Redraw the stay-list; second line tests against artefacts the department did not make |
Acceptance checks
A product, agent estate or operating model passes when all of these hold:
- For each production product, four named accountabilities are recorded, including control with a named second-line partner; any combined holders are declared.
- Change and pull-request templates capture the agent identity (provenance) and the dispatching and merging human (accountability) as separate fields. No owner field accepts an agent identity or a mechanism.
- A sample of ten gate-approved changes shows a named human accountable owner on each, and that owner could see and stop them.
- Every change touching a listed control value went to a human reviewer, routed to the control owner.
- Every registered agent, including those that never open a change, has a named, certified owner in the business function and a deputy. No unregistered agent identity appears in logs.
- No CIF wrangler holds more than three CIF agents, or a documented exception exists with an owner and a date.
- The seven seats are named in one place, shared seats are declared, and the commit query returns intent, spec and plan signatures for every product in production.
- A management-body signatory and second-line countersignatory for the AI components of the ICT risk framework are named in writing.
- The RACI has exactly one Accountable per row, carries a version stamp on the current Agent Control Board pack, and the last three-row name-currency sample passed.
- The consolidation stay-list is written down; the second line’s read access to evidence cannot be revoked by the first-line department; refusal rules are owned by the CISO.
- Specification and agent execution for each product sit in the same product team.
Source and status
This page synthesises the cited works. The four accountabilities, the seven names, the four team archetypes and the RACI are author models, not industry standards or supervisory expectations; Book 09 says explicitly that its seven owners and size bands are a starting point. Book 3’s RACI is a Claude-focused reference composite built around a composite bank. Work-stream 03 (the ADD proposal) is a firm-specific proposal with unresolved decisions, not evidence of a deployed organisation. The proposal for gate-merged changes is this page’s recommendation where the source leaves the question open. Vendor statements are dated to the book that reported them and marked for verification. Regulatory readings belong to the regulatory map; role assignments and separation-of-duties requirements need institution-specific legal and risk review before adoption.
Source material
- Book 1, Chapter 1, The Adoption Gap (§4.5 CIO/CAIO split; §7.1 wrangler span; §8.4 the AI ethics committee anti-pattern)
- Book 1, Chapter 5, The Framework Backbone (§7 pillar ownership by firm size)
- Book 1, Chapter 12, The Agent Wrangler and the Agent Lifecycle (§7 wrangler load ceiling and naming programme)
- Book 1, Chapter 18, The Implementation Roadmap (§4.1 the four team archetypes)
- Book 1, Appendix G, Programme Phasing and Governance (§G.4 maturity-aware sequencing matrix)
- Book 2, Chapter 7, The Product Team as the Unit of Accountability
- Book 2, Chapter 8, The Policy / Audit / Actuals Loop (§4.6 the federation boundary)
- Book 2, Chapter 19, The Motivations, Benefits and Difficulties (§8 the perceived loss of authority)
- Book 2, Chapter 20, Agent-Driven Departments (§4.2 the consolidation argument; §4.3 what consolidates and what does not; §5.4 the team shape; §7 practical application)
- Book 2, Chapter 24, Running the Factory (§4.4 the pod; §7 the seven names)
- Book 3, Chapter 3, The Control Plane Is Yours (§3.5 operating-model layer; §4 DORA and the management body)
- Book 3, Chapter 13, Wranglers, Product Teams and RACI (including OD-1 cadence table)
- Book 3, Appendix F, RACI Matrix for the Claude Operating Model
- Book 09 (Everything Is Green), Chapter 5, Whose Name Goes Here
- Book 09 (Everything Is Green), Chapter 8, The Number That Was Too Good
- Book 09 (Everything Is Green), Chapter 9, One Query
- Book 09 (Everything Is Green), Chapter 11, Mary's Migration
- Book 09 (Everything Is Green), Chapter 12, Who Holds the Dial
- Book 09 (Everything Is Green), Closing, An Afternoon With a Pencil (seven owners; at your size)
- Research Paper 6, The AI Factory versus the Software Factory (§3.5, §4)
- ADD proposal, Strategic Brief §3 and §7 (firm-specific proposal)
- Whitepaper, Building Organisations for the Age of AI, Part II §4 Workforce readiness
- Supporting Tools, Audit Evidence Schema, CAB change record and Deployer Manifest schemas v0.1.0
Related research
Related guidance
-
The AI Delivery Factory: Operating ModelThe factory's six connected parts, the control gap it closes, the handover curve that governs what agents may take over, and how to start one without rebuilding your tooling. -
Operate the Agent LifecycleInventory, register, sign, zone, review, suspend, recover and retire agents through a six-stage lifecycle with named human ownership, zone-specific authority and evidence at every transition. -
Change Governance for Agent-Enabled DeliveryRoute agent-speed change by risk without losing the approver: control values that always reach a person, a routing gate that reads the right signals, autonomy earned per change family, a Virtual CAB that prepares a complete dossier, and three bodies with defined escalation. -
The Agent-Speed SDLCA committed artefact chain, governed context, trusted tests and eight SDLC controls that let coding agents work quickly while intent, review, identity and evidence stay connected. -
Close the Policy, Audit and Actuals LoopRun governance as a standing comparison of declared policy against emitted records, route only the exceptions to the second line, and govern the policy packs that drive the comparison. -
Route Regulatory Questions to Obligations and EvidenceA dated, article-level reference that routes AI design questions to the EU AI Act, DORA and its RTS, GDPR and sectoral rules, and turns each obligation into a control, an owner and evidence: change records under RTS 2024/1774 Art 17, the 4 h / 72 h / one-month incident clocks, the CIF hinge and its five artefacts, the three-count Register of Information reconciliation, Art 14(4) oversight controls, the Art 26(5) discharge, the FRIA gate, Art 49 and Art 50, SCHUFA-grade review and supplier controls. -
The Audit Spine and the Evidence RecordHow to capture, join, protect, retain and prove per-action evidence: the AES v0.1.0 record contract, three capture points and one correlation ID, tiered immutable storage, retention and legal hold, replay rehearsal, the route-approval evidence gate, and the Claude-specific ways evidence goes missing. -
Identity, Secrets and Configuration for Agent WorkloadsGive every actor one owned identity, size its authority for the worst case, separate runtime from deployment, federate instead of holding keys, refuse impersonation and silent fallback, govern configuration by class, and audit the estate until flagged identities decline. -
Run the AI Delivery FactoryOperate demand, capacity, the two worker classes, exceptions and evidence as one service: read two leading numbers, keep a handover backlog, gate construction on three conditions, run queues and alerts at agent volume, and count unused products as cost. -
The Enterprise Agent Control PlaneThe firm-owned services that make every agent action identifiable, decidable, approvable and reconstructable: the ownership boundary, six planes and their contracts, the Policy Decision API with its latency budget, the persistence schema, the build sequence and the tests that show it works. -
Schemas, Conformance Packs and the ops ToolchainWhat the versioned Supporting Tools schemas hosted under /aes/v0.1.0/ require, how to validate against them, where the source specification contradicts itself, and what the planned ops CLI, Claude plugins and service conventions define.