Browse the reference ⌄
Operating Guide published

The Authority Process

Generative output is never a record. Label drafts, cite their sources, and turn a draft into an authoritative record only through one owned, eight-step process per record class: validation, business rules, data quality, reconciliation, a named human approval with rationale, immutable audit logging, posting through a write API only the process may call, and a separation-of-duties check with a visible exception register.

Version
0.1.0
Owner
DEIXEI
Last reviewed
Reading time
17 min

For Cto · Ai Architect · Platform Engineer · Data Product Owner · Risk And Assurance · Internal Audit · Legal And Compliance

Sources and details
Source works
Book 1 · Supporting Tools
Source chapters
16
Tool specifications
audit_evidence_schema@0.1.0
Refresh trigger
source change

Full source list ↓ Source index →

An agent can now produce something that looks like a record (a risk classification, a journal entry, a contract memo, a control mapping) in seconds, with sources and a confident tone. Nothing in that artefact tells the next person whether it is a draft or the firm’s position. This page sets the rule and the process: generative output is never an authoritative record, and the only way a draft becomes one is through the Authority Process, one owned instance per record class.

Reading the labels. The draft-versus-record distinction, the eight steps, the signatory model and the sizing figures are an author model from Book 1 Ch 16, built from the author’s design reviews; they are not an industry standard, and the sizing is an experience-based estimate. Recommendation marks this page’s own synthesis, notably the mapping onto the Audit Evidence Schema. Asset Manager X and Bank A are composite firms; supplier 4471082 is invented. Book 1 links individual steps to EU AI Act human oversight, EBA internal-governance expectations and Solvency II actuarial-function validation; the article-level mapping lives on the regulatory map, not here. The source states that regulators do not require an artefact called “the Authority Process”; naming it is what makes the behaviours they require operable in one place.

Why the boundary is needed

Composite, Book 1 Ch 16 §1. A procurement agent summarised a supplier: legal entity, country, beneficial owners, risk class, last KYC review, open findings. Every bullet had a source, but none of the sources was authoritative. The agent had read a due-diligence report, a press archive and a public registry, not the master supplier register. It reported the parent entity, whose risk class was medium; the firm’s contract was with a subsidiary in another jurisdiction, risk class high, KYC overdue by 68 days. A buyer pasted the summary into a contract memo, and an operations director signed it. The head of supplier risk caught it three days later in a quarterly cross-check against master data.

Nothing was fabricated. What failed was that no control asked whether the artefact was a record. The question was missing because most operating models predate agents that produce record-shaped artefacts at speed.

Draft versus record

Book 1 Ch 16 §4.4 gives eleven pairs. The left column is what AI (or anyone drafting) may produce; the right column is what only the firm, through its governance, may produce.

Generative output (draft)Authoritative recordWho may produce the record
ExplanationDecisionThe accountable decision-maker
Suggested actionExecuted actionThe authorised actor, through the governed path
Draft recordPosted recordThe dataset’s write API, called only by the Authority Process
Proposed classificationApplied classificationThe owning function (for example supplier risk for a risk class)
Recommended journal entryBooked journal entryThe controller, through the books-and-records process
Suggested emailSent emailThe accountable sender
Drafted contractSigned contractLegal and the authorised signatories
Generated test planAudited test planThe audit function
Proposed control mappingApproved control mappingThe audit function (see control map)
HypothesisConfirmed factVerification against the authoritative source
PlausibilityTruth(the general form of the other ten)

The source names the producer for three pairs: legal and the authorised signatories for the signed contract, the controller for the booked journal entry, and the audit function for the approved control mapping. The rest of the third column is this page’s reading.

The same rule appears elsewhere in this reference: a generated plan or proposal is not an approved change (BOM and recipes, change governance). The Authority Process governs records; change governance governs changes to systems, configuration and controls. A draft that would alter both needs both.

Label every draft and cite every source

