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

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):
| Element | What it contains | Acceptance check |
|---|---|---|
| Pattern composition | The coded patterns it is built from and how they connect (catalogue below) | Every component’s classification line names a code |
| Policy pack | The pre-approved control bundle for the shape: constraints at management-group scope, pipeline checks, per-request gateway decisions | Each control is enforced by a machine, not described in a design document |
| Templates | Repositories, pipeline definitions, infrastructure modules, evaluation-harness scaffold, design-system disclosure components, on top of the standard application foundation | A team can instantiate the family without writing plumbing |
| Evaluation signals | The family’s own metrics, named in advance, with golden records to measure against | No single “accuracy” number; the signals per card below |
| Default agency class and ceiling | The class from the product-shape guide. The class is a ceiling, not a target | The pipeline rejects an instance that exceeds the ceiling (drift check) |
| Known anti-patterns | Written from the firm’s own history and published catalogues | Present 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
| # | Family | Class | Pattern composition (Paper 2 §4) | What it brings |
|---|---|---|---|---|
| 1 | Content assistant | 0 | MI-TMPL, MI-STRUCT, IN-GW | Output guardrails, AI-use disclosure, prompt library, trace retention |
| 2 | Grounded knowledge assistant | 1 | KN-RAG+, KN-PERM, KN-CITE, IN-GW | Entitlement-aware retrieval, citation enforcement, groundedness evaluation |
| 3 | Structured-data analyst | 1–2 | KN-SQL, MI-STRUCT, AG-CODE (sandboxed) | Semantic-layer binding, query validator, row-level security, visible query |
| 4 | Document processing pipeline | 2 | WF-PIPE, MI-STRUCT, WF-PAR-VOTE, WF-HITL | Extraction schemas, confidence thresholds, exception queue, source-span evidence |
| 5 | Classification and triage router | 2 | WF-ROUTE, MI-ROUTE, IN-EVENT | Fixed label taxonomy, escalation rules, misroute feedback, routing audit log |
| 6 | Review and compliance checker | 2 | WF-EVAL, WF-PAR-VOTE, KN-CITE | Quote-and-cite per finding, rulebook versioning, no automatic approval path |
| 7 | Embedded domain copilot | 2–3 | IN-EMBED, KN-RAG+, AG-TOOL (read-only) | On-behalf-of identity, read-only default, actions as buttons the user presses |
| 8 | Bounded task agent | 3 | AG-BOUNDED, AG-PLAN, IN-MCPGW, WF-HITL | Dedicated identity, tool allow-list, budgets, approval before action, kill switch |
| 9 | Research and analysis crew | 4 | MA-HIER or MA-SUPER, KN-AGRAG, AG-REFLECT | Source allow-lists, provenance per claim, round and cost budgets, analyst ownership |
| 10 | Agent-driven department process | 4 | MA-SEQ / MA-SUPER, IN-A2AGW, IN-ASYNC, WF-HITL | Workflow-held state, workflow-enforced approvals, per-agent wrangler, replay testing |

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
- Start from the task and outcome, not the requested model or “agent”.
- 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).
- Find the agency class with the product-shape guide; every step up needs the evidence listed there.
- Pick the family within that class. If two are plausible, use the neighbour table.
- Decompose compound requests. Most “an agent that handles X” requests are several families in sequence.
- Let the data class, not the family, decide the hosting route (data classes and lanes).
- 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 between | Take the simpler one unless |
|---|---|
| 1 content assistant / 2 grounded assistant | The answer depends on facts the user did not supply |
| 2 grounded assistant / 9 research crew | Questions routinely need planning across many sources and a synthesised report |
| 3 structured-data analyst / 4 document pipeline | The inputs are documents rather than governed tables |
| 4 document pipeline / 8 bounded task agent | Documents vary so much that the processing steps cannot be fixed in advance |
| 5 triage router / 8 bounded task agent | Resolving the request, not only routing it, is genuinely in scope |
| 7 embedded copilot / 8 bounded task agent | The task spans several systems and cannot be completed inside the host application |
| 8 bounded task agent / 10 department process | Several 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):
| Request | Fit | Lesson |
|---|---|---|
| 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 later | Start 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 = 1 | None 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 defined | The 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):
- 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.
- Check it is a generative-AI problem at all (step 2 above).
- 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.
- 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.
| Aspect | Design |
|---|---|
| Use / avoid | Self-contained task the user judges / any answer that depends on facts the user did not paste (the most common misuse) |
| Scope | Draft only |
| Data and lanes | C1–C2 any lane; C3 on Lane B or C; C4 only on Lane C |
| Controls | Input classification, AI-use disclosure, no retention of pasted content beyond the trace policy, style and brand guardrails |
| Evidence | Gateway trace per call: user, template version, model, data class, lane |
| Evaluation | Task rubrics (summary faithfulness, translation quality), user feedback |
| Anti-patterns | Factual 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.
| Aspect | Design |
|---|---|
| Use / avoid | Knowledge in documents, answerable from a few passages / arithmetic over tables (3), synthesis across many sources (9) |
| Scope | Read-only |
| Data and lanes | C3 indexes separated by domain on Lane B or C; C4 corpora need a dedicated index on Lane C |
| Controls | Entitlement propagation, citation enforcement, answer-only-from-context instruction, document validity filters, indirect-injection screening of ingested content |
| Evidence | Per answer: question, user identity, source IDs retrieved, citation-check result. Per index: ingestion log with document class and validity |
| Evaluation | Retrieval recall and precision on a golden question set, groundedness, citation accuracy, refusal quality on out-of-scope questions |
| Anti-patterns | One 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.
| Aspect | Design |
|---|---|
| Use / avoid | Metrics defined and users need ad hoc cuts / metrics undefined or disputed: fix the data product first, or the interface industrialises the dispute |
| Scope | Read-only; class 1 for single queries, class 2 for a fixed query–validate–analyse chain |
| Data and lanes | Results inherit the data product’s class; C3 on Lane B or C; the model sees schema and aggregates, not bulk rows, wherever possible |
| Controls | Query allow-list, row- and column-level security, cost and row limits, sandbox without network egress, the executed query always shown |
| Evidence | Executed query, data timestamp, generated code and its output, validator decisions |
| Evaluation | Execution accuracy on a golden question-and-answer set, validator rejection rate, agreement with trusted reference reports |
| Anti-patterns | Text-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.
| Aspect | Design |
|---|---|
| Use / avoid | Known document types, output specifiable as a schema / each document needs its own investigation path (8) |
| Scope | Act with approval for writes; autonomous writes only above a validated confidence threshold for low-risk fields |
| Data and lanes | Onboarding files and contracts typically C3 with personal or client-identifying flags (Lane B or C); medical evidence handled at C4; masked samples for development |
| Controls | Schema validation, field-level thresholds, dual extraction, review queue with a service level, source-span evidence, idempotent writes |
| Evidence | Document hash and registration, source span per field, reviewer corrections, weekly sampling results |
| Evaluation | Field-level precision and recall per document type, straight-through rate, reviewer correction rate, drift by source |
| Anti-patterns | One 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.
| Aspect | Design |
|---|---|
| Use / avoid | High volume, stable labels, several handlers / low volume, or labels that change weekly |
| Scope | Assigns and tags only; never replies or resolves |
| Data and lanes | Inbound mail may contain anything: classify before any external lane; default Lane B or C for client mailboxes |
| Controls | Fixed taxonomy, mandatory escalation rules, misroute feedback loop, audit log of every routing decision |
| Evidence | Per item: labels, confidence, rule applied, destination; human triage decisions; misroute corrections |
| Evaluation | Per-label precision and recall; misroute rate and share sent to human triage, read as a pair; time to first handler |
| Anti-patterns | Model-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.
| Aspect | Design |
|---|---|
| Use / avoid | Rules can be written down and the reviewer stays accountable / inherently subjective judgement with no rulebook |
| Scope | Advisory only; the human decides |
| Data and lanes | Usually C2–C3; unpublished product or deal information may carry the inside-information flag (Lane B or C) |
| Controls | Quote-and-cite per finding, rulebook versioning, reviewer sign-off, no automatic approval path |
| Evidence | Rulebook version, every finding with quote and rule, reviewer decision per finding, reviewer identity |
| Evaluation | Finding precision and recall against expert-labelled drafts, acceptance share, missed-issue rate from later audits |
| Anti-patterns | Presenting 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.
| Aspect | Design |
|---|---|
| Use / avoid | Users work mainly in one system and ask about its records / tasks spanning systems end to end (8 or 10) |
| Scope | Draft or suggest, never execute; class 2 with fixed lookups, class 3 with a small read-only tool set |
| Data and lanes | Inherits the host system’s class; CRM and claims data typically C3 with flags (Lane B or C) |
| Controls | On-behalf-of tokens, read-only tools, a maximum number of tool calls per question, actions rendered as interface elements, per-application tool allow-list |
| Evidence | Every tool call with the user identity it ran under; executed actions recorded by the host application as the user’s own |
| Evaluation | Task success on scripted scenarios, tool-selection accuracy, latency, adoption and feedback in the host |
| Anti-patterns | A 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 element | Example setting (Paper 2 §5.8, a bank’s cash-reconciliation team) |
|---|---|
| Goal and scope | Investigate unmatched cash breaks on the team’s accounts and propose corrections |
| Tools | Read: ledger, correspondent statements, mailbox search. Write: create a correction proposal |
| Action scope | Act with approval for any write; no payments; no external email |
| Data scope | The requesting team’s accounts; C3 maximum |
| Budgets | At most 30 tool calls and 10 minutes, plus a token cap per run |
| Escalation | Unknown counterparty, amount above threshold, conflicting evidence |
| Identity | Dedicated least-privilege agent identity; on-behalf-of for user-triggered runs |
| Owner | Named head of the operations team |
| Aspect | Design |
|---|---|
| Use / avoid | Steps vary by case, tools exist, a human can approve the outcome / predictable steps (4 or a workflow), or irreversible high-value actions |
| Scope | Act with approval by default; autonomous only for reversible low-risk actions proven by replay tests |
| Data and lanes | Up to C3 by default; C4 only on Lane C with draft-only scope |
| Controls | Envelope enforcement, tool allow-list, budgets and kill switch, sandbox for generated code, trajectory logging, prompt-injection screening of tool outputs |
| Evidence | Logged plan, full trajectory of tool calls and policy decisions, each approval and its decider, final report |
| Evaluation | Task success on scenario suites, trajectory quality (unnecessary calls, denials), approval acceptance rate, cost per task, replay results |
| Anti-patterns | A 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.
| Aspect | Design |
|---|---|
| Use / avoid | Open questions needing many sources and hours of human work / a fixed corpus answers it (2), or speed matters more than breadth |
| Scope | Read-only; the output is a draft the analyst owns |
| Data and lanes | External 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 |
| Controls | Source allow-lists, provenance per claim, per-run budgets and round limits, information-barrier checks, analyst ownership |
| Evidence | Task ledger, source behind every claim, trajectory per agent, analyst sign-off |
| Evaluation | Factual accuracy and citation support on benchmark briefs, coverage against expert reports, cost and time per report, extent of analyst edits |
| Anti-patterns | Unbounded 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.
| Aspect | Design |
|---|---|
| Use / avoid | High-volume processes spanning teams with clearly owned stages / stages not yet stable: run each as family 4, 6 or 8 first |
| Scope | Per stage, from draft to autonomous within the envelope; approvals fixed by the workflow |
| Controls | Named 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 |
| Evidence | Every transition with agent identity and version; each approval and approver; exceptions and resolution; evidence bundle per instance |
| Evaluation | Cycle time, straight-through rate, exception rate by stage, error escapes found in QA, cost per case, wrangler workload |
| Anti-patterns | One 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.
| # | Step | Kind |
|---|---|---|
| 1 | Create repositories from the sanctioned template: application, infrastructure and test automation as separate repositories | Automated action |
| 2 | Provision development, test, staging and production environments | Automated action |
| 3 | Wire identity through the enterprise provider (with the sanctioned role-mapping pattern) | Automated action |
| 4 | Establish baseline secrets in the vault | Automated action |
| 5 | Configure logging and telemetry with correlation identifiers | Automated action |
| 6 | Register the APIs | Automated action |
| 7 | Deploy the infrastructure | Automated action |
| 8 | Run the tests | Policy gate |
| 9 | Scan dependencies and infrastructure | Policy gate |
| 10 | Publish the artefacts | Automated action |
| 11 | Deploy to staging | Automated action |
| 12 | Run the acceptance checks | Policy gate |
| 13 | Require a data-domain classification before production access is granted | Policy gate |
| 14 | Obtain the change approval | Human decision, checked as a policy gate (no deploy without a valid approval record) |
| 15 | Deploy to production | Automated action |
| 16 | Publish the evidence (change decision record, deployer manifest) | Automated action |
| 17 | Update the product record | Automated 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):
| Field | What it records |
|---|---|
| Code and name | Stable FAMILY-SHORTNAME identifier and plain name |
| Context (use when) | What is true before you reach for it |
| Forces | The 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 note | What the factory ships so the second team does not rebuild it, or the constraint it imposes |
| Related entries | Alternatives 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
| Code | Family | Question | Typical class |
|---|---|---|---|
| MI | Model interaction | How do we get the right output? | 0 and above, in every product |
| KN | Knowledge and grounding | How do we give the model the right facts? | 1 and above |
| AD | Model adaptation | Do we change the model itself? | Any (orthogonal to agency) |
| WF | Workflow | How do we chain deterministic steps and model calls? | 2 |
| AG | Agent | When may the model direct its own control flow? | 3 |
| MA | Multi-agent | How do several agents cooperate? | 4 |
| IN | Integration and interoperability | How do models, agents and systems connect? | Any |
| TR | Trust, governance and operations | How 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
| Code | Pattern | Forces | Trade-off | Factory asset |
|---|---|---|---|---|
| MI-TMPL | Prompt template with system instructions | Standardisation vs flexibility | Brittle across model versions | Versioned prompt library linked to evaluation results |
| MI-FEW | Few-shot prompting | Consistency vs token cost | Exemplars drift with the domain | Exemplar sets owned by the subject-matter expert |
| MI-STRUCT | Structured output | Interoperability vs expressiveness | Too tight a schema hides uncertainty | Shared schemas for common business objects |
| MI-REASON | Extended reasoning | Certainty vs latency and cost | Reasoning traces are not an audit record | Reasoning-budget policy per use case at the gateway |
| MI-SELFCHK | Self-consistency | Accuracy vs cost | The model marks its own work | Voting and consistency utilities |
| MI-CTX | Context engineering | Completeness vs window limits and distraction | Failures are silent | Context builders, memory policies, standing context files |
| MI-CACHE | Prompt and semantic caching | Cost and latency vs freshness and isolation | Cross-user leakage if the key ignores entitlements | Caching policy at the gateway, keyed by data class |
| MI-ROUTE | Model routing and cascading | Cost vs quality | Router accuracy caps quality | Routing rules in the model gateway |
| KN-RAG / KN-RAG+ | Naive / advanced retrieval | Currency vs fine-tuning cost; recall vs number of parts | Retrieval caps answer quality; more parts to pin | Ingestion pipeline, index template, retrieval service with standard reranker |
| KN-GRAPH | Knowledge-graph grounding | Relational depth vs construction cost | Graph ownership is a data-product question | Enterprise knowledge graph as a data product |
| KN-SQL | Text-to-SQL over a semantic layer | Reach vs correctness and authorisation | A plausible wrong number is worse than none | Governed semantic layer and query tools |
| KN-AGRAG | Agentic retrieval | Coverage vs predictability | Raises the product to class 3 | Retrieval tools behind the tool broker |
| KN-CITE | Citation enforcement | Verifiability vs fluency | Shorter answers, some refusals | Citation checker in output guardrails |
| KN-PERM | Permission-aware retrieval | Confidentiality vs index simplicity | Entitlement changes must propagate | Entitlement-propagating connectors behind the grounding data API |
| KN-MEM | Long-term memory | Continuity vs privacy and poisoning | Retention and erasure duties; poisoned memory persists | Memory service with retention policy |
| AD-NONE | Off-the-shelf model (default) | Speed vs dependency | Behaviour changes unless pinned | Catalogue entry; model usage registry |
| AD-PEFT | Parameter-efficient fine-tuning | Task fit vs training-data governance | Re-tune on every base upgrade | Adapter section of the catalogue |
| AD-DISTIL | Distillation to a small model | Unit cost and sovereignty vs upfront effort | Quality ceiling set by the teacher | Distillation pipeline |
| AD-PREF / AD-CPT | Preference tuning / own model | Behavioural fit or moat vs specialist effort and extreme cost | Heavy evaluation burden; a model to defend to a supervisor | Rarely justified / out of scope for most firms |
| AD-CLASSIC | Classical or predictive ML | Determinism and explainability vs generality | A separate MLOps lifecycle | Feature 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.
| Code | Pattern | Forces | Trade-off | Factory note |
|---|---|---|---|---|
| AG-TOOL | Tool-using agent | Reach vs selection error | Selection errors grow with tool count | Tools only through the tool broker; keep the declared Means short |
| AG-REACT | Reason–act–observe loop | Adaptability vs error propagation | One bad observation contaminates later steps | Step and spend budgets enforced outside the loop |
| AG-PLAN | Plan, then execute | Oversight and coherence vs plan staleness | Plans go stale as the environment moves | The preferred agent shape: the plan is an artefact a wrangler can approve |
| AG-REFLECT | Reflection / self-critique | Quality vs cost | Bounded by the model’s own competence | Not an independent control; never counted as second-line review |
| AG-CODE | Code-executing agent in a sandbox | Exactness vs execution risk | Sandbox security is mandatory | Always paired with TR-SANDBOX; no network egress by default |
| AG-COMPUTER | Browser or computer-use agent | Legacy reach vs fragility and injection exposure | The highest indirect-injection exposure in the catalogue | Last resort behind IN-FACADE; advisory rung until replay testing says otherwise |
| AG-BOUNDED | Bounded agent: Mandate, Means, Memory, Monitoring | Usefulness vs blast radius | Envelope design effort, paid once per recipe | Mandatory; 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):
| Code | Pattern | Forces | Trade-off | Factory note |
|---|---|---|---|---|
| IN-WRAP | Wrap-once MCP server per system of record | One contract for every consumer vs the owning team’s capacity | The owner becomes everyone’s dependency; breaking changes need a major version and a migration window | Read tools separated from acting tools; a second wrapper is a contribution to the first, never a fork; the arbiter settles disputes |
| IN-MANIFEST | Manifest-driven catalogue | Catalogue currency vs manifest discipline | The catalogue is only as true as the manifests | Built by pipeline from repository manifests, never by hand; listing gated by the evaluation harness |
| IN-FACADE | Anti-corruption façade over legacy | Safety of the core vs build effort | Effort per system | The typed contract is the asset; preferred to AG-COMPUTER wherever an API can be built |
| IN-EVENT | Event-driven agents | Responsiveness vs replay and duplication | Idempotency and replay design | Every emitted result carries the evidence record of the run that produced it |
| IN-ASYNC | Long-running task with durable execution | Durability vs infrastructure weight | Needs a workflow engine and a state store | Process state lives in the durable workflow, not in the model’s context |
| IN-EMBED | Embedded copilot | Adoption vs per-application integration | Integration effort per host | Core of family 7; inherits the host’s entitlements |
| IN-SIDECAR | Guardrail or policy sidecar | Proximity of control vs operational overhead | One more component per agent | One way to implement TR-EXEC-RUN where the gateway is too far from the action |
| IN-OBO | On-behalf-of identity | Least privilege by inheritance vs token-exchange complexity | The log must still tell agent from user | Used for advisory-rung assistants |
| IN-NHI | Dedicated non-human identity per agent | Attributability vs identity lifecycle work | Agent identities need lifecycle management | Default 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.]
| Code | Pattern | Control plane | Trade-off | Risk it mitigates |
|---|---|---|---|---|
| TR-INGRD | Input guardrails: injection, personal-data and topic detection | Policy | False positives; latency per call | Goal hijack (ASI01) |
| TR-OUTGRD | Output guardrails: grounding, citation, toxicity, data-leak checks | Policy | Some valid answers blocked; verdicts hard to explain | Misinformation and leakage (no single ASI number) |
| TR-TOOLPOL | Tool allow-lists, parameter validation, typed tool contracts | Policy; registry | Contract upkeep as tools evolve | Tool misuse (ASI02) |
| TR-LEASTPRIV | Least-privilege agent identities, short-lived credentials | Identity | Credential lifecycle overhead | Identity and privilege abuse (ASI03) |
| TR-SANDBOX | Sandboxed code and browser execution | Policy | Limits what the agent can usefully do | Unexpected code execution (ASI05) |
| TR-MEMHYG | Memory hygiene: provenance, time-to-live, write validation | Policy; evidence | Shorter memory, less personalisation | Memory and context poisoning (ASI06) |
| TR-BLAST | Blast-radius caps: budgets, rate limits, circuit breakers, kill switch | Observability; approval | A cap set too low halts legitimate work | Cascading failures (ASI08) |
| TR-SPOTLIGHT | Trusted instructions separated from untrusted content | Policy | Design effort; not a complete defence | Indirect prompt injection (listed under ASI01) |
| TR-SUPPLY | Provenance checks on models, datasets, MCP servers, dependencies | Registry | Slows adoption of new components | Agentic 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:
| Rule | Check | Source |
|---|---|---|
| R1. A cache inherits the highest data class it stores. A semantic cache whose key ignores entitlements is a confidentiality incident, not an optimisation | Cache key includes data class and entitlement scope; cache store classified | MI-CACHE, C.3 |
| R2. KN-PERM is mandatory for C3 and C4 corpora | Retrieval runs under the asker’s entitlements; propagation window stated and tested | KN-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 1 | Design record shows KN-RAG+ was tried and evaluated first | KN-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 error | Design record states why AD-CLASSIC or conventional software was rejected | AD-CLASSIC, C.5 |
| R5. Multi-agent needs ownership boundaries or measured single-agent degradation, never the org chart | Evaluation results or separate owners, identities or release cycles recorded | C.8 |
| R6. Self-critique is never a control. AG-REFLECT and MI-SELFCHK do not count as review | Second-line or human review is separate from the model | C.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).
| Code | Pattern | Who decides | Factory constraint |
|---|---|---|---|
| MA-SEQ | Sequential pipeline of agents | Code | The shape of a department process once its stages are stable |
| MA-CONC | Concurrent fan-out / fan-in | Code | Merge logic is code; disagreements are surfaced, not averaged |
| MA-LOOP | Generator–critic loop | Code | Iteration and cost caps declared in the recipe |
| MA-HANDOFF | Handoff between specialists | Agents | The handoff record names the receiving agent and its wrangler |
| MA-SUPER | Supervisor / coordinator | Model | Delegates only to catalogued agents |
| MA-HIER | Hierarchical decomposition | Model, several levels | Family 9 only; advisory rung |
| MA-GROUP | Group chat / debate | Model | Round cap; output is advice to a named human |
| MA-MAGENTIC | Manager with adaptive task ledger | Model | Ledger retained as evidence; not for a critical or important function |
| MA-SWARM | Swarm / peer-to-peer | Emergent | Not used for regulated processes; listed so a proposal can be recognised and declined |
| MA-DYNSEL | Dynamic selection from a catalogue | Model plus search | Works 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 pattern | Nearest codes | Factory constraint |
|---|---|---|---|
| 1 | Passive goal creator | MI-TMPL, MI-CTX, IN-EMBED | Default; log the goal in the user’s words |
| 2 | Proactive goal creator | MI-CTX, IN-EVENT, AG-COMPUTER | Ambient capture is personal-data processing; assess before building |
| 3 | Prompt/response optimiser | MI-TMPL, MI-FEW, MI-STRUCT | One versioned prompt library, not a copy per team |
| 4 | Retrieval augmented generation | KN-RAG, KN-RAG+, KN-PERM, KN-CITE | Add entitlement-aware retrieval and citation enforcement |
| 5 | One-shot model querying | MI-TMPL, MI-DECOMP | Least-agency starting point; its drawbacks justify any step up |
| 6 | Incremental model querying | WF-CHAIN, MI-REASON, AG-REACT | Every extra query metered at the gateway; step budgets declared |
| 7 | Single-path plan generator | AG-PLAN, MI-DECOMP, WF-CHAIN | Preferred agent shape: a plan a wrangler can approve |
| 8 | Multi-path plan generator | AG-PLAN with WF-HITL; MI-SELFCHK | Each human choice is a recorded approval |
| 9 | Self-reflection | AG-REFLECT, MI-SELFCHK, WF-EVAL | Quality technique, never a control |
| 10 | Cross-reflection | WF-EVAL, MA-LOOP, calibrated model-as-judge | Critic is a different model via the gateway; one wrangler owns the outcome |
| 11 | Human reflection | WF-HITL, online feedback | The duty is recorded in the recipe and held by a named person |
| 12 | Voting-based cooperation | WF-PAR-VOTE, MA-CONC | Code counts the votes; every ballot is evidence |
| 13 | Role-based cooperation | MA-SEQ, MA-SUPER, MA-HIER, MA-HANDOFF | Each role a separate identity with a wrangler (families 9, 10) |
| 14 | Debate-based cooperation | MA-GROUP | Advisory only, round cap, transcript retained |
| 15 | Multimodal guardrails | TR-INGRD, TR-OUTGRD, TR-SPOTLIGHT, IN-SIDECAR | Built once at the gateway; every block logged with its reason |
| 16 | Tool/agent registry | IN-MCPGW, IN-A2AGW, MA-DYNSEL, TR-EXEC-REG | Run internally and enforced: no registration, no credentials |
| 17 | Agent adapter | IN-FACADE, IN-MCPGW, TR-TOOLPOL | Prefer typed, versioned tool contracts to run-time interface learning |
| 18 | Agent evaluator | Shared evaluation harness, TR-EXEC-REL | Golden 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.
| Duty | What it does | Usually held by | Failure if unstaffed |
|---|---|---|---|
| Supervisor | Takes the approvals, low-confidence results and exceptions | The wrangler | An approval queue nobody reads |
| Annotator of golden records | Says what a right answer looks like, and keeps saying it as the domain moves | The business subject-matter expert | Evaluation drifts from reality; thresholds become meaningless |
| Feedback provider | Supplies corrections that somebody actually reads | The product owner answers for the loop | The 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).
| Rule | What it means in practice |
|---|---|
| One owner | Proposals 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 request | A 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 triggers | A second consumer, duplication telemetry or a third recurrence opens a judgement; none promotes anything automatically |
| Release like any shared asset | The corpus is versioned and released through the platform backlog; reviewed at least annually, sooner when a model generation, protocol or regulation moves |
| Stable codes | A 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 drawbacks | No trade-off column, no recommendation |
| Variants as deltas | At 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):
| When | Do | Output |
|---|---|---|
| Week 1 | Count. 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 way | Inheritance opportunity in senior hours |
| Week 2 | Pick 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 instance | One instantiable family |
| Week 3 | Change 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 data | Delta-only intake |
| Quarter 1 | Run 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):
| Firm | Families | Ownership |
|---|---|---|
| ~1,000 people | Realistically 1, 2, 4 and later 6, written in a shared document, not a portal. Scope confidential traffic against available hosting routes before starting | One named person can own all four, with time allocated |
| ~3,000 people | Three families in one quarter before any fourth | Factory 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 people | Converge duplicated divisional families on one central set | Variants 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 family | Fail if the manifest shows |
|---|---|
| 1 content assistant | Any retrieval of enterprise data, any tool, any automatic send |
| 2 grounded assistant | Any write scope; any tool beyond retrieval; agentic retrieval (KN-AGRAG) |
| 3 structured-data analyst | Any write scope; query not executed under the user’s identity; sandbox with network egress |
| 4 document pipeline | Model-selected next step; writes other than through the registered typed tool |
| 5 triage router | Any reply, resolve or close tool; labels outside the registered taxonomy |
| 6 review checker | Any approval or publish action |
| 7 embedded copilot | Any write tool executed by the copilot; service-account identity instead of on-behalf-of |
| 8 bounded task agent | No registered envelope; write tools without an approval route; missing budgets or kill switch |
| 9 research crew | Any write scope; no round cap; delegation to uncatalogued agents |
| 10 department process | Process 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)
Related guidance
-
Choose the Shape of an AI ProductA 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. -
Build a Living Product Bill of Material and RecipeDescribe what an AI product contains and how the firm builds it in one versioned specification shared by pipelines, agents and assurance teams, including the classification line, readiness grades and reuse generations. -
Workflow PatternUse a workflow when code can determine the next step, even when some steps call a model: the eight workflow patterns with their forces and factory notes, why class 2 is the default, how code-orchestrated multi-agent flows stay workflows, how to codify a stable agent path down or delegate exceptions up, and a composite service-desk triage example read across frameworks and cloud pillars. -
Bounded-Agent PatternA class 3 agent lets a model choose the next step, but only inside a registered, validated and enforced envelope of Mandate, Means, Memory and Monitoring. -
The Anatomy of an AI ApplicationA six-tier view of what one AI product is made of, crossed by a trust and operations plane that attaches controls to every tier; what the factory already supplies per tier, how the anatomy maps to the six-layer product portfolio, and how to run an anatomy review. -
The Enterprise Agent Control PlaneThe firm-owned services that make every agent action identifiable, decidable, approvable and reconstructable: the ownership boundary, six planes and their contracts, the Policy Decision API with its latency budget, the persistence schema, the build sequence and the tests that show it works. -
Data Classes, Processing Lanes and TokenisationClassify every model request by its data, route it only to a processing lane the class permits, keep derived artefacts inside their source class, and treat retention, roles and tokenisation as recorded, testable decisions. -
Design and Operate the Model GatewayBuild the model gateway as the governed edge for every model call: per-client identity, per-request highest-class routing, tokenisation, pinned models, a conformant wire contract, a correlated evidence record, a tested concentration answer, and day-two cost, latency and reliability operations across two estates and three meters. -
Govern MCP Connectors Through a BrokerAdmit, tier, pin and enforce every MCP server through one registry and two enforcement points, keep tokens audience-bound, govern A2A delegation through its own registry and gateway, and expose client-facing agent channels only through the same policy layer. -
Agent-Driven DepartmentsWhat an Agent-Driven Department is and how to test for one, the six-system stack it runs and the order to build it, the measured agent share, and the consolidation boundary: what moves into the department, what stays with the CISO, CRO, DPO and the business, and the order in which to move it. -
Measure the FactoryRead usage first, then the seven-dimension scorecard; emit a served-request event that separates human from agent callers; label every reported number by evidence tier; watch the two leading numbers of a control gap; treat an unexplained sharp improvement as an alarm; and never turn a participation metric into a target. -
Run the AI Delivery FactoryOperate demand, capacity, the two worker classes, exceptions and evidence as one service: read two leading numbers, keep a handover backlog, gate construction on three conditions, run queues and alerts at agent volume, and count unused products as cost. -
Evaluate, Assure and Test Agent ResilienceDefine a versioned evaluation contract, test the trajectory and the execution boundaries, run three assurance layers into one quarterly pack, map the OWASP Agentic Top 10 to controls that demonstrably fire, bring agents into threat-led penetration testing with a five-section scope, keep a continuous cadence between formal tests, land every finding as a live control-plane artefact, and engineer recovery down to a minimal AI service level on models you host. -
Run a Discovery-Paced PortfolioHow to decide which problems become products when construction is cheap: the selection rule and its evidence, the nine-field bet card, the kill clause, a retirement recipe run before promotion, and the promotion boundary, with owners, failure modes and acceptance checks.