Browse the reference ⌄
Pattern published

The Ten AI Product Recipe Families

The ten recipe families and their design cards (flow, action scope, data classes, controls, evidence, evaluation, anti-patterns), how to fit a request and choose between neighbours, the pattern catalogue beneath them, the human duties each recipe must staff, who governs the catalogue, and the pipeline checks that catch family drift, families of one and orphans.

Version
0.2.0
Owner
DEIXEI
Last reviewed
Reading time
46 min

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

Sources and details
Section
Patterns
Source works
Book 2 · Research Series
Source chapters
5, 22, 23, 24
Source appendices
02:C
Refresh trigger
source change

Full source list ↓ Source index →

A recipe family is a reusable composition of patterns, controls, templates, evaluation signals and known anti-patterns, held in the catalogue as a governed asset. Picking one turns a design problem into a fitting problem: which family is this nearest to, and what is genuinely different about it? The product inherits the family’s controls by composition, and only the difference is reviewed (source claim, Book 2 Ch 23 §3).

Status. The ten families, their cards and the claim that they cover most demand are the author’s design proposal. Coverage has not been measured against any firm’s use-case inventory; test it on your own backlog (Research Paper 2 §8).

Ten recipe families cover most of what a regulated firm will build with AI; start from the nearest family, not a blank page.

At a glance: start from the nearest of ten families, not from a blank page. The detailed diagram is under The catalogue. Source: The AI Delivery Factory, Chapter 23, Figure 23.2.

Vocabulary used on this page. Book 2 says recipe family, agency class 0–4, hosting route and autonomy-ladder rung. Research Paper 2 says archetype, A0–A4, processing lane (A vendor API, B own cloud tenancy, C controlled infrastructure) and action scope (read-only, draft, act with approval, act autonomously within an envelope). They describe the same ten shapes. This page uses Book 2’s names and quotes Paper 2’s lane and scope values in the cards, because the cards come from Paper 2. Lanes map to hosting routes on data classes and lanes.

What a family must ship

A family that lacks any of these six is a label, not an asset (source claim, Book 2 Ch 23 §4.1):

ElementWhat it containsAcceptance check
Pattern compositionThe coded patterns it is built from and how they connect (catalogue below)Every component’s classification line names a code
Policy packThe pre-approved control bundle for the shape: constraints at management-group scope, pipeline checks, per-request gateway decisionsEach control is enforced by a machine, not described in a design document
TemplatesRepositories, pipeline definitions, infrastructure modules, evaluation-harness scaffold, design-system disclosure components, on top of the standard application foundationA team can instantiate the family without writing plumbing
Evaluation signalsThe family’s own metrics, named in advance, with golden records to measure againstNo single “accuracy” number; the signals per card below
Default agency class and ceilingThe class from the product-shape guide. The class is a ceiling, not a targetThe pipeline rejects an instance that exceeds the ceiling (drift check)
Known anti-patternsWritten from the firm’s own history and published cataloguesPresent and non-empty; the cheapest section to write and the most often omitted

Two further attributes are kept per family by the pattern arbiter: its reuse generation (a family is G4, a governed recipe; see BOM and recipes) and the date of its last evaluation run. Orphan rule: a family with no active owner, or no evaluation run in 90 days, counts towards the orphan rate on factory measurement (Book 2 Ch 23 §4.1; App C C.10).

A family must also record the human duties it needs, with hours (below).

The catalogue

#FamilyClassPattern composition (Paper 2 §4)What it brings
1Content assistant0MI-TMPL, MI-STRUCT, IN-GWOutput guardrails, AI-use disclosure, prompt library, trace retention
2Grounded knowledge assistant1KN-RAG+, KN-PERM, KN-CITE, IN-GWEntitlement-aware retrieval, citation enforcement, groundedness evaluation
3Structured-data analyst1–2KN-SQL, MI-STRUCT, AG-CODE (sandboxed)Semantic-layer binding, query validator, row-level security, visible query
4Document processing pipeline2WF-PIPE, MI-STRUCT, WF-PAR-VOTE, WF-HITLExtraction schemas, confidence thresholds, exception queue, source-span evidence
5Classification and triage router2WF-ROUTE, MI-ROUTE, IN-EVENTFixed label taxonomy, escalation rules, misroute feedback, routing audit log
6Review and compliance checker2WF-EVAL, WF-PAR-VOTE, KN-CITEQuote-and-cite per finding, rulebook versioning, no automatic approval path
7Embedded domain copilot2–3IN-EMBED, KN-RAG+, AG-TOOL (read-only)On-behalf-of identity, read-only default, actions as buttons the user presses
8Bounded task agent3AG-BOUNDED, AG-PLAN, IN-MCPGW, WF-HITLDedicated identity, tool allow-list, budgets, approval before action, kill switch
9Research and analysis crew4MA-HIER or MA-SUPER, KN-AGRAG, AG-REFLECTSource allow-lists, provenance per claim, round and cost budgets, analyst ownership
10Agent-driven department process4MA-SEQ / MA-SUPER, IN-A2AGW, IN-ASYNC, WF-HITLWorkflow-held state, workflow-enforced approvals, per-agent wrangler, replay testing
Ten proposed recipe families arranged from single-call products through multi-agent processes, with agency class and hosting routes shown separately.

The ten families move from low to higher agency. No family owns a hosting route. Source: The AI Delivery Factory, Chapter 23, Figure 23.2.

Agency class is design-time; the rung is earned. The class says who decides the next step (code at classes 0–2, the model at class 3, models, code or both at class 4). The autonomy-ladder rung, or action scope, is a run-time permission earned on evidence per agent and domain, and authorised by the risk tier. A class 3 agent at the advisory rung is normal. A class 3 pattern chosen where class 2 would do breaches the least-agency rule at any rung (Book 2 App C C.1).

Class 4 covers two kinds of design. Class 4 is defined by ownership: several agents with separate owners, identities, security boundaries or release cycles. Family 9 is model-orchestrated; family 10 is sequenced by code between stages. Both carry the class 4 control bundle, but family 10’s test effort is closer to a workflow’s (Paper 2 §5.10, §8).

Code-execution routes. Every tool in the ten families is pre-authored, reviewed code. Agent-generated runtime code appears only in families 3, 8 and 9, always in an ephemeral sandbox. Runtime code that worked once is never promoted to a scheduled or production script except through reviewed deployment (Paper 2 §3; detail on bounded agent).

Fit a request to a family

  1. Start from the task and outcome, not the requested model or “agent”.
  2. Ask the first two questions of the decision sequence: would rules, a query or a report do? Is this a prediction (score, probability, forecast)? If so, it is conventional software or classical machine learning with its own model-risk regime, and none of the cards applies (Paper 2 §6.1; AD-CLASSIC below).
  3. Find the agency class with the product-shape guide; every step up needs the evidence listed there.
  4. Pick the family within that class. If two are plausible, use the neighbour table.
  5. Decompose compound requests. Most “an agent that handles X” requests are several families in sequence.
  6. Let the data class, not the family, decide the hosting route (data classes and lanes).
  7. Record the family and the deltas on the intake form (below).

