Browse the reference ⌄
Decision Guide published

Choose the Shape of an AI Product

A least-agency decision sequence for choosing a product design: agency classes and their trade-offs, the eight questions, evidence for every step up, the consequence matrix that caps action scope, the cut-set review for agents, the other selection dimensions, and the design record.

Version
0.2.0
Owner
DEIXEI
Last reviewed
Reading time
23 min

For Cto · Ai Architect · Product Leader · Platform Engineer · Risk And Assurance · Internal Audit

Sources and details
Section
Design
Source works
Book 2 · Book 1 · Research Series
Source chapters
1, 22
Source appendices
02:C
Refresh trigger
source change

Full source list ↓ Source index →

Use this guide at product intake or architecture review, after a candidate has a bet card admitted through the discovery portfolio. Every request arrives as somebody’s picture; it should leave as a governed choice among named shapes. The outputs are:

  1. An agency class, chosen by the least-agency rule, with every lower class rejected for a written reason.
  2. A ceiling on action scope, set per decision by the consequence matrix, independent of the class.
  3. For class 3 and 4 designs, a cut-set answer showing no single control failure lets the agent act outside its mandate.
  4. The classification line and a ten-field design record (an ADR) committed before the first branch.

Status of the model. The agency classes, decision sequence, escalation criteria, trade-off matrix, consequence matrix and design record are the author’s design proposal (Book 2 Ch 22; Research Papers 1 and 2), written for EU, UK and Swiss banks, insurers and asset managers. The underlying principle, that complexity should rise only when needed, is consensus guidance from Anthropic, Microsoft and Google Cloud as cited in those sources. Asset Manager X is the books’ composite institution. Where Book 2 and the Research Series differ, this page says which it follows.

Agency classes and the least-agency rule: choose the lowest class that meets the need; in a workflow code decides, in an agent the model does.

At a glance: choose the lowest agency class that meets the need, and climb only on evidence. The detailed diagram is under Keep two scales separate. Source: The AI Delivery Factory, Chapter 22, Figure 22.2.

Keep two scales separate

An agency class is a design-time property: who decides the next step. It is fixed when the design is chosen. Action scope (in Book 2’s terms, the rung on the autonomy ladder) is a run-time permission: what the design may do in production — read-only, draft for a human to send, act with approval, act autonomously within a defined envelope. It is earned on evidence. The two are independent: a class 3 design can operate at the advisory rung, and Research Paper 2’s research crew is class 4 and read-only (§2.2). The vocabulary mapping across books is on the bounded-agent pattern.

Agency classShapeWho decides the next step?
0 — single callOne model call, without enterprise factsCode
1 — grounded answerRetrieval plus one model callCode
2 — workflowA fixed sequence that may include model callsCode
3 — bounded agentOne agent in a loop inside a bounded-agency envelopeThe model, within its envelope
4 — multi-agentSeveral agents with separate owners and identitiesModels and code
Agency classes distinguish fixed code-selected steps from model-selected steps; every move to higher agency needs evidence.

Agency class is a design-time choice; the autonomy ladder is earned at run time. Source: The AI Delivery Factory, Chapter 22, Figure 22.2.

The control-flow test. The only conceptual boundary is between classes 2 and 3: in a workflow code selects the next step; in an agent the model does. Hold that line whatever a vendor diagram calls the pattern. A sequential or parallel flow whose order is fixed in code is a workflow, however many model calls or “agents” sit inside it (Book 2 Ch 22 §4.4).

Class 4 is defined by ownership. Research Paper 2 (§2.2) and Research Paper 1 (§7.3) add a nuance this page follows: a design is class 4 when it contains several agents with separate owners, identities, security boundaries or release cycles. If code fixes their sequence, it keeps most of a workflow’s predictability and test effort, but it still carries class 4’s identity controls — agent registry, authorisation between agents, a kill switch per agent — because those follow the identities, not the control flow.

Know what each class costs before committing

Research Paper 1 (§7.3) gives the qualitative trade-offs, with the control additions each class brings. The ratings are the author’s assessment.

ClassPredictabilityLatencyCost per taskTest effortAttack surfaceTypical additions to the control bundle
0 Single callHighLowLowLowLowGateway, output filters
1 Grounded answerHighLow–mediumLowMediumMedium (indirect injection through documents)Permission-aware retrieval, citation checks
2 WorkflowHighMediumMediumMediumMediumStep validation, human checkpoints where needed
3 Bounded agentMediumMedium–highMedium–highHighHighTool policy, agent identity, budgets, trajectory evaluation
4 Multi-agentLow–mediumHighHighVery highVery highAgent registry, authorisation between agents, replay testing, kill switch

