Browse the reference ⌄
Operating Guide published

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
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

Full source list ↓ Source index →

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

QuestionAnswer the model givesWhere it is set
Who is accountable for a product?Four named accountabilities (business, technical, operational, control), never blankFour accountabilities
Who owns a change an agent wrote?The person who dispatched it and merged it; the owner field never names the agentThe 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 rightsThe dispatch-and-gate gap
Who owns an agent that never opens a change?Its named owner on the registry; no owner means the agent stopsEvery agent has a findable owner
Which seats make it a factory rather than a pilot?Seven named seats, tested by commits, not interviewsSeven names
Who signs for the framework at the top?A management-body member, with second-line countersignatureManagement-body signatory
Who decides each recurring decision?One Accountable per row of a 28-decision Build/Run RACIThe RACI
Where does engineering authority stop?First line federates and builds; second line adjudicates and owns the boundariesLines 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 holds two classes of worker, human and agent; agent output is owned by a named wrangler.

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:

RecordWhat it answersHeld byTypical evidence
Provenance (attribution)Which agent, under which identity and version, produced this artefact, and from which instructionThe factory: workload identity, change record, evidence pipelineAgent workload identity on the commit and pull request; executing_agent and initiator in the Audit Evidence Schema
AccountabilityWhich named person stands behind it and can explain it in a meetingThe product teamNamed 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):

  1. Which team owns it?
  2. Which person signs for it?
  3. If an agent wrote it, which named person stands behind that agent?
  4. 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):

AccountabilityQuestion it answersAgent failure it catchesUsually held by
BusinessWhy the product exists and whom it servesA plausible feature nobody neededProduct lead / business owner
TechnicalWhether the design will hold and can be maintained within enterprise boundariesAn integration wired in a way that will not scaleLead engineer or technical owner
OperationalWhether it stays up, is supported and kept currentA change with no runbook, alert or on-call answerService owner / support rota
ControlWhich controls apply, and whether evidence shows they operatedAn agent that quietly steps round a control; the failure the other three cannot see and a supervisor finds firstA 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:

RoleJob in an agent team
Agent wranglerThe named human to whom an agent’s output is attached; owns its bounded-agency envelope
Business analystManages how business expectations change once people can use working slices within days
Adoption leadReads 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:

  1. confirm they read the change against its plan, not only against itself;
  2. state where the tests came from, and say so explicitly if they came only from the authoring agent;
  3. 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:

CaptureWhere 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_versionEach 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_upnSee the schema gap below
Named owner of the agent itselfRegistry 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 questionsReview templateCorrect? 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:

  1. For gate-merged changes, record the agent’s named owner as accountable owner, and record the requester separately as requester.
  2. 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.
  3. 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.
  4. 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.

RuleDetailSource
Name the owner before the agent is builtOwners named after production are how the floating-agent incident happensBook 1 Ch 12 §7
No owner, no runningIf no one will accept ownership, suspend or decommission. Hard pushback from the senior person in the function is a signal the agent should not existBook 1 Ch 12 §7; Book 09 Ch 5
No dispatch without a wranglerRefuse to dispatch an agent that has no attached wrangler; make it a precondition the factory enforcesBook 2 Ch 7 §7–§8
Owner sits in the business, not platform engineeringAt 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 namedBook 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 wranglerBook 3 Ch 13 §4.1
Suspend authority is real and testedSuspension hotline tested quarterly for every production envelope; exercise suspend at the first periodic reviewBook 3 Ch 13 OD-1; Book 1 Ch 12 §7
Route to the role, not the personRouting rules name “whoever owns transforms”, not a specific person, so the work survives leave and turnoverBook 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:

SourceNumberWhat it limits
Book 1 Ch 1 §7.1No 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 §7About 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.4Breaching the three-CIF ceiling is named as the typical risk when the agent estate outgrows operations capacityAdvice: 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:

TierOwnsBoundary
ChampionNothing in the control sense; a volunteer who multiplies adoptionCapped time; refers security and data-handling questions to administrators rather than improvising
WranglerOne agent’s behaviour and envelopeNamed, certified, holds suspend authority
Product ownerThe workflow and its risk acceptanceRe-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 agentChange ships that no one stands behind; in a regulated firm that is a finding
Head of the factory / person accountable for delivery end to endPriority goes to whoever shouts loudest; intake becomes a form; the roadmap discussion stops
Factory architect / architect who owns the standard designs and recipesThe 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 productThe factory optimises throughput and builds what was asked for, unused
Business analyst who specifies each productAgents build plausible but wrong products from thin intent faster than anyone can catch them
Agent-fleet operatorAutonomy is granted on anecdote; runaway loops burn unwatched
Operational owner of each product in productionThe 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.md before 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).

  1. Name, in writing, the management-body member who signs for the ICT risk framework covering AI agents, and the second-line owner who countersigns.
  2. 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.
  3. 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

LineRoles (abbreviation)
ExecutiveExecutive Sponsor (ES): holds the management-body signature
1st lineAI 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 lineHead 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-lineVirtual CAB Chair (VCC): chairs a body spanning first-line owners and second-line challengers
3rd lineInternal Audit (IA): receives the sign-off pack on copy, not for signature
OperationalSOC: 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)

#DecisionARC (summary)
1Deployment route choiceESAPO, APPO, PROCMR, CISO, CDO, DPO, L&C
2Identity integration baselineAPOAPPOCISO
3LLM gateway build vs buyAPOAPPOCISO, L&C, PROC
4MCP server intake, tier R0APPOAPOAW
5MCP server intake, tier R1APPOAPO, AWBO, CISO, CDO
6MCP server intake, tier R2VCCAPO, APPO, AWBO, MR, CISO, CDO, DPO, L&C, PROC
7Claude Code managed settings.json baselineAPPOAPOCISO
8API agent envelope, tier 0–1AWAPO, APPOBO
9API agent envelope, tier 2VCCAPO, APPO, AWBO, MR, CISO, CDO, DPO
10API agent envelope, tier 3ESAPO, APPO, AWBO, MR, CISO, CDO, DPO, L&C, VCC
11Data classification framework refreshCDODPOAPO, MR, CISO, L&C
12Audit Evidence Schema implementationCISOAPO, APPOMR, CDO
13Landing-zone sign-offESAPO, MR, CISO, CDO, DPOL&C
14Wrangler assignmentBOAWAPO
15Risk-tier classification of a new use caseMRBOAPO, APPO, AW, CISO, DPO, L&C
16Prohibited-use list maintenanceESL&CAPO, MR, CISO, DPO
17Agent Control Board: new agent to productionVCCBO, AWAPO, APPO, MR, CISO, CDO, DPO, L&C
18Virtual CAB: tier 2 changeVCCAWAPO, APPO, BO, MR, CISO, CDO
19Model upgrade, minor within a familyAPPOAPOAW, MR, VCC
20Model upgrade, across familiesVCCAPO, APPOBO, AW, MR, CISO, CDO
21Incident classification, major ICT-relatedL&CAPO, CISO, SOCES, BO, AW, MR, DPO
22Incident communication: supervisor notificationESL&CDPO
23Cost budget exceptionAPPOBOAPO, AW, PROC
24Red-team programme planningCISOSOCAPO, APPO, MR, IA
25TLPT scope inclusion of AI agentsESCISOAPO, MR, L&C, IA
26Board reporting cadence and contentESL&CAPO, MR, CISO, CDO, DPO, IA
27Vendor concentration assessmentPROC(none named)ES, APO, MR, L&C
28Exit rehearsal: supplier suspension drillPROCAPO, APPO, SOCCISO, 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):

ControlCadenceOwner
Sample three rows and check every name is current against the directoryMonthly (4th Friday in Book 3’s composite)AI Platform Product Owner
Every named role resolves to an active directory groupEach quarterly reviewAI Platform Product Owner
Version stamp on every Agent Control Board pack; the version in force on the action date is the one cited in evidenceEvery packAI Platform Product Owner
Review and re-sign the matrix; close prior-year exceptions; record new ones with named remediation ownersAnnually (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 committeeContinuousAI 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):

LayerWhoWhat they may do
First line federatesProduct teams and the platformSet their own practice inside declared boundaries; depart from a guideline on purpose and answer for it (see policy, audit and actuals)
Second line adjudicatesRisk, compliance, the CISO as policy ownerOwn the boundaries, read the evidence, rule on exceptions; answerable to the supervisor, not to the domains
Non-negotiable floorRegulatory obligationsNot 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 functionStays 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 centreCISO: 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):