Choose between neighbours

Take the simpler family unless the named condition holds (Book 2 Ch 23 §5.4; Paper 2 §6.2):

Unsure betweenTake the simpler one unless
1 content assistant / 2 grounded assistantThe answer depends on facts the user did not supply
2 grounded assistant / 9 research crewQuestions routinely need planning across many sources and a synthesised report
3 structured-data analyst / 4 document pipelineThe inputs are documents rather than governed tables
4 document pipeline / 8 bounded task agentDocuments vary so much that the processing steps cannot be fixed in advance
5 triage router / 8 bounded task agentResolving the request, not only routing it, is genuinely in scope
7 embedded copilot / 8 bounded task agentThe task spans several systems and cannot be completed inside the host application
8 bounded task agent / 10 department processSeveral teams own parts of the process and need separate agents, identities and release cycles

Tie-break. When the room cannot agree, ship the simpler family and let its evaluation signals show within a quarter whether the harder one was needed. The argument costs more and produces no evidence (Book 2 Ch 23 §5.4).

Composite fits (illustrative)

Research Paper 2 §6.3 fits three requests at composite firms (not real institutions):

RequestFitLesson
Insurer I: “an agent that handles motor claims”Inbox sorting = family 5; form and estimate extraction = family 4; finding cover terms = family 2 or 7; end-to-end process = family 10, earned laterStart with two class 2 families
Bank B: “AI that writes credit memoranda”Public research on a corporate borrower = 9; checking a finished memo against policy = 6; drafting from the analyst’s notes = 1None of the three makes or recommends the credit decision
Asset Manager X: “a chatbot on our fund data”Prospectus questions = 2; flows and performance figures = 3, after checking the metrics are definedThe request named a technology; the fit named a smaller first step

When a request fits none of the ten

A misfit is information about the list, not a failed request (Paper 2 §7, design proposal):

  1. Check for a composition. A router (5) that hands some items to a grounded assistant (2) and others to a bounded agent (8) is three cards. Apply each card to its part, and let the stricter controls govern the joins.
  2. Check it is a generative-AI problem at all (step 2 above).
  3. Design from the patterns and record the decision in an AI design record (the ten fields of Book 2 Ch 22 §5.5, on the product-shape guide): problem and business owner; classification line; chosen agency class and every lower class rejected, with reasons; patterns per anatomy tier; catalogue assets reused and new assets proposed; model class and hosting route; policy pack and residual risks; evaluation plan and acceptance thresholds; named accountable human; exit or fallback. (Paper 2 §7 lists the same record without the reuse field.) A one-off design gets more review than a family instance, because nothing about it is pre-approved.
  4. Treat recurrence as a signal. A third build of the same composition opens a decision on a new family; it does not create one automatically.

Shapes the ten do not carry well, per the author: client-facing conversational channels (conduct, disclosure and complaint duties no card sets out), browser or computer-use agents as the main mechanism, fine-tuning, and decisions at machine speed with no human decision point.

The ten design cards

Each card gives the flow, scope, data, controls, evidence, evaluation and anti-patterns (Research Paper 2 §5, design proposal; Book 2 Ch 23 §5). Lane values are Paper 2’s. Where a use touches people’s creditworthiness, insurance pricing or automated decisions about individuals, the same shape can become a different regulatory object; check the regulatory map rather than assuming the card settles it.

1. Content assistant (class 0)

Flow. User picks a task and pastes content → gateway classifies the input, masks personal data where the task allows, picks a lane → versioned task template wraps the content → one model call → output guardrails check tone, leakage and format; the interface labels the text AI-generated → the user edits and uses it. Nothing is sent automatically.

AspectDesign
Use / avoidSelf-contained task the user judges / any answer that depends on facts the user did not paste (the most common misuse)
ScopeDraft only
Data and lanesC1–C2 any lane; C3 on Lane B or C; C4 only on Lane C
ControlsInput classification, AI-use disclosure, no retention of pasted content beyond the trace policy, style and brand guardrails
EvidenceGateway trace per call: user, template version, model, data class, lane
EvaluationTask rubrics (summary faithfulness, translation quality), user feedback
Anti-patternsFactual questions the model cannot know; pasted content stored in shared memory

Why build it first. It forces the gateway, prompt library, disclosure component and trace policy into existence, and the next nine families inherit all four (Book 2 Ch 23 §5.1).

2. Grounded knowledge assistant (class 1)

Query flow. Question + identity → gateway input guardrails and classification → query rewrite → hybrid search under the asking user’s entitlements → rerank and assemble context → answer with citations → gateway groundedness and citation check → cited answer, or “not found”.

Ingestion flow (the half firms underestimate). Load from approved sources → parse and chunk → attach metadata (owner, class, validity date, access groups) → embed → write to an index whose class equals the highest class it contains. Deletions and permission changes reach the index within a stated, scheduled-tested propagation window.

AspectDesign
Use / avoidKnowledge in documents, answerable from a few passages / arithmetic over tables (3), synthesis across many sources (9)
ScopeRead-only
Data and lanesC3 indexes separated by domain on Lane B or C; C4 corpora need a dedicated index on Lane C
ControlsEntitlement propagation, citation enforcement, answer-only-from-context instruction, document validity filters, indirect-injection screening of ingested content
EvidencePer answer: question, user identity, source IDs retrieved, citation-check result. Per index: ingestion log with document class and validity
EvaluationRetrieval recall and precision on a golden question set, groundedness, citation accuracy, refusal quality on out-of-scope questions
Anti-patternsOne big index for everything; service-account retrieval that ignores user permissions; stale documents without validity dates

3. Structured-data analyst (class 1–2)

Flow. Question → mapped to defined metrics in a semantic layer, not raw tables → model drafts a query → validator checks syntax, allowed tables, row-level security and cost; failures loop back within a small retry budget → the platform runs the query as the user → optional analysis in an ephemeral sandbox with read-only access to the result set → narrative plus the executed query, data timestamp and chart.

AspectDesign
Use / avoidMetrics defined and users need ad hoc cuts / metrics undefined or disputed: fix the data product first, or the interface industrialises the dispute
ScopeRead-only; class 1 for single queries, class 2 for a fixed query–validate–analyse chain
Data and lanesResults inherit the data product’s class; C3 on Lane B or C; the model sees schema and aggregates, not bulk rows, wherever possible
ControlsQuery allow-list, row- and column-level security, cost and row limits, sandbox without network egress, the executed query always shown
EvidenceExecuted query, data timestamp, generated code and its output, validator decisions
EvaluationExecution accuracy on a golden question-and-answer set, validator rejection rate, agreement with trusted reference reports
Anti-patternsText-to-SQL on raw operational tables; full datasets in the prompt; hiding the query