Two rules make the boundary visible to the human who reads the draft (Book 1 Ch 16 §6, composite practice):

  1. Header label. Every generated artefact that resembles a record carries the label DRAFT (generative output) in its header. Recommendation: make the label a property of the output template and of any document the agent writes into, so that copying the content into another document keeps the label, and fail the template’s check if it is removed before step 7.
  2. Inline source citation with authority level. Every field taken from data cites the dataset and its authority level, in the form risk class as of 12 March 2026, source supp_risk_001 (master). Unverified sources are cited as unverified. The authority level comes from dictionary field 8, authoritativeness (master, reference, authoritative-copy, derived, operational, draft, unverified), on the agent-readable data dictionary.

Where the agent may assist and where it must not invent

From the composite supplier-onboarding flow (Book 1 Ch 16 §6), generalised:

The agent mayThe agent must not
Draft the memo by composing fields from master datasets and narrative from unverified sources, each cited at its levelSupply an identifier (for example the LEI) from anywhere but the master; if the master lacks it, flag a gap
Suggest a classification (for example an initial third-party classification) as a recommendation with rationale and citationsSet the classification; only the owning function, through the Authority Process, sets it
Call a separate screening tool (for example sanctions) and attach its structured result (match / no match / manual review)Infer beneficial owners from registry filings or press; if KYC is overdue it flags the status and routes to the KYC team
Collate open findings, citing masters as masters and knowledge-base hits as unverifiedWrite to the system of record (for example contract management); it drafts, the owning team posts

Enforcement point. The agent’s tools are read tools. Dictionary field 17 (retention_and_agent_allowed_list, whose agent allowed list is enumerated and empty by default) lists them per dataset; write tools are never on it. The connector broker enforces the list (MCP and connector broker).

One Authority Process per record class

Properties of each instance (source claim, Book 1 Ch 16 §4.4):

  • One per class of record: supplier risk class, KYC outcome, journal entry, regulatory submission line, control mapping, and so on.
  • Owned, by a named process owner for that class.
  • Named signatories, both human and machine, at every step.
  • Auditable end to end from one record reference.
  • Drafter-neutral. The same process applies whether the draft came from an agent, a junior analyst, a consultant, a vendor or an integration. Agents get no separate process; they are the volume driver that tests whether the existing one holds.

Book 1 reports that two years of design reviews found no need to add a field or a step, and repeated need to enforce the ones already there. Treat that as the author’s experience, not evidence of completeness.

The eight steps

Skipping a step is a control failure (source claim). Each row gives the step’s purpose, its signatories and what halts it. The checks and signatories are the source’s. In the “Halts or routes when” column, steps 1–3 and step 5 follow the source; the entries for steps 4, 6, 7 and 8 are this page’s recommendation. “Evidence” is also this page’s recommendation for what each step should emit so step 6 can assemble the trail.

#StepWhat it checksMachine signatoryHuman signatoryHalts or routes whenEvidence to emit
1ValidationCompares the draft with the authoritative source (dictionary field 8 = master)Validation tool, logging its check against the dictionary entryWrangler of the agent that produced the draftMismatch: passes to step 2 flaggedValidation result, dataset and version read, mismatch list
2Business-rule checksApplies the record class’s rules (for example: no risk-class change without a documented finding; four-eyes on this change)Rules engineRules-engine owner; second reviewer if a four-eyes rule firesMissing finding reference: held; four-eyes rule: queuedRules evaluated, rule version, outcome
3Data-quality checksCompleteness, cross-field consistency, conformance to the dataset schema (dictionary field 14)Data-quality engineData steward of the receiving datasetAny missing required field, inconsistency or schema violation: haltDQ result per rule
4ReconciliationAgainst adjacent records: parent/subsidiary, prior versions, related entitiesReconciliation toolData stewardConflict: halt; related scope: “consider scope” noteReconciliation note, related records
5Human approvalA named human with authority for this record class approves explicitly(none can substitute)Named approver, role specific to the record classNo: exception path (step 8)Approver identity, timestamp, mandatory free-text rationale, references to steps 1–4
6Audit loggingWrites the full trail to an immutable log against the Audit Evidence SchemaAudit-logging serviceAudit-evidence ownerLogging unavailable: do not post (recommendation; see below)The evidence record
7Versioning and postingVersions the record and posts it to the authoritative dataset; bumps dictionary field 15 (version) if the schema changedThe dataset’s write API, which only the Authority Process may callData-product ownerWrite refused: return to step 5 ownerPosted record ID and version, provenance link to the draft
8Separation of duties and control evidenceConfirms the step-5 approver is not the step-1 wrangler; attaches control evidence to the record; runs the exception pathSoD checkControl owner; Internal Audit on reviewSoD conflict: block and re-routeSoD result, exception-register entry if any