Read the test-effort column twice. Between class 2 and class 3 the unit under test changes from an output to a trajectory. A firm that has only evaluated outputs cannot yet say whether an agent did the right thing for the right reason; budget trajectory evaluation (evaluation and resilience) before approving the first class 3 design.

Ask the eight questions in order

The default at every step is the least agentic, least bespoke option that meets the need. Questions 1 to 5 produce the agency class; 6 to 8 produce reuse, controls and hosting. For an ordinary request the sequence takes about forty minutes and should be run live with the sponsor in the room; its output is a draft design record with the alternatives still visible (Book 2 Ch 22 §5.1).

#QuestionOutcome
1Is AI needed at all? Would rules, a query or conventional analytics do?If yes, build conventional software and stop. This question ends more requests than the other seven together
2Prediction or generation?Predicting a number or class from structured data (default probability, fraud score, lapse rate) is classical machine learning with its own model-risk regime; continue only for generation
3Does it need enterprise facts?No enterprise facts and one call suffices → class 0. Enterprise facts needed, or more than one step → question 4
4Are the steps known in advance?One step over retrieved facts → class 1. Several known steps → class 2. Not known → question 5
5Is it one coherent responsibility?One responsibility, one owner, one tool set → class 3. Several responsibilities needing separate owners, identities, security boundaries or release cycles → class 4
6Which catalogue assets cover each anatomy tier?Go tier by tier through the application anatomy; every covered tier is one you do not design, test or separately control
7Which policy pack applies?Inherited by scope from risk tier, data class, agency class and action scope (see the note below)
8Which hosting route and model class do data class and cost allow?Vendor API, private tenancy or controlled infrastructure; model class from the firm’s own evaluations

Multi-step work on user-supplied content (source difference). Book 2 Ch 22 §5.1 sends every “no enterprise facts” answer to class 0. Research Paper 1 (§7.1) repairs this: a task with no enterprise facts but several steps — draft, check against a style rule, reformat — continues to question 4 and lands at class 2, and one whose steps cannot be known continues to question 5. Without the repair, a workflow or agent over user-supplied content has no path through the sequence. This page follows Research Paper 1.

Question 7 (source difference). Book 2 keys the policy pack on risk tier, agency class and data class; Research Paper 1 keys the control bundle on risk tier, action scope and data class. This page treats them as layers: the agency class brings the structural controls in the trade-off table’s last column, the action scope brings the per-rung controls (approval points, reversibility), and the risk tier and data class select the package around both. Pre-approve a policy pack for every recurring combination with the second line, so question 7 is inheritance rather than negotiation.

Question 8. Book 2 calls the three options hosting routes; Research Papers 1 and 9 call them processing lanes. They are the same three choices. Lane definitions and the per-deployment assignment rule are on data classes and lanes. A hosting route is not a delivery lane: the delivery lane decides who builds the thing, the route decides where it runs.

When the request is an existing procedure

Book 1 (Ch 1 §4.5) describes an approach for institutions formalising procedures for the first time (its example is Gulf banks with less legacy process debt): map each operational SOP directly into a decision model rather than a document, with five elements — task, inputs, decision criteria, output, and the explicit point where a human stays in the loop. Book 1’s reading is that wherever the criteria are deterministic and the data governed, an AI agent can act, and wherever judgement, exception or regulatory accountability is required, the human point is marked before any code is written. Book 1’s precondition: internal staff, not an integrator, own and maintain the decision models.

This page’s recommendation is to feed the decision model into questions 1, 4 and the consequence check rather than straight into an agent: deterministic criteria over governed data are usually a rules or workflow candidate under the least-agency rule (class 3 only where the steps cannot be fixed), and the marked human point is where the consequence matrix is applied. Book 1 frames the method for Gulf institutions; applying it to any firm formalising a procedure is the page’s extension.

Choose between neighbouring archetypes

Most real decisions are between two adjacent shapes. Research Paper 2 (§6.2) gives the rule: take the simpler one unless a stated condition holds — for example, a grounded assistant rather than a research crew unless questions routinely need planning across many sources and a synthesised report; a document pipeline rather than a bounded agent unless documents vary so much the steps cannot be fixed. When the room cannot agree, ship the simpler shape and let its evaluation results show whether the harder one was needed. The archetype cards are in Research Paper 2 and the recipe families on the recipe catalogue.