4. Document processing pipeline (class 2)

Flow. Governed intake; each document hashed and registered → parse/OCR with layout → classifier assigns document type → type-specific schema drives extraction; two independent extractions must agree on critical fields → rules and confidence thresholds decide straight-through or review queue → approved records written through a typed, idempotent tool, never as free text → weekly sampled QA of straight-through items. Every field keeps a pointer to its page and text span.

AspectDesign
Use / avoidKnown document types, output specifiable as a schema / each document needs its own investigation path (8)
ScopeAct with approval for writes; autonomous writes only above a validated confidence threshold for low-risk fields
Data and lanesOnboarding files and contracts typically C3 with personal or client-identifying flags (Lane B or C); medical evidence handled at C4; masked samples for development
ControlsSchema validation, field-level thresholds, dual extraction, review queue with a service level, source-span evidence, idempotent writes
EvidenceDocument hash and registration, source span per field, reviewer corrections, weekly sampling results
EvaluationField-level precision and recall per document type, straight-through rate, reviewer correction rate, drift by source
Anti-patternsOne generic prompt for all types; writing unvalidated output; no exception queue

5. Classification and triage router (class 2)

Flow. Event (mail, ticket, form) normalised → sensitivity classified first, so later steps use a permitted lane → classifier with a fixed label set and structured output assigns intent, urgency, language, entities → below the confidence threshold: human triage, whose decision joins the golden records → above it: a deterministic, business-owned rule table maps labels to destinations, including other families → complaints and regulatory or legal language always escalate, whatever the confidence.

AspectDesign
Use / avoidHigh volume, stable labels, several handlers / low volume, or labels that change weekly
ScopeAssigns and tags only; never replies or resolves
Data and lanesInbound mail may contain anything: classify before any external lane; default Lane B or C for client mailboxes
ControlsFixed taxonomy, mandatory escalation rules, misroute feedback loop, audit log of every routing decision
EvidencePer item: labels, confidence, rule applied, destination; human triage decisions; misroute corrections
EvaluationPer-label precision and recall; misroute rate and share sent to human triage, read as a pair; time to first handler
Anti-patternsModel-invented labels; complaints routed without escalation rules; no path back from a wrong queue

A change of destination is a rule-table change, never a prompt change. The workflow pattern has a composite service-desk example that shows what happens when resolution creeps into a router.

6. Review and compliance checker (class 2)

Flow. Draft submitted with context (product, audience, jurisdiction) → the versioned rulebook for that context is loaded; Compliance or Legal maintains it as structured data, not prompt text → rule groups checked in parallel; each finding quotes the passage and cites the rule → findings merged and ranked by severity → a critic pass removes unsupported findings and flags missing mandatory elements → the reviewer accepts or rejects each finding; rejections feed evaluation.

AspectDesign
Use / avoidRules can be written down and the reviewer stays accountable / inherently subjective judgement with no rulebook
ScopeAdvisory only; the human decides
Data and lanesUsually C2–C3; unpublished product or deal information may carry the inside-information flag (Lane B or C)
ControlsQuote-and-cite per finding, rulebook versioning, reviewer sign-off, no automatic approval path
EvidenceRulebook version, every finding with quote and rule, reviewer decision per finding, reviewer identity
EvaluationFinding precision and recall against expert-labelled drafts, acceptance share, missed-issue rate from later audits
Anti-patternsPresenting the output as “compliant” (the fatal one); rules hidden in prompts; no rulebook version recorded

7. Embedded domain copilot (class 2–3)

Flow. The panel sends the question, current record ID and the user’s token → the copilot chooses among a small set of read-only tools → calls pass the tool broker as the user, so the business system enforces its own permissions → answer plus a proposed next step (for example a prefilled form) → the user executes any change through the host application’s normal controls.

AspectDesign
Use / avoidUsers work mainly in one system and ask about its records / tasks spanning systems end to end (8 or 10)
ScopeDraft or suggest, never execute; class 2 with fixed lookups, class 3 with a small read-only tool set
Data and lanesInherits the host system’s class; CRM and claims data typically C3 with flags (Lane B or C)
ControlsOn-behalf-of tokens, read-only tools, a maximum number of tool calls per question, actions rendered as interface elements, per-application tool allow-list
EvidenceEvery tool call with the user identity it ran under; executed actions recorded by the host application as the user’s own
EvaluationTask success on scripted scenarios, tool-selection accuracy, latency, adoption and feedback in the host
Anti-patternsA service account with broader access than the user (an escalation path invisible to testing, because the copilot works); free-text instructions instead of structured actions; a separate copilot per screen with no shared tools

8. Bounded task agent (class 3)

The first family where the model directs the flow, so the envelope is the main design artefact. Full envelope schema, validation and worked example: bounded agent.

Flow. Trigger (user or event) → logged plan, shown to the user for higher-risk tasks → act loop: every tool call passes the same policy check (tool, scope, budget) → reads execute, writes create an approval task, denied calls escalate to the owner rather than retrying → observations update run state → the run ends on success, budget exhaustion or escalation, with a report and the full trace.

Envelope elementExample setting (Paper 2 §5.8, a bank’s cash-reconciliation team)
Goal and scopeInvestigate unmatched cash breaks on the team’s accounts and propose corrections
ToolsRead: ledger, correspondent statements, mailbox search. Write: create a correction proposal
Action scopeAct with approval for any write; no payments; no external email
Data scopeThe requesting team’s accounts; C3 maximum
BudgetsAt most 30 tool calls and 10 minutes, plus a token cap per run
EscalationUnknown counterparty, amount above threshold, conflicting evidence
IdentityDedicated least-privilege agent identity; on-behalf-of for user-triggered runs
OwnerNamed head of the operations team
AspectDesign
Use / avoidSteps vary by case, tools exist, a human can approve the outcome / predictable steps (4 or a workflow), or irreversible high-value actions
ScopeAct with approval by default; autonomous only for reversible low-risk actions proven by replay tests
Data and lanesUp to C3 by default; C4 only on Lane C with draft-only scope
ControlsEnvelope enforcement, tool allow-list, budgets and kill switch, sandbox for generated code, trajectory logging, prompt-injection screening of tool outputs
EvidenceLogged plan, full trajectory of tool calls and policy decisions, each approval and its decider, final report
EvaluationTask success on scenario suites, trajectory quality (unnecessary calls, denials), approval acceptance rate, cost per task, replay results
Anti-patternsA user’s full permissions; open-ended “do whatever it takes” goals; approvals clicked through without information