Boundary conditions (source claim). The agent can drive steps 1–4, which are mostly automation it is good at. Step 5 is the human checkpoint no agent can substitute for. Steps 6–8 are mostly automated again, with human owners.

Step 5: the approval record

The step-5 record needs, at minimum (source): the approver’s identity, the timestamp, a free-text rationale (mandatory) and references to the results of steps 1–4.

Recommendation: carry it in the AES approval group. The Audit Evidence Schema v0.1.0 already has the fields: approval.required (true for an Authority Process posting), approval.policy_decision_id and approval.policy_version (the record-class rule set that required approval), approval.rationale (the approver’s free text), approval.workflow_id (the Authority Process instance), and approval.approvers[] with upn, role and timestamp (and optional ticket_ref). The schema accepts an empty approvers[] when required is true; reject that in the emitter profile, because an approval with no named approver answers nothing. Store the step 1–4 results as references in the record’s payload; the schema does not define a field for them, so do not invent a top-level field.

Step 6: the trail

Book 1 lists the trail as: draft ID, agent ID, agent wrangler, validation result, business-rule result, DQ result, reconciliation result, approver identity, approver rationale, timestamp. In the composite it answers who acted, what was done, why, when, on what authority and with what evidence. Recommendation: if evidence capture is unavailable, the process must not post; a record whose provenance cannot be written is not yet a record. It is consistent with the principle on audit evidence that evidence is never dropped silently.

Step 7: the write API is the control

The rule that makes the whole process enforceable is architectural. Only the Authority Process holds the credential to call the authoritative dataset’s write API. Agents hold read tools only; humans who would bypass the process hold no direct write path either, except through a named, logged override (step 8). Book 1 Ch 16 §7 makes compliance responsible for translating step 5 into policy-as-code, enforced at runtime by the MCP gateway and the dataset’s write API. Verify by attempting a write with an agent identity and with a human identity outside the process: both must be refused and the refusals must appear in evidence.

Step 8: separation of duties and the exception path

  • SoD check: the approver at step 5 is not the wrangler at step 1. In the composite, the agent’s wrangler is the head of procurement operations and the approver is the head of supplier risk: different people, roles and functions.
  • “What if step 5 says no?” is named here: a standing exception register, a named override authority, and a timed re-review of every exception.
  • Visibility: a quarterly, board-visible report of exception count, type and resolution (Book 1 Ch 16 §8). Exceptions are permitted; they are not free. The second use of an exception should trigger the question the first did not.

Worked example: one finding through the process

Composite (Bank A, Book 1 Ch 16 §6). A buyer asks the agent to raise supplier 4471082’s risk class from medium to high after a sanctions-watchlist hit on a beneficial owner.

StepWhat happened
1Validation reads supp_risk_001 (master): the class is already high, set in 2024. The draft is current state, not a change. Flagged to step 2: no change required; the finding adds to the existing class. Time taken: under a second
2Rules require a named finding for any class change. The 2024 finding exists; the new hit becomes a second finding. Adding a finding under the existing class is permitted. Pass
3The finding record has date, source, beneficial-owner reference, severity and status; schema-conformant. Pass
4Reconciliation finds three related suppliers in the same group and issues a “consider scope” note for cross-group review. Pass with note
5The head of supplier risk receives the whole chain, approves with a one-paragraph rationale, opens the related-supplier review as a separate workstream, and signs
6The full trail is written immutably against the Audit Evidence Schema
7The finding is posted to supp_risk_001; the dataset version goes from 3.21 to 3.22; downstream consumers (contract-memo tooling, procurement dashboard, regulatory reporting feed) refresh through lineage_downstream
8SoD passes (wrangler and approver are different people in different functions). Control evidence is attached; an auditor can reconstruct the chain from one record reference