Bring evidence for every step up

Choose the lowest agency class that meets the need. A step up is allowed, but the design record must carry the evidence (Book 2 Ch 22 §5.2; Research Paper 1 §7.2).

Step upEscalate only ifEvidence the design record must carry
0 → 1Answers depend on internal or current factsExamples where the base model gets it wrong
1 → 2The task needs several distinct steps, tools or validationsThe step list, and the failure modes of the single call
2 → 3The next step cannot be predicted from the input; the paths are too many to codePath analysis showing combinatorial branching; the cut-set answer
3 → 4One agent’s tool set or instructions become self-conflicting, or domains need separate ownership, security boundaries or release cyclesEvaluation results showing single-agent degradation; the cut-set answer
Prompting → fine-tuningPrompting and retrieval have plateaued on a stable task, or cost and latency demand a smaller modelThe evaluation curve, a data-governance plan, a re-tuning plan
Read-only → actingThe business case needs execution, and reversibility or approval is designed inAction inventory, reversibility analysis, approval points, named wrangler

What is not evidence for 3 → 4: that the process has four steps, that four teams are involved, or that a vendor diagram has four circles. Several agents are justified by ownership boundaries and demonstrated single-agent degradation, not by the shape of the org chart.

Source difference. The cut-set answer in rows 2 → 3 and 3 → 4 is Book 2’s addition; Research Paper 1’s table does not include it. This page follows Book 2.

Defer with a trigger, never “no”. Every deferral of a higher class names the trigger that reopens it, for example “class 3 deferred; revisit when the evaluation harness holds a quarter of graded peer-comparison outputs” (Book 2 Ch 22 §6). Read the deferrals as a portfolio: if nothing has ever crossed the 2 → 3 line, the criteria are being deployed as a veto, not applied.

Cap action scope by consequence

Agency class describes mechanics. It does not say whether the firm should let the system act. That is set per decision, on two axes: how much harm a wrong decision causes, and how complex the decision is. The principle — human involvement follows consequence, not use-case category — is taken by both sources from McKinsey’s 2026 public-sector work; the matrix below is Research Paper 1’s proposal for applying it (§7.6). Sign-off by category (“all HR use cases need sign-off, operations do not”) is over- and under-inclusive from its first day.

Consequence of a wrong decision ↓ / Decision complexity →LowMediumHigh
LowAI runs itAI runs it; a human reviews samplesAI proposes; a human has the final say
MediumAI recommends; a human approvesAI recommends; a human approvesA human decides; AI assists
HighA human decides; AI assistsA human decides; AI assistsA human decides; AI assists

Default for regulated firms. Both sources place in the high-consequence row, by default, every decision that has a legal or similarly significant effect on a person, a client or the firm’s regulatory standing: a credit decision, a claims denial, a suitability assessment, a regulatory filing. The legal basis and article references for human intervention are on the regulatory map.

How the cap is applied.

  1. List the decisions the product takes or contributes to, not the use case as a whole. One product often contains decisions in different cells.
  2. Place each decision in a cell and record the reason in the design record (field 7, residual risks).
  3. Translate the cell into a ceiling on action scope. This page’s mapping (a synthesis, not a source table):
Matrix cellHighest action scopeOversight mode (Research Paper 1 §7.4)
AI runs itAct autonomously within the envelopeAfter the fact
AI runs it; a human reviews samplesAct autonomously within the envelopeAfter the fact, sampled
AI proposes / recommends; a human has the final say / approvesAct with approvalIn the loop
A human decides; AI assistsRead-only or draft (advisory)In the loop; the human owns the decision
  1. The consequence ceiling is the maximum; the escalation criteria above decide whether the design may approach it, and the autonomy ladder decides when the rung is earned. A high-consequence decision caps action scope whatever the agency class.
  2. Apply the stricter of the consequence ceiling and the use-case tier’s autonomy_ceiling from risk tiers (where, for example, T2 and T3 deny execute_autonomously). The matrix works per decision; the tier works per use case. Neither loosens the other.

Source difference. Book 2 (Ch 22 §5.3) states the two axes and says the result caps “the rung”; it does not print the matrix. Research Paper 1 prints the matrix and says it caps “action scope”. With the ladder-to-scope mapping, these are the same cap. This page uses the Research Paper 1 matrix.

Run the cut-set review for class 3 and 4