9. Research and analysis crew (class 4)

Flow. Analyst brief with scope, permitted sources and deadline → supervisor writes a plan and task ledger, visible to the analyst → specialists work in parallel, each with a narrow tool set and its own context, returning sourced findings → synthesis writes the report, every claim linked to a source → critic checks support, contradictions and coverage, and may request another round within a hard round budget → analyst edits and signs; the report is marked AI-assisted and the trace retained.

AspectDesign
Use / avoidOpen questions needing many sources and hours of human work / a fixed corpus answers it (2), or speed matters more than breadth
ScopeRead-only; the output is a draft the analyst owns
Data and lanesExternal research can run on Lane A; internal client, position or deal data raises the run to C3–C4 and Lane B or C; information barriers enforced per agent, not per crew
ControlsSource allow-lists, provenance per claim, per-run budgets and round limits, information-barrier checks, analyst ownership
EvidenceTask ledger, source behind every claim, trajectory per agent, analyst sign-off
EvaluationFactual accuracy and citation support on benchmark briefs, coverage against expert reports, cost and time per report, extent of analyst edits
Anti-patternsUnbounded rounds (the fastest way to turn a budget into nothing); agents sharing one giant context; reports forwarded without review

10. Agent-driven department process (class 4)

Flow. A business event opens a durable workflow instance with fixed states (received, checked, prepared, approved, executed, closed, plus an exception state that returns to the wrangler) → each stage is a specialised agent with its own envelope, identity and wrangler → cross-department steps go through the agent gateway, never shared credentials → exceptions, low-confidence results and denials land in the wrangler console → approvals are workflow states, not prompt requests → the execution agent acts through governed tools → evidence, indicators and cost collected per instance. The workflow carries the highest data class seen so far and enforces it on later stages.

AspectDesign
Use / avoidHigh-volume processes spanning teams with clearly owned stages / stages not yet stable: run each as family 4, 6 or 8 first
ScopePer stage, from draft to autonomous within the envelope; approvals fixed by the workflow
ControlsNamed owner per agent, workflow-enforced approvals, inter-agent authorisation, replay testing before scope changes, kill switch per agent and per process, failures raised in the firm’s ICT incident process
EvidenceEvery transition with agent identity and version; each approval and approver; exceptions and resolution; evidence bundle per instance
EvaluationCycle time, straight-through rate, exception rate by stage, error escapes found in QA, cost per case, wrangler workload
Anti-patternsOne super-agent doing everything; agents coordinating by conversation with no process state; accountability assigned to “the AI”

Assemble family 10 last. Build it only after its stages run stably as lower-class families; otherwise it is unproven components in series that fail where you have least evidence. Process rules, stack and team shape: agent-driven departments.

A worked recipe: the regulated internal workflow application

A recipe is a sequence with each step labelled automated action, policy gate or human decision (labelling rules on BOM and recipes). Book 2 Ch 5 §4.3 gives the reference sequence for a regulated internal workflow application. The labels below are this page’s reading; the book requires each step to carry one but does not tabulate them.

#StepKind
1Create repositories from the sanctioned template: application, infrastructure and test automation as separate repositoriesAutomated action
2Provision development, test, staging and production environmentsAutomated action
3Wire identity through the enterprise provider (with the sanctioned role-mapping pattern)Automated action
4Establish baseline secrets in the vaultAutomated action
5Configure logging and telemetry with correlation identifiersAutomated action
6Register the APIsAutomated action
7Deploy the infrastructureAutomated action
8Run the testsPolicy gate
9Scan dependencies and infrastructurePolicy gate
10Publish the artefactsAutomated action
11Deploy to stagingAutomated action
12Run the acceptance checksPolicy gate
13Require a data-domain classification before production access is grantedPolicy gate
14Obtain the change approvalHuman decision, checked as a policy gate (no deploy without a valid approval record)
15Deploy to productionAutomated action
16Publish the evidence (change decision record, deployer manifest)Automated action
17Update the product recordAutomated action

Composite example (Asset Manager X, Book 2 Ch 5 §6; a composite firm). An operational-risk case-management application inherits this recipe on Azure: Entra ID with role mapping, Application Insights with correlation IDs, Key Vault, API Management registration, Defender for Cloud dependency scanning, infrastructure scanning, and a Purview data-domain classification gating production data. It also requires a rollback plan and a named support model before production. The team writes only the product-specific steps (incident state machine, routing rules, regulator export) and composes the identity, logging and foundation sub-recipes. As of 2026 per Book 2 Ch 5. [FACT-CHECK: confirm current Azure service names and capabilities against Microsoft documentation.]

The pattern catalogue beneath the families

Families are compositions of coded patterns. Book 2 Appendix C holds some seventy entries in eight families (structure from Research Paper 1 §4.2 and Appendix A). Codes belong in the classification line and the catalogue; chapters and product prose use names.

How an entry is recorded

Each entry follows the CSIRO pattern template, adopted for every factory-owned entry (Book 2 App C C.1):

FieldWhat it records
Code and nameStable FAMILY-SHORTNAME identifier and plain name
Context (use when)What is true before you reach for it
ForcesThe pressures that pull against each other (cost against certainty, reach against control)
Consequences (trade-offs)What it costs; benefits are implied by the context, drawbacks are what a reviewer needs
Catalogue asset or factory noteWhat the factory ships so the second team does not rebuild it, or the constraint it imposes
Related entriesAlternatives and complements

An entry that lists only benefits is marketing; if the arbiter cannot name its cost, the factory has not used it enough to recommend it.

The eight families and the order of preference

CodeFamilyQuestionTypical class
MIModel interactionHow do we get the right output?0 and above, in every product
KNKnowledge and groundingHow do we give the model the right facts?1 and above
ADModel adaptationDo we change the model itself?Any (orthogonal to agency)
WFWorkflowHow do we chain deterministic steps and model calls?2
AGAgentWhen may the model direct its own control flow?3
MAMulti-agentHow do several agents cooperate?4
INIntegration and interoperabilityHow do models, agents and systems connect?Any
TRTrust, governance and operationsHow do we keep it safe, observable and compliant?Any; intensity scales with class and tier

Two preference orders (source claim, Book 2 App C C.2; Paper 1 §4.2):

  • MI → KN → AD. Try prompting and output patterns first, then grounding, and change model weights only as an exception with its own business case. AWS’s Generative AI Lens frames the same order as a lifecycle step (prompts, then data sources, then weights), per Book 2 App C C.12. [FACT-CHECK: confirm against the current AWS Well-Architected Generative AI Lens.]
  • WF → AG → MA. A workflow before an agent, one agent before several, and every step up justified in an ADR.

Model interaction, knowledge and adaptation: entries with forces and factory assets