End to end: 26 minutes of agent and human time. The composite’s pre-process equivalent took three days, lost two emails, relied on an unchecked spreadsheet and drew a supervisory comment on incomplete provenance. The author’s point is that codified steps are faster than steps negotiated each time.

Roll out and size it

First iteration (Book 1 Ch 16 §7)

The process depends on the dictionary: step 1 needs to know which source is master. Roll the two out together.

  1. Pick three high-stakes datasets where an inaccurate agent read has the largest regulatory or financial consequence: typically a master (customer, supplier, counterparty, holdings or policy), the feed for the largest regulatory submission, and the master for the process being automated most aggressively. Three, no more.
  2. Populate the 17-field dictionary on those three. The owning domain populates; the central data function reviews; the agent platform team sanity-checks the agent allowed list; the Chief Data Officer signs. Expect resistance on field 8 (authoritativeness) and field 11 (accuracy_sla). Field details are on data and API integration.
  3. Wire one MCP server and one API to one of the three datasets, both taking schema and tool descriptions from the dictionary entry.
  4. Run the Authority Process on one real generated artefact end to end with the named signatories: a risk-class change, a KYC re-review outcome or a submission line. Time it and log every step. Expect the first run to expose a missing rules engine, an unclear approver or an audit log missing evidence fields. Fix the gaps before scaling.

Target: three populated dictionary entries, one MCP server, one Authority Process run, by the end of week six. The rest of the dictionary follows in two further iterations through the year.

Sizing (author’s estimates)

50,000-employee FS firm1,000-employee specialist firm
Steady-state dictionary2,000–8,000 dataset entries, 30–60 domains100–400 entries, 5–12 domains
MCP-published for agents200–80030–80
First iteration8–12 weeks; team of six (data architect, two data-product engineers, agent platform engineer, governance lead, programme manager) plus owning domains4–6 weeks; team of three
Recurring cost3–5 FTE central enablement, plus 0.1 FTE per data product in the domain1–2 FTE
Authority Process ownersUsually already in post (heads of supplier risk, KYC, financial crime, controllership; investment-data and actuarial-data owners). Their work is reshaped, not addedSame

The smaller firm’s temptation is to skip the dictionary because “everyone knows where the master data is”. That holds until the second and third agents start reading.

Who owns what

RoleDeliverablesEvidence they sign
Process owner per record classThe instance: rules, approver role, write-API bindingProcess definition, versioned
Head of compliance(1) Per-dataset mapping of dictionary fields to the obligations they discharge; (2) policy-as-code for step 5, enforced by the MCP gateway and the write API; (3) per-domain attestation by each data-product owner that the fields are current, authoritativeness is honest, and the allowed list is an enumerated exceptionQuarterly dictionary attestation to the operational-risk and model-risk committees: master datasets populated, accuracy SLAs measured, Authority Process exercised on a tested sample
Head of internal audit(1) A query template that returns the full chain for any posted record from one reference; (2) a testability matrix sampling allowed-list enforcement, honest field 8 values on masters, and exceptions in the register with timed re-review; (3) a half-yearly test of the draft/record boundary: sample posted records and confirm a named step-5 approver who is not the wranglerHalf-yearly internal-audit report on the agent-data plane to the audit committee
Agent wranglerStep 1 signatory; keeps the agent’s tools read-onlyWrangler attestation (accountability)
Data-product ownerStep 7 signatory; owns the write APIDataset version history

The compliance and internal-audit rows are from Book 1 Ch 16 §7. The process-owner, wrangler and data-product-owner rows are this page’s recommendation, built from the signatories in §5.2.

Align the dictionary with the model usage registry

