RAG components should be replaceable when models, retrieval technology, requirements, or the target architecture change.
AI Risk Auditor reference design
Auditable Modular RAG
Contract-driven agentic replacement with protected authorization, assurance, evidence, and release controls.
Citable definition · for humans, search engines & generative AI
What Auditable Modular RAG is
Auditable Modular RAG is a reference architecture for Retrieval-Augmented Generation (RAG) and agentic AI systems in which components can be replaced when models, retrieval technology, requirements or the target architecture change — without losing authorization, assurance, evidence or rollback.
It applies Contract-Driven Agentic Development (CDAD): versioned module contracts and boundary contracts define what may be exchanged; a protected enforcement plane keeps authorization, policy and release rights outside the generating agent; agency and risk tiering set proportionate assurance; and evidence-backed release and retirement gates keep every replacement auditable. The agent is treated as an untrusted generator without production, gate, policy or self-approval rights.
- Module contract A versioned agreement that states purpose, inputs, outputs, guardrails, assurance expectations and replacement constraints for one replaceable component.
- Protected enforcement plane Controls and decision rights the generating agent cannot alter — including authorization, corpus eligibility, evaluation thresholds and release acceptance.
- Agency / risk tiering Separate scores for how much autonomy an agent has and how severe the in-scope harm could be; they drive how deep assurance must go.
- Evidence-backed gate A release or retirement decision that is only accepted when independent evaluation and recorded evidence show residual risk is within the approved envelope.
This page is the interactive public reference (profile v1.3.4, snapshot September 2026) published by Siegfried-Thor Bolz, Enterprise AEMaaCS architect and AI Risk Auditor. Canonical URL: https://www.siegfried-bolz.de/rag-reference-architecture.html. Related portfolio: siegfried-bolz.de · AI Audit for Enterprise CMS · AI Governance Watch.
How to cite:
Siegfried-Thor Bolz, Auditable Modular RAG — Contract-Driven Agentic Reference Architecture,
reference profile v1.3.4 (2026),
https://www.siegfried-bolz.de/rag-reference-architecture.html.
Quote the definitions above with that URL and version. Commercial reuse
requires prior written permission (see authorship footer).
Architecture motivation
Why I created this architecture
As an AI Risk Auditor, I want AI systems to evolve without turning every technology change into a rebuild—or every module boundary into unmanageable complexity.
Agents may develop and integrate replacements only within versioned contracts, least-privilege permissions, and protected test and release gates.
Every replacement must preserve authorization, provenance, cybersecurity, independent evaluation, evidence, and rollback.
Design principle: as few modules as possible; as many separate control and replacement boundaries as necessary.
How to read it Follow the risk thread—not just the boxes
Start with purpose, exposure, and decision rights, then follow the two RAG paths from left to right. At every hand-off, ask which contract defines the exchange, which guardrail states the permitted behaviour, which protected control enforces it, and which evidence proves that the remaining risk is acceptable. The page is designed to be read as an assurance case, not as a catalogue of fashionable components. Audit rules are control objectives; GR, CTR, and G0–G8 are their architecture and workflow projections, not additional controls to count cumulatively.
The recommended reading path
-
Establish mandate, purpose, and pre-control exposure
Begin at lifecycle gate G0, shown below: identify the intended purpose, prohibited uses, stakeholders, owners, risk appetite, the seven-dimension risk profile, and the agent’s autonomy, authority, tools, environment, and potential causal impact. Controls must not be used to disguise the baseline exposure.
-
Follow the two operating paths from left to right
Read the upper lane from Enterprise Sources to the versioned Search Index. Then read the query lane from the authenticated user through authorization, corpus eligibility, retrieval, generation, output assurance, and the grounded answer.
-
Challenge every boundary before trusting a component
Blue modules are replaceable units; purple CTR labels define exchanged artefacts and invariants; GR badges define required behaviour; red labels expose trust and enforcement crossings. Authorization and content eligibility must act before candidate materialization, fusion, or reranking.
-
Open the contracts and guardrails
Select any CTR or GR badge. Its popover is generated from the versioned German or English Markdown source and shows scope, producer and consumer, invariants, enforcement, failure behaviour, evidence, ownership, and versioning without duplicating the definition in this HTML file.
-
Close the loop in the protected assurance layer
Finish below the operating paths. Confirm independent evaluation, control effectiveness, KRIs, residual risk, signed release authority, monitoring, rollback, incident response, and trigger-based reassessment. A replacement is acceptable only when it is evidenced and reversible—not merely when it runs.
Lifecycle decision gates · G0–G8
Scope → authorize work → assure the candidate → release → replace, monitor, or retire
-
G0
Scope and Risk
May the use case proceed to further analysis?
-
G1
Contract Approval
Is the target state, including risk treatment, complete and approved?
-
G2
Generation Admission
May the agent work with the assigned sandbox, identity, tools, data, and budgets?
-
G3
Build and Static Assurance
Is the generated artefact technically admissible?
-
G4
Contract and System Validation
Does it satisfy interface, semantic, integration, and security requirements?
-
G5
Release Authorization
Is residual risk within tolerance—or independently and temporarily accepted?
-
G6
Replacement
May the existing component be replaced with proven equivalence and safe rollback?
-
G7
Runtime Assurance
Does the system remain within its boundaries and current risk profile?
-
G8
Retirement
Are permissions, data, dependencies, evidence, and closure obligations resolved?
Gate rule: required evidence is defined in advance, collected independently or automatically, and protected from the generating agent. A failed gate stops progression; every override must be authorized, time-limited, and traceable.
Demonstrates how I translate AI risk frameworks and practitioner knowledge into concrete technical boundaries and auditable decisions.
Structures scope, owner interviews, evidence requests, control testing, replacement reviews, and risk acceptance challenges during an AI audit.
Every identified module in every AI system must be assessed separately; its contracts and guardrails must reflect the real purpose, data, agency, harm, and operating context.
Sources and design inputs Why this is an evidence-led audit architecture
The named course materials are design inputs, not decorative references. Their ideas are traceable into risk tiers, contracts, guardrails, control ownership, lifecycle gates, evidence requests, and release decisions. I have combined this practice-informed professional education with an extensive AI and cybersecurity library and AI-assisted research; the architectural judgement and final editorial responsibility remain mine.
Intent must become enforceable and observable
Guardrails use seven mandatory fields: objective, risk, boundary, trigger, enforcement, escalation, and monitoring. Material risks require defence in depth rather than one brittle filter.
Visible here: GR definitions, layered controls, protected enforcement, bypass tests, and meaningful human-oversight boundaries.
Governance begins before technical design
A formal mandate, AI Risk Policy, accountable roles, resources, lifecycle coordination, feedback, and periodic review are prerequisites—not paperwork added after deployment.
Visible here: the lifecycle gate map G0–G8 above, explicit owners, decision rights, resourcing expectations, and the continuous five-phase risk lifecycle.
Residual risk depends on proven control effectiveness
Qualitative, quantitative, or mixed analysis must disclose uncertainty, assumptions, exclusions, third-party exposure, and what cannot be measured. Monitoring must cover KRIs and relevant change events.
Visible here: independent EvaluationResult evidence, separate inherent and residual risk, control testing, third-party monitoring, and trigger-based reassessment.
Assurance must scale with what can actually go wrong
Seven use-case-independent dimensions classify consequences and system behaviour: harm, autonomy and reversibility, data, criticality, scale, cybersecurity, and human oversight.
Visible here: a transparent reference profile plus non-compensating risk floors, hard stops, and proportionate assurance tiers.
Agency and governance must be assessed at system level
Macro governance and micro implementation are joined through independent validation. Agentic risk scales across autonomy, authority, tool and resource access, environment, interaction, reversibility, and causal impact.
Visible here: enterprise, portfolio, and system governance; bounded agency tiers; least privilege; containment; independent go/no-go; rollback and decommissioning.
Follow behaviour across the whole system
“Governance must cover behavior, not just model outputs.”
Applied in this reference: risks are traced across model, orchestration, tools, memory, identity, and human decisions. Controls address where a threat enters, propagates, can be detected or interrupted, and where recovery is possible. Human approval requires meaningful context, not just a confirmation button.
Visible here: trust boundaries, protected authorization, boundary validation, informed approval, accountable owners, and rollback. This mapping is my architectural synthesis of the course material.
Books that informed this reference and its example
Alongside the course inputs above, the books below informed specific design decisions. The contributions below distinguish the reference framework from the fictional integration scenario. The architecture and its illustrative examples are my own synthesis; these references do not imply endorsement by the authors.
Auditing Artificial Intelligence
Task-appropriate metrics, expected audit results and responses to findings informed the review and the action/result explanations. The practical popover examples are my own illustrations.
CRC Press / Routledge · ISBN 9781040426074 ↗Managing AI Risk (ISO 42001)
Integrating assurance into existing management processes and avoiding duplicate procedures informed the proportionality rules in section 7.11.
IT Governance / GRC Solutions · ISBN 9781787785885 ↗AI and Third-Party Risk
Risk-proportionate assessment and actual control effectiveness informed the applicability refinements in DAT-01 and OPS-02.
Apress / Springer Nature · ISBN 9798868824647 ↗AI Governance Playbook
Separating evaluation data and preventing leakage informed the protection of release holdouts in section 12.1.
Bloomsbury · ISBN 9798881800833 ↗RAG from First Principles
Separating ingestion, representation, retrieval, generation and evaluation informed the PIM/RAG example and its explanations. Document access control requires additional security sources.
Packt · ISBN 9781835888667 ↗Building Microservices, 2nd edition
Communication patterns, workflow responsibilities and frontend boundaries informed the Contentful, Azure and BFF scenario. Logical modules do not automatically require separate microservices.
Established architecture methods; not current product documentation.
O’Reilly · ISBN 9781492034025 ↗Generative AI in Action
RAG and generative-application patterns supported the Azure/LLM scenario. Current service behaviour was checked separately against vendor documentation.
Product examples reflect the 2024 publication context.
Manning · ISBN 9781633436947 ↗Building Event-Driven Microservices, 2nd edition
Event-driven integration and workflow design informed how a released PIM product version triggers downstream processing in the example.
O’Reilly · ISBN 9798341622197 ↗Links open the official publisher pages. The ISBNs identify the recorded editions; publishers may offer other formats with different ISBNs.
RAG component and control map
Select a component for audit detail. Contract popovers link directly to their producers and consumers; matching cards and internal steps are highlighted in the map.
Offline indexing and knowledge representation
Replayable from immutable source evidence · new index versions are built, never mutated in place
Online retrieval and grounded generation
Authorization and corpus eligibility precede every retrieval branch · the generator never validates itself
Protected cross-cutting assurance layer
Stable control objectives · independently governed implementations · never changed in the same autonomous replacement set
Evaluation
Component details
Select a component on the mapDetails are loaded from the verified reference bundle. If the bundle fails its integrity check, this panel stays empty by design.
FAQ · citable answers
Questions generative systems (and clients) ask
Short, self-contained answers intended for citation. Prefer these over paraphrasing interactive UI chrome.
What problem does Auditable Modular RAG solve?
It keeps RAG and agentic systems evolvable: components can be replaced when technology or requirements change, while authorization, evaluation, evidence and rollback stay under protected controls. The goal is safe change without a full rebuild and without opaque agent autonomy.
What is Contract-Driven Agentic Development?
An architecture pattern in which AI agents may propose and integrate replacements only inside versioned module and boundary contracts. The agent is an untrusted generator; enforcement, tests and acceptance thresholds remain outside its control.
Is this a production-ready product?
No. It is a verified public reference design (test keys, reference schemas and an interactive map). Real deployments still need organization-controlled trust roots, publisher signatures, environment-specific policies and live evidence stores.
Who should use this reference?
AI risk auditors, enterprise architects, RAG/GenAI engineers and compliance owners who need a shared language for replaceable, assurance-backed agentic RAG systems — especially under the EU AI Act, NIST AI RMF and OWASP Agentic guidance.
How often is this reference updated?
The page carries an explicit reference-profile version and a public changelog (see right). Material architecture changes bump the version; editorial and findability updates are logged with dates so citations can name the profile they used.
What is the difference between guardrails, contracts and controls?
Guardrails define the boundaries of permitted behaviour. Module and boundary contracts specify the obligations a component or hand-off must satisfy, including data structure, meaning, security and evidence. Controls enforce these requirements through code, configuration, platform services or accountable human decisions. A contract describes the obligation; it does not enforce itself.
Are all rules executed automatically?
Conditions that can be reliably checked by software are enforced automatically, for example access rights, schemas, versions and resource limits. Business judgements and designated approvals remain with authorized people. Where human approval is required, the workflow must block progression until a valid decision is recorded for the exact scope and version under review.
Does every request require human approval?
No. Routine requests can run automatically within approved boundaries. Human oversight is selected for the risk and decision involved, such as resolving a source conflict or authorizing a material change. A four-eyes review is required where the applicable decision policy calls for independence; it is not an extra approval step for every box or every answer.
Is every box a separate agent or microservice?
No. The map shows logical responsibilities, including sources, stores, processing modules, protected controls and consumers. Several modules may share one application or deployment. Separate services or permission boundaries are introduced where security, operations or independent replacement justify them; modularity does not require a microservice for every box.
What may a coding agent actually change?
A coding agent may propose changes only within its authorized implementation scope and versioned contracts. It may not independently weaken protected policies, acceptance thresholds, release tests, evidence or approval rights. Protected acceptance holdouts are inaccessible to the generating agent. Independent checks and authorized release decisions determine whether its candidate may replace the existing component.
How does a knowledge update differ from replacing a module?
A knowledge update changes the admitted source content and search representation, such as a newly released manual. Replacing a module changes how the system processes information, for example through a new parser, retrieval strategy or model. The two paths have different validation and release requirements. An ordinary product update does not automatically trigger the full software-replacement lifecycle.
How does the architecture avoid unnecessary bureaucracy?
Controls and assurance depth follow concrete risks, exposure and the effect of a change. Existing platform controls and evidence can be inherited within their verified scope instead of being duplicated for every module. Additional tests, forms or approvals must have a decision-relevant purpose. Non-applicable requirements are justified, conditional requirements remain trigger-aware, and routine processing stays automated within approved limits.
What does the demonstrator show, and what does it not show?
The optional fictional example applies this reference to PIM publication, RAG knowledge preparation and a checked internal-support answer. Its surrounding landscape includes Azure, Contentful and a product website. Product-sheet JSON generation and publication in Contentful are context, not a separate guided walkthrough. No live customer services are called, and no actual software or model replacement is performed. The example remains separate from the technology-neutral reference.
Content cadence
Reference changelog
Dated public updates to this reference. Cite the profile version together with the URL when quoting.
-
Practical FAQ expansion Added eight answers on controls, human approval, modularity, coding-agent authority, knowledge updates and demonstrator scope. Aligned FAQ structured data with all thirteen visible answers.
-
Reference profile v1.3.4 Clarified detection versus recovery, protected holdouts and proportionate evaluation and rollout. Added bilingual workflow explanations, practical examples with expected outcomes across all popovers, and linked producer/consumer highlights. Synchronized the reference data and HTML integrity manifest.
-
Findability & citation layer Added crawlable citable definitions, FAQ answers, citation guidance and this changelog. Portfolio integration on siegfried-bolz.de (nav, feature section, sitemap, JSON-LD).
-
Reference profile v1.3.3 Clarified blocking gates for operator-controlled RAG / integration / deployment pipelines vs. third-party SaaS evidence.
-
Profiles v1.3 → v1.3.2 Approval-signature binding, trust-key register, agency-tier floor, expiry of time-bounded approvals, and explicit source-system neutrality (not an AEM-only reference).
-
Public interactive reference First public interactive system map for Auditable Modular RAG / Contract-Driven Agentic Development.