CodePatternForcesTrade-offFactory asset
MI-TMPLPrompt template with system instructionsStandardisation vs flexibilityBrittle across model versionsVersioned prompt library linked to evaluation results
MI-FEWFew-shot promptingConsistency vs token costExemplars drift with the domainExemplar sets owned by the subject-matter expert
MI-STRUCTStructured outputInteroperability vs expressivenessToo tight a schema hides uncertaintyShared schemas for common business objects
MI-REASONExtended reasoningCertainty vs latency and costReasoning traces are not an audit recordReasoning-budget policy per use case at the gateway
MI-SELFCHKSelf-consistencyAccuracy vs costThe model marks its own workVoting and consistency utilities
MI-CTXContext engineeringCompleteness vs window limits and distractionFailures are silentContext builders, memory policies, standing context files
MI-CACHEPrompt and semantic cachingCost and latency vs freshness and isolationCross-user leakage if the key ignores entitlementsCaching policy at the gateway, keyed by data class
MI-ROUTEModel routing and cascadingCost vs qualityRouter accuracy caps qualityRouting rules in the model gateway
KN-RAG / KN-RAG+Naive / advanced retrievalCurrency vs fine-tuning cost; recall vs number of partsRetrieval caps answer quality; more parts to pinIngestion pipeline, index template, retrieval service with standard reranker
KN-GRAPHKnowledge-graph groundingRelational depth vs construction costGraph ownership is a data-product questionEnterprise knowledge graph as a data product
KN-SQLText-to-SQL over a semantic layerReach vs correctness and authorisationA plausible wrong number is worse than noneGoverned semantic layer and query tools
KN-AGRAGAgentic retrievalCoverage vs predictabilityRaises the product to class 3Retrieval tools behind the tool broker
KN-CITECitation enforcementVerifiability vs fluencyShorter answers, some refusalsCitation checker in output guardrails
KN-PERMPermission-aware retrievalConfidentiality vs index simplicityEntitlement changes must propagateEntitlement-propagating connectors behind the grounding data API
KN-MEMLong-term memoryContinuity vs privacy and poisoningRetention and erasure duties; poisoned memory persistsMemory service with retention policy
AD-NONEOff-the-shelf model (default)Speed vs dependencyBehaviour changes unless pinnedCatalogue entry; model usage registry
AD-PEFTParameter-efficient fine-tuningTask fit vs training-data governanceRe-tune on every base upgradeAdapter section of the catalogue
AD-DISTILDistillation to a small modelUnit cost and sovereignty vs upfront effortQuality ceiling set by the teacherDistillation pipeline
AD-PREF / AD-CPTPreference tuning / own modelBehavioural fit or moat vs specialist effort and extreme costHeavy evaluation burden; a model to defend to a supervisorRarely justified / out of scope for most firms
AD-CLASSICClassical or predictive MLDeterminism and explainability vs generalityA separate MLOps lifecycleFeature store and classical model section

Workflow (WF) entries, with their factory notes, are on the workflow pattern. The envelope behind AG-BOUNDED is specified on bounded agent. The three gateway entries (IN-GW, IN-MCPGW, IN-A2AGW) are on the model gateway and MCP and connector broker pages.

Agent, integration and trust entries

Single-agent entries (class 3), from Book 2 App C C.7. Every production entry runs inside AG-BOUNDED; the other six describe what happens inside the envelope.

CodePatternForcesTrade-offFactory note
AG-TOOLTool-using agentReach vs selection errorSelection errors grow with tool countTools only through the tool broker; keep the declared Means short
AG-REACTReason–act–observe loopAdaptability vs error propagationOne bad observation contaminates later stepsStep and spend budgets enforced outside the loop
AG-PLANPlan, then executeOversight and coherence vs plan stalenessPlans go stale as the environment movesThe preferred agent shape: the plan is an artefact a wrangler can approve
AG-REFLECTReflection / self-critiqueQuality vs costBounded by the model’s own competenceNot an independent control; never counted as second-line review
AG-CODECode-executing agent in a sandboxExactness vs execution riskSandbox security is mandatoryAlways paired with TR-SANDBOX; no network egress by default
AG-COMPUTERBrowser or computer-use agentLegacy reach vs fragility and injection exposureThe highest indirect-injection exposure in the catalogueLast resort behind IN-FACADE; advisory rung until replay testing says otherwise
AG-BOUNDEDBounded agent: Mandate, Means, Memory, MonitoringUsefulness vs blast radiusEnvelope design effort, paid once per recipeMandatory; declared in the recipe, owned by the wrangler, evaluated on every call (TR-EXEC-RUN)

Integration entries beyond the gateways (Book 2 App C C.9; translocation entries IN-CODIFY and IN-DELEGATE are on the workflow pattern):

CodePatternForcesTrade-offFactory note
IN-WRAPWrap-once MCP server per system of recordOne contract for every consumer vs the owning team’s capacityThe owner becomes everyone’s dependency; breaking changes need a major version and a migration windowRead tools separated from acting tools; a second wrapper is a contribution to the first, never a fork; the arbiter settles disputes
IN-MANIFESTManifest-driven catalogueCatalogue currency vs manifest disciplineThe catalogue is only as true as the manifestsBuilt by pipeline from repository manifests, never by hand; listing gated by the evaluation harness
IN-FACADEAnti-corruption façade over legacySafety of the core vs build effortEffort per systemThe typed contract is the asset; preferred to AG-COMPUTER wherever an API can be built
IN-EVENTEvent-driven agentsResponsiveness vs replay and duplicationIdempotency and replay designEvery emitted result carries the evidence record of the run that produced it
IN-ASYNCLong-running task with durable executionDurability vs infrastructure weightNeeds a workflow engine and a state storeProcess state lives in the durable workflow, not in the model’s context
IN-EMBEDEmbedded copilotAdoption vs per-application integrationIntegration effort per hostCore of family 7; inherits the host’s entitlements
IN-SIDECARGuardrail or policy sidecarProximity of control vs operational overheadOne more component per agentOne way to implement TR-EXEC-RUN where the gateway is too far from the action
IN-OBOOn-behalf-of identityLeast privilege by inheritance vs token-exchange complexityThe log must still tell agent from userUsed for advisory-rung assistants
IN-NHIDedicated non-human identity per agentAttributability vs identity lifecycle workAgent identities need lifecycle managementDefault for any agent above the advisory rung, with a named wrangler

Security and safety entries (Book 2 App C C.10). The risk column is the book’s mapping to the OWASP Top 10 for Agentic Applications for 2026, as of September 2026. [FACT-CHECK: confirm the ASI numbering against the current OWASP GenAI Security Project publication.]