ArchetypeOwnsIndicative share of IT headcount (Book 1)
Business-facing product squadsUse cases end to end; every agent has a sponsoring squad and named wrangler; the adoption lead sits here60–70%
Platform and enablementLanding zones, identity, network zoning, API management, model inventory, AI gateway, policy engine, evidence pipeline; Skills Library and ADR/GIP repositories15–20%
Control and assuranceEvidence engineering and regulatory mapping (see source difference below)8–12%
AI-agent operationsAgent 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 collapseSource
A few hundred people, around seventy engineersSeven seats shared among three or four people, declared; refuse builder-and-tester of controls in one personBook 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 agentsBook 2 Ch 7 §7; Book 1 Ch 5 §7.2; Book 1 App G §G.4
Global, 50,000 employeesEach framework altitude and platform pillar has a dedicated team and accountable director; wrangler naming runs as a four-week programmeBook 1 Ch 5 §7.1; Book 1 Ch 12 §7
A few thousand, technology already under one headOrganisational work is nearly free; borrow the operating model and size controls to riskBook 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 ownsShared platform team ownsJoint hand-off
Product purpose, user outcomes, domain rules and service-level expectationsSupported runtime, identity and policy mechanisms, shared model/tool gateways, logging and evidence servicesAgree supported patterns, service boundaries, dependency and escalation contacts before production.
Agent configuration and behaviour within approved boundaries; named wranglerTenant, network, identity, secrets, platform guardrails, platform availability and technical operationsBind product identity and scopes to approved platform controls; document who can change each boundary.
Product tests, evaluations, release evidence, service runbooks and recovery planReusable pipeline, policy enforcement, shared control evidence and platform incident responseLink product artefact versions to platform policy/configuration and deployment records.
Product-level incident triage, customer impact and remediationPlatform-level detection, containment and restoration for shared componentsAgree 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 modeHow you recognise itRecovery
Accountability follows authorshipThe 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 mechanismOwner reads “auto-approved”, a service account or a team mailboxMonthly ten-change sample; apply the gate-merge proposal above
Agent with no wranglerAn agent identity in commit history with no human accountability line; an agent on logs but not on the registerRefuse dispatch without an attached wrangler; suspend unowned agents; register owners for non-change agents
Engineer-as-wranglerThe wrangler identity resolves to platform engineering; the suspension hotline rings someone who can fix the agent but not explain the business impactRegistry refuses an envelope whose wrangler resolves to platform engineering
Wrangler in name onlylast_reviewed_at behind cadence; quarterly attestation signed in minutes with no working paperDaily review as a signed registry entry, with a SOC rule alerting on its absence (Book 3 Ch 13 §7)
Product team without operational accountabilityA post-incident review cannot name the product team’s contributionWrangler 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 rowCount the A’s; more than oneAI Steering Committee picks one; the other becomes Consulted with sign-off
Platform made accountable for product outcomesIncident reviews route product decisions to platformKeep the four accountabilities inside the product team
Security and risk as a late gateReview latency climbs with agent throughputBring control into specifying, so the recipe constrains the agent and the gate confirms rather than discovers
Skill shift announced but not resourcedBest engineers leave; review quality erodes under volumeStaff and time specifying, reviewing and wrangling as the real work
Champion made wrangler for many agentsOne volunteer appears as wrangler on many envelopesEnforce the three tiers; apply the span and CIF load ceiling
Hero routingAll 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 departmentIntent writers and agent operators in different organisationsRejoin them in one product team; centralise only agent capacity
Wide consolidation boundaryThe department signs risk opinions on its own workRedraw 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

← All AI Delivery Factory guidance

On this page

  1. The model in one table
  2. Provenance is not accountability
    1. The four-question test for any shipped change
  3. Four accountabilities for every product
  4. Who owns an agent’s change
  5. The gap when a workflow dispatches and a gate merges
  6. Every agent has a findable owner
  7. Seven names and the blank test
  8. The management-body signatory
  9. The Build/Run RACI (28 decisions)
    1. Roles and lines of defence
    2. Conventions
    3. The matrix (Accountable and Responsible; Consulted in brief)
    4. Operate the RACI as a runtime asset
  10. First line federates, second line adjudicates
    1. The consolidation boundary: what moves and what stays
  11. Team archetypes, pods and sizing
  12. Make platform and product responsibilities meet cleanly
  13. Failure modes and recovery
  14. Acceptance checks
  15. Source and status

All pages in Govern and prove →