For every class 3 or class 4 design, the design record must answer one question: is any single control failure sufficient for the top event — the agent acts outside its mandate? The idea is borrowed from fault-tree analysis: a minimal cut set is the smallest combination of failures that produces the top event, and a cut set of one is a single point of failure. No probabilities, no gate arithmetic, no new artefact (Book 2 Ch 22 §5.2).

Method (about ten minutes if the design record is honest).

  1. Write the top event concretely for this agent: what “outside its mandate” means (an issuer it may not touch, a write it may not make, a recipient it may not reach).
  2. List every control between the agent and that event.
  3. Tag each control with its part of the bounded-agency envelope and its control-plane location:
Control typeEnvelope partControl plane (product side)
Instruction or system-prompt ruleMandatePolicy
Tool broker refusal, scoped identity, data entitlementMeansIdentity and policy
Retained trajectories that reconstruct what was askedMemoryEvidence
Checkpoint, alert, sampled reviewMonitoringObservability and evidence

Book 2 names the plane for the instruction (policy), the broker refusal (identity and policy) and the checkpoint (observability and evidence); placing retained trajectories on the evidence plane is this page’s reading.

  1. Test each control alone and in pairs. Ask: if only this fails, does the top event occur? Then: which pairs suffice?
  2. Record the result. Any single-event cut set is a finding, not a note. Separately record controls that remove detection but not prevention.
  3. Fix with a control that fails differently, not a better-worded instruction.

Independence heuristic. No top event should be reachable by the failure of controls drawn from one part of the envelope. Controls that share a plane and a tier are rarely as independent as their designers believe. A guardrail on the same tier as the instruction it protects is the same event.

Composite worked answer (Book 2 Ch 22 §5.2, Asset Manager X’s deferred peer-comparison agent). Top event: the agent pulls filings for, or writes about, an issuer outside its mandate. Candidates: (a) the guardrail is bypassed by text inside a retrieved filing; (b) its service identity was over-granted; (c) the human checkpoint on each quarter’s first table is skipped.

FailureSufficient alone?Why
(a) Guardrail bypassNoProvided the tool broker enforces the mandate’s issuer list regardless of what the model asks
(b) Over-grantNoNothing induces the agent to ask
(c) Skipped checkpointNoIt removes detection, not prevention; record as a separate finding
(a) + (b)YesThe model is talked into the request and nothing downstream refuses it

The answer that fails is the most common: the only thing between the agent and an out-of-mandate action is an instruction in its prompt. The fix is an independent control: the connector broker refuses the call because the issuer list is an authorisation property of its configuration, not a sentence the model can be argued out of.

Owner. The pattern arbiter (part of the factory architect’s job, Book 2 Ch 24) runs it in the same review that reads the classification line. No new forum or role.

Regulatory framing. Book 2 treats a single-event cut set in a product’s control architecture as the same class of finding as DORA’s duty to identify material single points of failure in ICT systems. The book labels this its own extension of that duty, not a separate obligation; for a product supporting a critical or important function, it is the reading to have on file. Article references are on the regulatory map.

Week three exercise (Ch 22 §7). Take the class 3 agent you are least worried about, write its top event, list the controls and ask whether any one failing alone is enough. A yes is the second control to build this quarter.

Settle the other selection dimensions

Agency class is one choice among several. Research Paper 1 (§7.4) lists the rest and what to choose by.

DimensionOptionsChoose by
Model classFrontier · mid-tier · small or open-weight · specialisedTask difficulty shown by the firm’s own evaluations, latency budget, cost, hosting constraint. Published rankings date within months
Processing lane (hosting route)Vendor API · private cloud tenancy · controlled infrastructureData class, outsourcing rules, exit strategy (data classes and lanes)
Knowledge patternContext stuffing · RAG · advanced RAG · graph grounding · semantic layer · agentic RAGShape of the data (text, tables, relations), variety of queries, freshness
Interaction modeChat · embedded · batch · event-driven · agent-to-agentWhere the user or process already works
Human oversightIn the loop (approves each action) · on the loop (monitors, intervenes) · after the fact (reviews samples)Action scope, reversibility, risk tier, and the consequence matrix above
Build or buyPackaged assistant · built on the platform · customDifferentiation, data access, control needs, vendor concentration (vendor concentration and exit)
FrameworkDirect SDK · workflow engine · agent frameworkTeam skills and portability. A framework must not hide prompts and responses