CodePatternControl planeTrade-offRisk it mitigates
TR-INGRDInput guardrails: injection, personal-data and topic detectionPolicyFalse positives; latency per callGoal hijack (ASI01)
TR-OUTGRDOutput guardrails: grounding, citation, toxicity, data-leak checksPolicySome valid answers blocked; verdicts hard to explainMisinformation and leakage (no single ASI number)
TR-TOOLPOLTool allow-lists, parameter validation, typed tool contractsPolicy; registryContract upkeep as tools evolveTool misuse (ASI02)
TR-LEASTPRIVLeast-privilege agent identities, short-lived credentialsIdentityCredential lifecycle overheadIdentity and privilege abuse (ASI03)
TR-SANDBOXSandboxed code and browser executionPolicyLimits what the agent can usefully doUnexpected code execution (ASI05)
TR-MEMHYGMemory hygiene: provenance, time-to-live, write validationPolicy; evidenceShorter memory, less personalisationMemory and context poisoning (ASI06)
TR-BLASTBlast-radius caps: budgets, rate limits, circuit breakers, kill switchObservability; approvalA cap set too low halts legitimate workCascading failures (ASI08)
TR-SPOTLIGHTTrusted instructions separated from untrusted contentPolicyDesign effort; not a complete defenceIndirect prompt injection (listed under ASI01)
TR-SUPPLYProvenance checks on models, datasets, MCP servers, dependenciesRegistrySlows adoption of new componentsAgentic supply-chain vulnerabilities (ASI04)

The uncoded practices every recipe inherits (golden records, offline evaluation in CI, calibrated model-as-judge, trajectory evaluation, replay testing, red teaming, progressive delivery, FinOps guardrails, the failure-mode register, cut-set review) are attached through the policy pack, not the classification line; see evaluation and resilience.

Reviewer rules

Book 2 App C attaches reviewer notes to the riskiest entries. Stated as rules a reviewer can check:

RuleCheckSource
R1. A cache inherits the highest data class it stores. A semantic cache whose key ignores entitlements is a confidentiality incident, not an optimisationCache key includes data class and entitlement scope; cache store classifiedMI-CACHE, C.3
R2. KN-PERM is mandatory for C3 and C4 corporaRetrieval runs under the asker’s entitlements; propagation window stated and testedKN-PERM, C.4
R3. Fix retrieval before adding agency. A request for KN-AGRAG because retrieval is mediocre is usually a chunking or enrichment defect; the fix is KN-RAG+ at class 1Design record shows KN-RAG+ was tried and evaluated firstKN-AGRAG, C.4
R4. Ask whether a foundation model is needed at all. A numeric scoring or forecasting request answered with a language model is a category errorDesign record states why AD-CLASSIC or conventional software was rejectedAD-CLASSIC, C.5
R5. Multi-agent needs ownership boundaries or measured single-agent degradation, never the org chartEvaluation results or separate owners, identities or release cycles recordedC.8
R6. Self-critique is never a control. AG-REFLECT and MI-SELFCHK do not count as reviewSecond-line or human review is separate from the modelC.7, C.11

Multi-agent patterns: who decides the next step

Read the “who decides” column first. The first three entries are workflows whose stations happen to be agents and keep most of a workflow’s predictability; they still carry class 4 identity and registry controls (Book 2 App C C.8; Paper 1 Appendix A.6).

CodePatternWho decidesFactory constraint
MA-SEQSequential pipeline of agentsCodeThe shape of a department process once its stages are stable
MA-CONCConcurrent fan-out / fan-inCodeMerge logic is code; disagreements are surfaced, not averaged
MA-LOOPGenerator–critic loopCodeIteration and cost caps declared in the recipe
MA-HANDOFFHandoff between specialistsAgentsThe handoff record names the receiving agent and its wrangler
MA-SUPERSupervisor / coordinatorModelDelegates only to catalogued agents
MA-HIERHierarchical decompositionModel, several levelsFamily 9 only; advisory rung
MA-GROUPGroup chat / debateModelRound cap; output is advice to a named human
MA-MAGENTICManager with adaptive task ledgerModelLedger retained as evidence; not for a critical or important function
MA-SWARMSwarm / peer-to-peerEmergentNot used for regulated processes; listed so a proposal can be recognised and declined
MA-DYNSELDynamic selection from a catalogueModel plus searchWorks only if every agent’s classification line is filled in honestly

Controls that execute

Four TR patterns put governance in the deterministic layer; they are the product-side view of the enterprise control plane: TR-EXEC-CI (ADRs and guardrails compiled into CI checks for agent and human changes alike), TR-EXEC-RUN (envelope, route and tool policy evaluated on every call at gateway, broker or policy engine), TR-EXEC-REL (release blocked unless the release manifest’s evaluation results meet thresholds) and TR-EXEC-REG (unregistered models, agents or tools cannot obtain credentials or routes). Every family’s policy pack draws on them.

Cross-reference: the CSIRO Agent Design Pattern Catalogue

Book 2 App C C.11 maps all eighteen patterns of the CSIRO catalogue (Liu, Lo, Lu, Zhu et al., Journal of Systems and Software 220, 2025) to factory codes. Summaries are paraphrased; the constraints are the author’s.

#CSIRO patternNearest codesFactory constraint
1Passive goal creatorMI-TMPL, MI-CTX, IN-EMBEDDefault; log the goal in the user’s words
2Proactive goal creatorMI-CTX, IN-EVENT, AG-COMPUTERAmbient capture is personal-data processing; assess before building
3Prompt/response optimiserMI-TMPL, MI-FEW, MI-STRUCTOne versioned prompt library, not a copy per team
4Retrieval augmented generationKN-RAG, KN-RAG+, KN-PERM, KN-CITEAdd entitlement-aware retrieval and citation enforcement
5One-shot model queryingMI-TMPL, MI-DECOMPLeast-agency starting point; its drawbacks justify any step up
6Incremental model queryingWF-CHAIN, MI-REASON, AG-REACTEvery extra query metered at the gateway; step budgets declared
7Single-path plan generatorAG-PLAN, MI-DECOMP, WF-CHAINPreferred agent shape: a plan a wrangler can approve
8Multi-path plan generatorAG-PLAN with WF-HITL; MI-SELFCHKEach human choice is a recorded approval
9Self-reflectionAG-REFLECT, MI-SELFCHK, WF-EVALQuality technique, never a control
10Cross-reflectionWF-EVAL, MA-LOOP, calibrated model-as-judgeCritic is a different model via the gateway; one wrangler owns the outcome
11Human reflectionWF-HITL, online feedbackThe duty is recorded in the recipe and held by a named person
12Voting-based cooperationWF-PAR-VOTE, MA-CONCCode counts the votes; every ballot is evidence
13Role-based cooperationMA-SEQ, MA-SUPER, MA-HIER, MA-HANDOFFEach role a separate identity with a wrangler (families 9, 10)
14Debate-based cooperationMA-GROUPAdvisory only, round cap, transcript retained
15Multimodal guardrailsTR-INGRD, TR-OUTGRD, TR-SPOTLIGHT, IN-SIDECARBuilt once at the gateway; every block logged with its reason
16Tool/agent registryIN-MCPGW, IN-A2AGW, MA-DYNSEL, TR-EXEC-REGRun internally and enforced: no registration, no credentials
17Agent adapterIN-FACADE, IN-MCPGW, TR-TOOLPOLPrefer typed, versioned tool contracts to run-time interface learning
18Agent evaluatorShared evaluation harness, TR-EXEC-RELGolden records owned by the business expert and versioned