The source flags a fifth failure next door: the dictionary’s field 4 (data_classification) and the model usage registry’s field 7 (data_classes_touched, on model governance) must agree, or an agent invokes a model with data classes the model is not approved for. Run the cross-reference query at registration time. Data classes themselves are on data classes and lanes.

Failure modes and recovery

Failure (Book 1 Ch 16 §8)SignalRecovery
Generative output treated as recordDrafts posted because posting is automated; agent confidence used as a quality gate; the first wrong posted record (journal entry, customer communication, applied class) exposes the gap after many have been postedReintroduce the process for the affected class; reconcile the affected period retroactively; forbid agent writes except through the process, enforced at field 17 and the write API
Process bypassed under time pressureQuarter-end or deadline exceptions recur; within two years the exception is the normStanding exception register, named exception authority, timed re-review, quarterly board-visible exception report
Agent reads the data lake without a dictionaryAgent reaches operational exhaust, prior agent outputs and stale snapshots with nothing marking which is whichRevoke broad read; populate the dictionary on needed datasets; restrict through the MCP layer; require citation of the dictionary entry for every source
MCP servers but no glossary anchorsField 9 null on most entries; one term means different things in two domainsPopulate the glossary first; anchor every entry; review quarterly
Dictionary not aligned with the usage registryData classes on the usage row disagree with the dataset classificationCross-reference query at registration
Label stripped in copy (recommendation)A draft pasted into another document loses its DRAFT headerLabel carried by the template; posting refused while a draft label is present without a step-5 approval

Acceptance checks

  • Every record class that agents draft for has a named Authority Process owner, a defined rule set and a named step-5 approver role.
  • An agent identity, and a human identity outside the process, are both refused when they call the write API directly; the refusals are in evidence.
  • Every sampled posted record has an AES record with approval.required: true, a non-empty approvers[] and a rationale, and links to step 1–4 results.
  • In a half-yearly sample, no step-5 approver is also the step-1 wrangler.
  • Every sampled generated artefact carries the DRAFT (generative output) label and cites sources with their authority level.
  • The exception register shows owner, authority, re-review date and resolution for every exception, and the count is reported quarterly.
  • One record reference is enough for an auditor to reconstruct the chain, without rebuilding it.

Provenance and refresh

Synthesised from Book 1 Chapter 16 (§§1, 4.4, 5.2, 6–8) and the Audit Evidence Schema v0.1.0 approval group. The draft/record pairs, the eight steps, the signatory model, the rollout and the sizing are the author’s model and estimates. The AES field mapping, the fail-closed logging rule and the label-persistence rule are this page’s recommendations. Regulatory linkage is on the regulatory map.

Review trigger: a change to Book 1 Ch 16, to the AES approval group, or to the dictionary schema; an incident in which a draft was treated as a record; or an exception count that rises two quarters running.

Source material

  • Book 1 (Building Organizations for the Age of AI), Chapter 16, Data as the Enterprise Multiplier (§1 composite opening, supplier 4471082; §4.4 generative output is not an authoritative record; §5.2 the Authority Process; §6 worked example, supplier onboarding; §7 Monday morning, sizing and role deliverables; §8 anti-patterns)
  • Supporting Tools, Audit Evidence Schema v0.1.0 (the approval group)

← All AI Delivery Factory guidance

On this page

  1. Why the boundary is needed
  2. Draft versus record
    1. Label every draft and cite every source
    2. Where the agent may assist and where it must not invent
  3. One Authority Process per record class
  4. The eight steps
    1. Step 5: the approval record
    2. Step 6: the trail
    3. Step 7: the write API is the control
    4. Step 8: separation of duties and the exception path
  5. Worked example: one finding through the process
  6. Roll out and size it
    1. First iteration (Book 1 Ch 16 §7)
    2. Sizing (author’s estimates)
    3. Who owns what
  7. Align the dictionary with the model usage registry
  8. Failure modes and recovery
  9. Acceptance checks
  10. Provenance and refresh

All pages in Govern and prove →