Pattern families. Each capability is built from one of eight families (Book 2 Ch 22 §4.2; Appendix C): model interaction, knowledge and grounding, model adaptation, workflow, agent, multi-agent, integration and interoperability, and trust, governance and operations. Record the named pattern per anatomy tier in the design record. Integration and interoperability is both an anatomy tier (where a component lives) and a family (how it is built); the classification line keeps the two positions as separate fields.

Record the decision

The classification line

Six values, carried in the repository manifest, the catalogue entry and the product BOM: anatomy tier / pattern family / agency class / risk tier / data class / reuse generation. Search, policy-as-code, the catalogue and the pattern arbiter all read it. Value definitions, reuse generations and the no-automatic-promotion rule are on BOM and recipes.

The design record (ten fields)

An ADR in a repository agents can reach, marked superseded rather than edited when it changes (Book 2 Ch 22 §5.5; Research Paper 1 §7.5).

#FieldWhat it holds
1Problem and business ownerThe problem in the originator’s words (from bet card field 1); the named sponsor
2Classification lineThe six values
3Chosen agency class, and every lower class rejected with the reasonThe least-agency rule made auditable; deferrals carry triggers
4Patterns used per anatomy tierNamed patterns from the catalogue
5Catalogue assets reused; new assets proposed for contributionOutput of question 6
6Model class and hosting routeWith the data-class reason
7Policy pack and residual risksIncluding the consequence cell per decision and, for class 3/4, the cut-set answer and any findings
8Evaluation plan and acceptance thresholdsOutput or trajectory evaluation as the class requires; golden records where they exist
9Named accountable human for the operational scopeThe wrangler
10Exit or fallback strategyWhat happens when the model, vendor or pattern fails

Field 3 is the one that changes behaviour: a record stating only the chosen class is a receipt; one stating the rejected classes and why is a decision. Because the record sits where agents read, an agent that meets an unresolved design question can propose the missing record instead of filling the gap with a plausible default; the human decides.

Sequencing rule. No branch until the record exists. If writing it takes more than an hour, the fields are wrong. A record first committed after the first substantial pull request is retrospective justification.

Reading vendor reference architectures

Published material falls into five families that answer different questions (Book 2 Ch 22 §4.4; Research Paper 1 §3): hyperscalers describe lifecycle and quality, practitioners composition, academics forces and trade-offs, standards bodies interfaces, regulators obligations. Take each family’s strength; none alone is enough.

Five substance tests. Keep an element only if it passes at least three: (1) it states a principle that survives a change of vendor; (2) it names trade-offs or failure modes, not only benefits; (3) it maps to a component or control someone can build or audit; (4) any numbers come with a method; (5) it is consistent with independent sources. Brand names, unqualified impact percentages and product lists fail.

Vendor positions (as of September–November 2026, per Book 2 Ch 22 §4.4 and Appendix C C.12). [FACT-CHECK: pattern names and classifications in the current Microsoft Learn, AWS Well-Architected Generative AI Lens and Google Cloud agentic design pattern pages; all are revised without version numbers.]

SourceContributionHow this factory reads it
Anthropic, Building effective agentsWorkflows (predefined code paths) versus agents (model-directed); five workflow patterns; “simplest solution possible”Draws the line where this page does
Microsoft Learn, AI agent orchestration patternsSequential, concurrent, group-chat, hand-off and magentic orchestration; use the lowest complexity that reliably meets requirementsOrchestration guidance, not a portfolio model: says how to wire four agents, not whether to have four
AWS Well-Architected Generative AI LensQuality pillars across lifecycle phasesA good per-workload review instrument; little on portfolio reuse
Google Cloud, choose a design pattern for agentic AIRequirements-to-pattern selection; lists sequential, parallel and loop among multi-agent patternsUnder the control-flow test, code-ordered sequential, parallel and loop flows are workflows. Mislabelling decides which control bundle attaches and whether trajectory evaluation and an agent identity are needed

Translate imported material at the door into the factory’s vocabulary: six anatomy tiers and one plane, five classes, eight families. Hold the mapping centrally.

Failure modes and recovery