The CSIRO catalogue says little about identity, entitlements, evidence or release; that is its scope, not a defect, and is why the factory keeps its own catalogue (Book 2 App C C.11).

Staff the human duties with hours

A recipe that puts people in the loop must name three duties and the hours against each (source claim, Book 2 Ch 24 §7). They are staffing commitments, not interface features, and they are filled from people the product team already has.

DutyWhat it doesUsually held byFailure if unstaffed
SupervisorTakes the approvals, low-confidence results and exceptionsThe wranglerAn approval queue nobody reads
Annotator of golden recordsSays what a right answer looks like, and keeps saying it as the domain movesThe business subject-matter expertEvaluation drifts from reality; thresholds become meaningless
Feedback providerSupplies corrections that somebody actually readsThe product owner answers for the loopThe recipe stops improving

Procedure. Record each duty in the recipe with an owner role and estimated hours per week at the expected volume. Cost them at intake on the same capacity line as the business analysts. Acceptance check (this page’s recommendation, following the book’s warning that a supervisor with no hours means an unread approval queue): no recipe instance goes live with a duty at zero hours. Book 2 gives no hour figures; size them from the family’s expected exception rate and review-queue volume.

Who governs the catalogue: the pattern arbiter

The taxonomy, the pattern catalogue and the ten families are one versioned corpus with one owner: the factory architect, acting as pattern arbiter (source claim, Book 2 Ch 22 §5.5, Ch 24 §7, App C C.13).

RuleWhat it means in practice
One ownerProposals come from anyone; decisions come from the arbiter. Security, risk and the platform lead advise; advice is not ownership. A board owning the taxonomy collectively is the corpus rotting by committee
No forks: raise a change requestA team whose family does not fit raises a row on the platform backlog with the telemetry that prompted it. The arbiter rules one of three ways: amend the family, add a pattern, or decline with the reason written down, in an ADR
Signals, not triggersA second consumer, duplication telemetry or a third recurrence opens a judgement; none promotes anything automatically
Release like any shared assetThe corpus is versioned and released through the platform backlog; reviewed at least annually, sooner when a model generation, protocol or regulation moves
Stable codesA code is never reused for a different pattern, because shipped products’ classification lines depend on it. When a vendor renames something, the vocabulary cross-reference changes and the code does not
Every entry carries its drawbacksNo trade-off column, no recommendation
Variants as deltasAt large firms, divisional variants are declared deltas against the central family, not forks; the policy pack stays centrally owned even where templates stay local

The arbiter also runs the cut-set review for class 3 and 4 designs in the same design-record review (see product-shape guide).

Adopt families: count, pick three, change the intake form

Book 2 Ch 23 §7 gives a sequence (recommendation):

WhenDoOutput
Week 1Count. Put the architecture sections of every completed AI design on a wall. Count distinct shapes, distinct control decisions, and how many decisions four or more teams answered the same wayInheritance opportunity in senior hours
Week 2Pick three, write one properly. Usually families 1, 2 and 4. Write one fully (composition, policy pack, templates, evaluation signals, anti-patterns, named owner). Do not start the second until the first has an instanceOne instantiable family
Week 3Change the intake form. Replace “describe your architecture” with two fields: which family is this nearest to and what is different about it. Add the classification-to-route table as a read-only consequence of the declared dataDelta-only intake
Quarter 1Run the orphan check (below)Live or retired families

Delta-only intake form. Recommended fields (this page’s elaboration of the two-field rule): nearest family and version; each delta, stated as an added pattern code, added tool or write scope, changed data class, changed agency class or action scope, or a control the family does not carry; the declared data classes and flags; the hosting route (computed, read-only); owner and wrangler; human-duty hours. Everything not declared as a delta is inherited and not reviewed.

Calibrate to size (Book 2 Ch 23 §7):

FirmFamiliesOwnership
~1,000 peopleRealistically 1, 2, 4 and later 6, written in a shared document, not a portal. Scope confidential traffic against available hosting routes before startingOne named person can own all four, with time allocated
~3,000 peopleThree families in one quarter before any fourthFactory architect as arbiter; each family has a technical owner and a business counterpart; publish the control inheritance rate per family from the first instance
~50,000 peopleConverge duplicated divisional families on one central setVariants as deltas; expect roughly one genuinely new family a year

Measure inheritance per family. The control inheritance rate is the share of a product’s required controls satisfied by inherited assets rather than new build (definition on factory measurement). A family whose rate is not rising is not being inherited from; you want to know in month three.

Composite worked example (Asset Manager X, Book 2 Ch 23 §6; composite firm). Three families in one quarter, under the constraint “three, fully governed, before any fourth”:

  • Family 1 in four weeks. Shipped per-request classification at the gateway, a versioned prompt library, the AI-use disclosure component and a classified trace store with stated retention. Six weeks in, telemetry found 11% of requests carrying content the gateway classified as confidential, from users told the tool was internal-only; the gateway routed all of them correctly, which is the argument for per-request enforcement.
  • Family 2 in ten weeks. It inherited classification and routing, prompt versioning, disclosure, the trace store and harness scaffolding from family 1, and added entitlement-aware retrieval, index lifecycle with a stated propagation window, and indirect-injection screening. A little over 60% of its required controls were met by inheritance. The architecture forum took forty minutes instead of three sessions, most of it on the index lifecycle, where erasure obligations land.
  • Family 4. Lease abstraction: fourteen fields per lease, dual extraction on the four fields feeding the rent roll, thresholds set so roughly two-thirds went straight through in month one, page-and-span evidence per field, idempotent typed writes. It reused family 2’s governed store, so it needed no entitlement story of its own.

Family hygiene checks

These are the failure modes the catalogue must detect by construction (source claims, Book 2 Ch 23 §7–8; check specifications marked as this page’s recommendation).

Family drift: the pipeline check

Failure. An instance acquires a write tool for a good reason, then another, and becomes a bounded task agent still running under family 2’s pack, which has no tool allow-list, budgets, approval gate or kill switch.

Prevention (source). Make the family a checked field: a write scope granted to a family 2 instance fails in the pipeline, not in a meeting. Detection (source). Compare each instance’s declared family with its release manifest: tools registered, write scopes granted, and whether the model directs control flow.

Check specification (recommendation, derived from the cards). The pipeline reads declared_family from the classification line and the release manifest, and fails the release when any row is violated:

Declared familyFail if the manifest shows
1 content assistantAny retrieval of enterprise data, any tool, any automatic send
2 grounded assistantAny write scope; any tool beyond retrieval; agentic retrieval (KN-AGRAG)
3 structured-data analystAny write scope; query not executed under the user’s identity; sandbox with network egress
4 document pipelineModel-selected next step; writes other than through the registered typed tool
5 triage routerAny reply, resolve or close tool; labels outside the registered taxonomy
6 review checkerAny approval or publish action
7 embedded copilotAny write tool executed by the copilot; service-account identity instead of on-behalf-of
8 bounded task agentNo registered envelope; write tools without an approval route; missing budgets or kill switch
9 research crewAny write scope; no round cap; delegation to uncatalogued agents
10 department processProcess state held outside the durable workflow; approvals not encoded as workflow states; cross-department calls not via the agent gateway

Recovery. Re-fit the instance into its true family and re-inherit the correct pack. It is unwelcome and non-negotiable.

Family of one

Recognise by instance count: one instance after two quarters means a product dressed as a family, and its templates are pure carrying cost. Recover by demoting it to a product and keeping only the reusable parts, usually a control or two. A family earns its status on the second and third instance; the second instance opens that judgement rather than triggering it.

One index for ten families

Recognise by comparing the number of distinct corpora behind the retrieval store with the number of classification domains the policy defines. Fewer corpora than domains means the separation the matrix requires (domain separation at confidential, a dedicated index at strictly confidential) is no longer true. Recover through the grounding data API (data and API integration): keep one governed store and route, filter and log at the contract, rather than proliferating indexes.

The permission matrix as a wish

Recognise by sampling fifty real requests through the gateway and comparing the class it computed with the class the application declared. If the gateway computes none, you have your answer. Recover by enforcing on the request path, treating the declared class as metadata, and classifying the trace store, often the highest-class store in the estate.

Skipping to family 10

Recognise in the plan: stages with no prior instances, or a business case that only works at full scope. Recover by decomposing into per-stage families (4, 6, 8), shipping those, and assembling only when stage exception rates are boring.

Run the quarterly orphan check

Every family, every quarter, three questions: does it have an owner; has its evaluation harness run in the last 90 days; has anything been instantiated from it since the last review? A family that fails all three is a document, not a family. Retire it or reassign it, and record the decision.

Acceptance checks

  • Each published family has all six elements, a named owner and business counterpart, human-duty hours, and a last-evaluation date under 90 days.
  • The intake form asks for nearest family and deltas, and the hosting route is computed from declared data, not chosen.
  • The pipeline fails a release whose manifest exceeds its declared family’s ceiling (drift check above).
  • Control inheritance rate is published per family and trending up; instance count per family is reviewed each quarter.
  • Every pattern entry used in a classification line exists in the catalogue with forces and trade-offs; no code has been reused.
  • Change requests against families are on the platform backlog with an arbiter ruling and ADR.

Source notes and differences

  • Families versus archetypes. Book 2 Ch 23 and Research Paper 2 describe the same ten shapes with different vocabulary (see the opening note). Paper 2’s cards use processing lanes and action scope; Book 2 uses hosting routes and autonomy-ladder rungs. This page keeps Paper 2’s values inside the cards and does not convert them silently.
  • Neighbour table. Paper 2 §6.2 adds the 1/2 row; Book 2 §5.4 adds the 3/4 row. This page shows both.
  • Classification line. Book 2’s line has six values (anatomy tier, pattern family and code, agency class, risk tier, data class, reuse generation). Paper 2’s code also has six fields, but it combines layer and pattern into one field and adds action scope. See BOM and recipes for the comparison.
  • Recipe-step labels in the worked recipe and the drift-check rule table are this page’s derivation from the sources, not tables the books print.
  • Paper 2’s regulatory pointers (§4.1) are not restated here; see the regulatory map and regulatory calendar.

Source material

  • Book 2 (The AI Delivery Factory), Chapter 23, The Ten Recipe Families (§3 main idea; §4.1 what a family ships; §5 the ten families; §5.4 choosing between neighbours; §6 worked example; §7 Monday morning; §8 anti-patterns)
  • Book 2, Appendix C, The Pattern Catalogue (C.1–C.13)
  • Book 2, Chapter 22, The Shape of an AI Product (§5.2 escalation criteria; §5.4 classification line; §5.5 design record and ownership)
  • Book 2, Chapter 24, Running the Factory (§7 the factory architect as pattern arbiter; human duties of a recipe)
  • Book 2, Chapter 5, Bills of Material and Recipes (§4.3 what the recipe governs; §6 worked example)
  • DEIXEI Research Series, Working Paper 02, Ten Solution Archetypes for Regulated Finance (§2–§7)
  • DEIXEI Research Series, Working Paper 01, A Taxonomy for a Reuse-Driven AI Factory (§4.2 pattern families; Appendix A)

← All AI Delivery Factory guidance

On this page

  1. What a family must ship
  2. The catalogue
  3. Fit a request to a family
    1. Choose between neighbours
    2. Composite fits (illustrative)
    3. When a request fits none of the ten
  4. The ten design cards
    1. 1. Content assistant (class 0)
    2. 2. Grounded knowledge assistant (class 1)
    3. 3. Structured-data analyst (class 1–2)
    4. 4. Document processing pipeline (class 2)
    5. 5. Classification and triage router (class 2)
    6. 6. Review and compliance checker (class 2)
    7. 7. Embedded domain copilot (class 2–3)
    8. 8. Bounded task agent (class 3)
    9. 9. Research and analysis crew (class 4)
    10. 10. Agent-driven department process (class 4)
  5. A worked recipe: the regulated internal workflow application
  6. The pattern catalogue beneath the families
    1. How an entry is recorded
    2. The eight families and the order of preference
    3. Model interaction, knowledge and adaptation: entries with forces and factory assets
    4. Agent, integration and trust entries
    5. Reviewer rules
    6. Multi-agent patterns: who decides the next step
    7. Controls that execute
    8. Cross-reference: the CSIRO Agent Design Pattern Catalogue
  7. Staff the human duties with hours
  8. Who governs the catalogue: the pattern arbiter
  9. Adopt families: count, pick three, change the intake form
  10. Family hygiene checks
    1. Family drift: the pipeline check
    2. Family of one
    3. One index for ten families
    4. The permission matrix as a wish
    5. Skipping to family 10
    6. Run the quarterly orphan check
  11. Acceptance checks
  12. Source notes and differences

All pages in Patterns →