Failure mode (Book 2 Ch 22 §8; the last row from §5.3)How to recognise itRecovery
The taxonomy becomes a filing cabinetAsk which system fails when a classification line is wrong. If none, nothing reads itWire the line into consequences: policy pack attaches from it, catalogue counts reuse from it, unregistered combinations get no credentials
Agency creep by demonstrationDrift signature: the line says class 2 while traces show the model choosing tool order. Escalations happened one commit at a timeMake the class a run-time assertion: compare declared class with observed control flow in traces, and open a finding on mismatch rather than waiting for audit
Design record written afterwardsRecord committed after the first substantial pull request; rejected alternatives nobody seriously consideredNo branch until the record exists
Least agency as a permanent vetoRecords that say no and stop, with no deferral triggers; nothing ever crosses 2 → 3Require a trigger on every deferral; review deferrals as a portfolio
The single controlCut-set review run backwards yields one entry, or all entries on one tier and planeAdd a control that fails differently (broker refusal, unreachable data, workflow-held approval)
Importing someone else’s stack wholeTwo people use “layer 3” for different things for ten minutes without noticingHold the mapping centrally and translate at the door; keep the anatomy and the portfolio apart (application anatomy)
Consequence by categorySign-off rules written per department or use-case typeRe-classify per decision on the matrix

Translocation. The shape is not permanent. When trajectory traces show the same tool sequence in the large majority of runs over a sustained period, codify the hot path as a workflow, replay-test for equivalence and narrow the agent to the residue; legacy systems can delegate exceptions upward to an agent in draft or approval mode. Procedure on the bounded-agent pattern.

Acceptance checks

  • Every AI product in production or build has a classification line; at least one system reads it with consequences (policy, catalogue or credentials).
  • Every design record has field 3 filled with rejected lower classes and reasons; every deferral has a trigger.
  • Every step up carries the evidence in the escalation table; no 3 → 4 escalation rests on step count, team count or a vendor diagram.
  • Each decision the product takes is placed on the consequence matrix, and the configured action scope does not exceed the stricter of the matrix ceiling and the risk tier’s autonomy_ceiling.
  • Every class 3 or 4 design record contains a cut-set answer naming the top event, the controls with their envelope part and plane, and no single-event cut set (or an open finding with an owner and date).
  • Declared agency class is checked against trace evidence; a mismatch opens a finding.
  • Design records are committed before the first branch.
  • The share of requests whose control bundle attached without a meeting is measured (Book 2’s best single indicator that the taxonomy is working).

Scale to the firm

Firm (Book 2 Ch 22 §7)Approach
About 1,000 peopleNo pattern arbiter. The technology-strategy owner holds the taxonomy for about ninety minutes a fortnight. Adopt the eight family names and five classes; let specific patterns accumulate. Still write the classification lines down
About 3,000 peopleAppoint the pattern arbiter explicitly within the factory architect’s job: no design record, no build. Pre-approve a policy pack per recurring class-and-data-class combination
About 50,000 peopleCentralise the vocabulary (five classes, eight families, one control-flow test), the escalation criteria and the design-record schema; let divisions hold their own pattern catalogues underneath

The research-assistant example applies the full sequence to a composite request: seven agents on a vendor slide became a class 2 routing workflow in front of a class 1 grounded assistant, with class 3 deferred on a trigger and class 4 rejected on the 3 → 4 rule.

Source material

  • Book 2 (The AI Delivery Factory), Chapter 22, The Shape of an AI Product (§2, §4.2–§4.6, §5.1–§5.5, §6–§8)
  • Book 2 (The AI Delivery Factory), Appendix C, The Pattern Catalogue (C.10 Trust, governance and operations; C.12 Cross-reference: the practitioner guides)
  • Book 1 (Building Organizations for the Age of AI), Chapter 1, The Adoption Gap (§4.5, the GCC leapfrog: formalising SOPs into decision models)
  • Research Paper 1, A Taxonomy for a Reuse-Driven AI Factory (§3 sidebar five tests; §7.1–§7.6 decision framework)
  • Research Paper 2, Ten Solution Archetypes for Regulated Finance (§2.2 agency class and action scope; §6.1 find the agency class; §6.2 choose between neighbours)

← All AI Delivery Factory guidance

On this page

  1. Keep two scales separate
  2. Know what each class costs before committing
  3. Ask the eight questions in order
    1. When the request is an existing procedure
    2. Choose between neighbouring archetypes
  4. Bring evidence for every step up
  5. Cap action scope by consequence
  6. Run the cut-set review for class 3 and 4
  7. Settle the other selection dimensions
  8. Record the decision
    1. The classification line
    2. The design record (ten fields)
  9. Reading vendor reference architectures
  10. Failure modes and recovery
  11. Acceptance checks
  12. Scale to the firm

All pages in Design →