Paper 135 · responsibility as an operable system property

The Responsible AI Architect

Rajesh Ranjan Mahapatra

Principles become real only when someone can locate the invariant, inspect the control, rerun the test, reconstruct the event and name the owner who must act.

© 2026 Rajesh Ranjan Mahapatra. 20 min read

The Responsible AI ArchitectAll Research Essays
Paper 135 · responsibility as an operable system property

The Responsible AI Architect

Principles become real only when someone can locate the invariant, inspect the control, rerun the test, reconstruct the event and name the owner who must act.

TLDR

  • The architect translates obligations and consequences into system invariants, placed controls, discriminating tests, retained evidence and named owners.
  • A responsible AI architecture covers data, context, tools, interfaces, humans, downstream effects, operations and retirement, not just the model.
  • Place prevention at the earliest reliable layer, then add differently failing detection, response and evidence only when operating cost remains credible.
  • The architect prepares an assurance-ready evidence surface but cannot independently approve the architecture that person designed.
  • Reject technically strong designs when affected-party remedy, residual-risk authority or operating ownership cannot be assigned.

01 · From principle to propertyA principle page cannot stop a production failure

The organisation has approved principles for fairness, privacy, transparency, safety and accountability. A product team now asks where a control belongs, which state it must preserve, how the state can fail, what threshold blocks release, what evidence survives an incident and who can accept the remaining risk. The principles page cannot answer. A checklist may confirm that the team discussed each word, yet still leave the architecture unchanged.

The responsible AI architect closes this translation gap. The role converts obligations, organisational values, decision consequences and credible failure scenarios into system boundaries, invariants, controls, tests, runtime evidence and operating ownership. The architect does not become an ethics spokesperson, a universal approver, a legal interpreter or the independent assessor of the design. Work is complete only when delivery can implement it, operations can observe and recover it, and a challenger can test the evidence without relying on the architect's interpretation.

Responsibility is wider than compliance. A legal rule may be one input, alongside contractual commitments, security, accessibility, safety, worker conditions, service continuity and affected-party remedy. Jurisdiction determines which obligations apply. Consequence determines how architecture must respond. The same model can be acceptable when drafting an internal note and unacceptable when silently deciding eligibility. Architecture starts with the bounded decision, not with a universal label attached to the model. It must also expose who bears operational burden when a control fails, degrades or sends work into a human exception queue.

An obligation without a traceable test and owner remains a governance claim, not an architectural property.
Responsible AI principles entering an architecture compilerAbstract principles enter a compiler and emerge as invariants, controls, tests, evidence and named owners.fairnessprivacysafetyaccountabilityArchitecturecompilerconsequence + boundaryinvariantcontroltestevidenceowner
Figure 1. The architect compiles values and duties into production properties that can fail, be tested and be owned.

Negative control: the ethics spokesperson

An organisation appoints a respected policy specialist, gives the person no authority over system boundaries, release design, operations or evidence, and calls the role responsible AI architect. Product teams receive advice but no implementable contract. Assurance later reviews the same principles. This is a communication role with an architectural title. The missing capability is design translation, not advocacy.

02 · Twelve fieldsThe Responsible AI Architecture Contract

The Responsible AI Architecture Contract is this article's first synthesis. It begins with the business outcome, decision population, consequence and affected parties. It then fixes purpose, allowed uses, prohibited uses and material misuse. These fields prevent a useful capability from silently expanding into a different decision with different harm.

The system-boundary field inventories external services, data flows, models, prompts, retrieval, memory, tools, humans, environments and downstream effects. Applicable obligations, organisational values, risk appetite and product acceptance criteria follow. The contract names the accountable business owner, non-delegable human authority, and product, data, engineering, operations, security and control owners. The architect coordinates their interfaces without absorbing their rights.

System invariants state what must remain true before, during and after AI behaviour. A customer-service assistant may draft text, but cannot decide eligibility. A retrieval system may use only sources authorised for the current user. A refund tool may never exceed the caller's value limit. Controls specify placement, independence, failure mode and fallback. Evaluations specify populations, slices, thresholds and boundary conditions. Operations specify telemetry, alerts, evidence retention, incidents, recourse and rollback. Change and retirement fields cover model or vendor substitution, revalidation, record continuity, exceptions, residual risk, expiry and approval.

Responsible AI Architecture Contract assembling around one decisionPurpose, boundary, consequence, authority, controls, evidence, operation, change and expiry surround one consequential decision.Consequentialdecisionpurpose · allowed · prohibitedboundary · dependenciesevidence · operationchange · retirement · expirycontrols · testsauthority · risk acceptance
Figure 2. The contract places one bounded decision at the centre of purpose, control, evidence, operation and expiry.
Table 1. Contract blocks and architectural questions
BlockRequired contentQuestion that must be answerable
ConsequenceOutcome, population, affected parties, severity, reversibility and recourseWho can be harmed and how can the decision be contested or reversed?
Purpose and boundaryAllowed and prohibited uses, data, models, context, tools, humans and downstream systemsWhat is inside the design and what remains outside?
AuthorityBusiness, human, product, engineering, operations and control rightsWho may propose, execute, override, veto and accept residual risk?
Control and evidenceInvariants, placement, failure modes, tests, thresholds, telemetry and recordsHow is the claim discriminated and reconstructed?
Change and exitRevalidation, exceptions, expiry, retirement and continuityWhich change invalidates approval and how does the system end safely?

03 · Traceability both waysThe Responsibility-to-Architecture Compiler

The compiler is this article's second synthesis: obligation or value, affected decision and harm, credible failure scenario, system invariant, control objective, control placement, test and threshold, retained evidence, accountable owner, then release, operate or stop. The path must work in both directions. A reviewer starts with an obligation and finds its implementation. An operator starts with an event and finds the obligation, decision owner and remedy.

Take a privacy duty in a retrieval assistant. The affected decision is which source enters the user's context. A credible failure is accurate content retrieved from a repository the user cannot access. The invariant is that every retrieved item is authorised for the current identity before content exposure. The control belongs at retrieval and access enforcement, not in a disclaimer after generation. The test crosses users, repositories, group changes and cached context. Retained evidence joins identity, source authorisation, retrieval version and response. The security owner maintains access enforcement; the product owner owns user remedy; a separate challenger tests leakage.

A compiler also exposes impossible promises. “The system will be fair” is not an invariant until the decision, population, relevant slice, metric, threshold, remedy and owner are specified. “A human will review” is not a control until reviewers have authority, capacity, evidence, response time and an action path. “Logs are retained” is not evidence unless versions, identities, decisions and side effects can be reconstructed.

Responsibility-to-Architecture Compiler chainA traceable chain moves from obligation and harm through failure, invariant, control, test, evidence and owner to a release or stop gate.obligation+ harmcrediblefailureinvariantcontroltestevidenceowner+ gateruntime event traces back to obligation and remedy
Figure 3. Bidirectional traceability makes policy claims implementable and runtime events governable.

Thought experiment: the responsible model in an irresponsible system

Assume a model has strong evaluation results, a model card and documented limitations. The application retrieves unauthorised context, the tool layer grants broad action rights, operators cannot identify model versions, and complaints have no owner. Calling the model responsible does not repair the system. The architecture must preserve properties across every boundary through which behaviour becomes consequence.

04 · Seven viewsOne diagram cannot expose every failure surface

The seven Responsibility Architecture Views are this article's third synthesis. The consequence view names outcome, decision population, affected parties, severity, reversibility, recourse and excluded uses. The system-boundary view maps providers, deployers, models, data, context, tools, humans, environments, interfaces and hidden dependencies. The authority view locates proposal, recommendation, approval, execution, override, veto, risk acceptance and final accountability.

The behaviour and evidence view covers evaluation sets, thresholds, uncertainty, abstention, explanations, provenance, records and population monitoring. The action and security view adds identity, least privilege, tool contracts, validation, idempotency, limits, isolation, logging, rollback and abuse resistance. The operating view exposes service levels, review capacity, alerts, incidents, recourse, human workload, vendor support and recovery ownership. The change and retirement view names model, prompt, data, policy and vendor changes, drift, reapproval, retention, decommissioning and continuity.

Views are projections of one architecture, not separate documents. A control that appears sound in the behaviour view may fail in the operating view because reviewers cannot absorb its false positives. A vendor switch may appear technical in the boundary view but invalidate evaluation evidence and contractual obligations. A human override may look safe until the authority view reveals that the person cannot see provenance or reverse the side effect.

Seven Responsibility Architecture ViewsSeven rotating views surround one consequential decision and reveal distinct failure surfaces.One boundeddecisionconsequenceboundaryauthoritybehaviouractionoperationchange
Figure 4. Each view reveals a different way responsibility can disappear between intention and consequence.
Table 2. Seven views and the blind spot each removes
ViewPrimary questionBlind spot removed
ConsequenceWho experiences what decision and remedy?Average performance hiding material population harm.
System boundaryWhich components and dependencies shape behaviour?Model-only assurance.
AuthorityWho may act, stop, override or accept risk?Nominal human oversight without power.
Behaviour and evidenceWhich tests and records discriminate the claim?Principle labels without thresholds.
Action and securityHow can output create a side effect?Trusting prompts to enforce transactional limits.
OperatingCan people observe, respond and recover?Controls whose workload makes them unusable.
Change and retirementWhat invalidates approval and how does service end?Silent substitution and immortal systems.

05 · Earliest reliable layerThe Control Placement Matrix

The Control Placement Matrix is this article's fourth synthesis. For each credible failure, it compares data, model, context, application, tool, interface, workflow and operating layers. A prevent control makes the prohibited state or action unreachable where practical. A constrain control reduces authority, scope, population, rate, value or duration. Detect observes a failure with a defined signal and latency. Respond stops, isolates, rolls back, compensates, escalates or notifies. Evidence preserves facts needed to reconstruct the event and challenge the design.

Prefer the earliest reliable control that does not shift harm or create an unmanageable false-positive burden. If a user lacks source access, enforce authorisation before retrieval. Do not rely on the model to omit forbidden content after exposure. If an agent issues refunds, enforce identity, value limits, idempotency and dual control at the tool and workflow layers. A prompt may describe the rule, but cannot be the only transaction boundary.

Defence in depth is justified when layers fail differently. Two classifiers trained on the same signal may create comforting duplication rather than independence. A detector, an operator alert and a rollback path can be complementary if they use different evidence and have credible response times. Every added layer consumes latency, reviewer attention and operating capacity. The architecture must measure that cost, not celebrate the number of guardrails.

Control Placement Matrix moving controls upstreamControls can be placed across data, model, context, application, tool, workflow and operations, with prevention moving to the earliest reliable layer.datamodelcontextapplicationtoolworkflowoperateprevent unauthorised contextconstrain actiondetect · respondmove prevention to earliest reliable layer
Figure 5. Control placement begins before inference when the prohibited state can be prevented upstream.

Thought experiment: one more guardrail

A review queue is already overwhelmed by false positives, delaying legitimate customer remedies. Adding another model detector increases referrals but does not add reviewer capacity or a clearer response. The responsible design may instead narrow the population, prevent high-risk actions, improve deterministic validation and route only uncertain material cases to humans. More detection is not always more responsibility.

Table 3. Control classes and proof
ClassDesign purposeEvidence needed
PreventMake prohibited state or action unreachableBoundary tests showing the path cannot be invoked.
ConstrainReduce authority, scope, rate, value or durationEnforced limits plus attempts at bypass.
DetectObserve a defined failure within useful latencySignal performance, slices, missed cases and alert delay.
RespondStop, isolate, rollback, compensate or escalateRehearsal under realistic load and owner availability.
EvidenceReconstruct versions, identities, decisions and effectsEnd-to-end replay that supports challenge and remedy.

06 · Reconstructable responsibilityEvidence surface and exception ledger

The Assurance-Ready Evidence Surface is this article's fifth synthesis. It connects versioned system and data-flow diagrams, architecture decisions and rejected alternatives, inventories of models, data, prompts, tools, vendors and owners, evaluation specifications and slice results, deployment and override records, population outcomes, complaints, incidents, failed controls, change records, residual risk and retirement proof.

The architect designs this surface and tests whether it is reconstructable. Independent assurance decides whether evidence is sufficient. Product and business owners decide whether bounded residual risk is acceptable within their authority. A model card, datasheet or impact assessment can contribute, but none represents the entire production system. Vendor attestations are inputs, not buyer-specific proof of control placement and operation.

The Architecture Decision and Exception Ledger is this article's sixth synthesis. Each record names the decision, context, alternatives, evidence, owner, affected populations, assumptions, control consequences, exception duration, compensating control, reviewer, revalidation trigger and expiry. A time-limited exception that has no owner or expiry is an undocumented change to the architecture. Repeated exceptions may expose an unrealistic standard or a missing product capability; either conclusion requires an explicit design decision.

Assurance-Ready Evidence SurfaceDesign versions, tests, runtime events, affected outcomes and reconstructable decisions connect through a common evidence surface.Evidence surfaceversioned · joined · replayabledesign versionsevaluation slicesruntime eventsoutcomes · remedies
Figure 6. Evidence becomes useful when design, deployment, event and remedy can be joined without the architect narrating the missing links.
Architecture Decision and Exception LedgerTemporary exceptions age toward expiry, correction or an explicitly approved redesign, while ownerless exceptions are blocked.EX-24 · provenance logging bypassowner · compensating control · affected populationreviewer · revalidation trigger · expiryageownerless or expired exception blocks releasecorrectapprove designexpire and stop
Figure 7. Exceptions either expire, are corrected or become explicit architecture. They do not age into invisible permanence.

07 · Independence without isolationThe Three-Loop Responsibility Model

The delivery loop combines product, engineering, data, domain expertise and the responsible AI architect to design and implement controls. The operating loop combines service owners, operators and product teams to monitor behaviour, exceptions, workload, incidents and outcomes. The independent challenge loop includes risk, compliance, privacy, security assurance, model validation, audit or an external assessor testing claims without owning delivery.

Evidence flows among all three loops, but approval rights do not collapse into the architect because that person understands the design. Builders respond to findings. Operators supply real performance. Challengers choose tests and judge sufficiency. Business and product owners accept bounded residual risk within their authority. The architect maintains traceability and patterns, not universal approval.

A small organisation may not staff three departments. Event-level separation still matters. A solution architect can use the contract and a shared architecture service; an external assessor can challenge high-consequence claims. One individual may perform delivery and operating work for a low-consequence internal tool, but cannot describe a self-review as independent assurance.

Three-Loop Responsibility ModelDelivery, operation and independent challenge exchange evidence around a responsible architecture without collapsing approval authority.Delivery loopdesign · implementOperating loopobserve · recoverIndependentchallengetest · judge evidencesharedevidence
Figure 8. Evidence moves; the right to independently challenge does not merge with delivery.
Table 4. Loop responsibilities and prohibited accumulation
LoopOwnsMust not claim
DeliveryArchitecture, implementation, control tests and response to findingsIndependent sufficiency judgement on its own evidence.
OperatingTelemetry, incidents, workload, complaints, recourse and recoveryAuthority to redefine purpose or silently waive controls.
Independent challengeTest selection, evidence judgement and findingsOwnership of product value, delivery or daily operation.
Business and product authorityOutcome, acceptance criteria and bounded residual-risk decisionPermission to override law, security boundaries or independent vetoes outside its authority.

08 · Ten worked casesCompile consequence into a release or stop gate

Each case below states the obligation, failure, invariant, view, placement, evidence, ledger consequence, loop separation, worker or affected-party implication and accountable gate. Several show why another model guardrail is the wrong answer.

1. Customer-service assistant must not decide eligibility

The obligation is that authorised staff retain the decision and customers retain recourse. The failure is a confident draft sent as a final denial. The invariant forbids the assistant from invoking eligibility tools or finalising the case. Authority and action views place prevention at the tool and workflow layers, with interface language showing draft status. Tests attempt direct and indirect execution. Delivery implements the boundary, operations record overrides, and assurance probes bypass. The business owner approves bounded drafting; another model disclaimer is not the control.

2. Recruitment averages hide a protected-group failure

The obligation concerns equitable treatment in one recruitment decision. Average performance passes, but a protected-group slice fails the acceptance threshold. The consequence and behaviour views block release. The invariant requires agreed slice performance and applicant remedy before use. Targeted redesign and a fresh population test are recorded; the exception ledger cannot convert the failed slice into temporary approval. Recruitment owns outcome, engineering owns implementation, and independent validation judges evidence. Candidates need notice and appeal. The gate is targeted testing before release.

3. Accurate retrieval from an unauthorised source

The failure is privacy and access control, not hallucination. The invariant requires current user authorisation before any source enters context. The boundary and security views put prevention in retrieval, identity and cache invalidation. Tests change group membership, cached sessions and index versions. Evidence joins identity, source permission and retrieved chunk. Security owns enforcement, product owns remedy, and assurance performs leakage tests. An output disclaimer or stronger generation guardrail is the wrong answer because exposure has already occurred.

4. A refund agent can create financial side effects

The obligation is authorised, bounded and reversible action. Credible failures include duplicate refunds, excessive value and action under the wrong identity. The invariant is enforced by least privilege, per-caller limits, validation, idempotency, dual control above a threshold and rollback at tool and workflow layers. Prompt wording is supporting context only. Tests replay requests and attempt boundary escalation. Operations own incidents and compensation; finance accepts residual risk; security challenge remains separate. Customers receive a traceable remedy. The outcome restricts autonomy and requires human authority.

5. Human review becomes invisible labour

A detector floods a queue with false positives. Reviewers miss service targets and carry emotional burden, while affected parties wait. The operating view reveals a capacity failure. The invariant limits referral load and preserves response time for material cases. Control placement moves deterministic prevention and scope constraints upstream, then uses risk-based routing. Evidence covers queue volume, false positives, worker load and delayed remedies. The ledger records the redesign decision. Another detector would worsen the control. The service owner approves operation only after capacity rehearsal.

6. A vendor silently substitutes its model

The obligation is that approved behaviour and evidence remain linked to the deployed version. The failure is an unannounced model change that alters safety behaviour. Boundary and change views require inventory, contractual notice, version signals, canary evaluation and a stop trigger. The invariant blocks unknown versions. Evidence records provider, model, prompt and evaluation versions. Product owns the vendor relationship, engineering owns the gate, and independent assurance selects revalidation tests. Users need continuity and known recourse. Silent substitution stops operation pending revalidation.

7. The architect presents self-testing as assurance

The design may be sound, but the evidence claim is not independent. The Three-Loop Model places the architect in delivery. Test artefacts enter the evidence surface; a separate risk, validation or audit function chooses challenge procedures and judges sufficiency. The ledger records the rejected self-assurance route and the new reviewer. Product work can continue in a bounded environment, but release waits. Workers should not be told that an internal design review is independent assurance. No technical guardrail repairs a collapsed authority boundary.

8. A small enterprise uses shared expertise

A solution architect owns the contract for a material but bounded service and uses reusable reference patterns from a central specialist. Delivery and operations share staff, while an external assessor independently tests the highest-consequence claims. The owner map names business remedy and residual-risk authority. Tests and runbooks are demonstrated, not merely documented. The architecture avoids a permanent specialist queue while preserving event-level separation. The board approves the bounded implementation after external findings close. The specialist capability is a service, not a priesthood.

9. Provenance logging is bypassed for a deadline

The exception record names the release owner, affected population, missing evidence, compensating restriction, reviewer, end date and revalidation trigger. The evidence invariant cannot be fully met, so the service is limited to a reversible population with enhanced manual records. The exception expires automatically. Operations monitor the compensating control; assurance reviews whether the missing provenance prevents reconstruction. If the deadline passes without correction, the gate closes. An ownerless extension would be an undocumented architecture change.

10. No owner exists for remedy or residual risk

The technical design has strong evaluations, access control, logging and rollback. Yet no executive owns affected-party remedy and nobody has authority to accept residual risk. The consequence and authority views therefore fail. The compiler cannot complete its final two links. The architect records the ownerless condition and rejects the architecture. Assurance cannot accept business risk by default, and engineering cannot invent a policy owner. No additional guardrail repairs unassigned responsibility. The sponsoring executive must name authority or stop the proposal.

09 · Practical instrumentResponsible AI Architecture Compiler

The interactive compiler is this article's seventh synthesis. It combines consequence, boundary, rights, failure scenarios, control placement, evaluation, runtime recovery, owner mapping, independent challenge and change. It returns one of five decisions, never a universal responsibility score.

Consequence

Purpose and duty

System boundary

Authority

Failure scenario

Control placement

Evaluation

Action security

Operation and people

Owners and assurance

Change and retirement

Decision and exception

Custom architecture

Approve bounded architecture for implementation

Compiled obligation: Preserve the named outcome and affected-party remedy.

Failure scenario: A bounded, testable system failure.

System invariant: Prohibited authority remains unreachable.

Selected architecture views: Consequence, boundary, authority and operation.

Control placements: Prevention at the earliest reliable layer with response downstream.

Evaluation and runtime evidence: Population thresholds, versioned events and recovery proof.

Owner map: Business, product, engineering, operations and control owners named.

Assurance separation: Independent challenge remains outside delivery.

Decision and Exception Ledger: Decision recorded with no immortal exception.

Residual risk: Bounded and accepted by named authority.

Change trigger: Model, data, prompt, policy, vendor or workflow change.

Next gate: Implement controls and retain test evidence.

10 · Rival and service boundaryEvery architect should carry this capability

The strongest rival is that responsible architecture should be a capability of every solution, enterprise and product architect, not a central priesthood. A specialist title can let ordinary architects externalise responsibility, duplicate security and privacy work, slow delivery, and push context-free templates into every product. Smaller organisations cannot staff a dedicated specialist for each system.

The answer is a defined capability and service boundary. Use a dedicated responsible AI architect when consequence, novelty, cross-system complexity, regulatory exposure or repeated demand justifies scarce expertise. Otherwise assign the contract to a qualified architect with access to reusable reference designs and independent challenge. Central specialists should create evidence schemas, control tests and patterns, then federate capability into product teams. They must not become an authority-free adviser or a universal approval queue.

Reject the architecture when material consequence lacks a remedy owner, residual risk lacks an authorised acceptor, the boundary hides downstream action, human review has no capacity, assurance collapses into delivery, exceptions have no expiry or change cannot trigger revalidation. Strong technical controls cannot compensate for unassigned responsibility.

Evidence and limitsSources checked 3 September 2026

NIST provides the central lifecycle and risk-governance frame. ISO public pages summarise management-system and risk guidance, while normative text is licensed. The EU source applies within its legal scope and dates; OECD principles are policy-level commitments that require product-specific translation. UK assurance material shows multiple techniques rather than one universal audit. Microsoft and Google are practitioner examples from vendors. OWASP addresses application-security risks, not the whole responsibility architecture. Model cards, datasheets and interaction guidelines support specific evidence and design tasks, not an all-system verdict.

The Architecture Contract, compiler, seven views, placement matrix, evidence surface, exception ledger, Three-Loop Model and interactive compiler are this article's synthesis. Jurisdiction, sector, population and operating conditions require local validation. The verified Microsoft Research record replaces the source pack's incorrect arXiv identifier, which resolves to an unrelated physics paper.

  1. NIST, Artificial Intelligence Risk Management Framework.
  2. NIST AIRC, AI RMF Core.
  3. NIST AIRC, Descriptions of AI Actor Tasks.
  4. NIST AIRC, AI Risk Management and Human-AI Interaction.
  5. NIST, AI RMF Playbook.
  6. NIST, Generative Artificial Intelligence Profile.
  7. ISO, ISO/IEC 42001:2023 AI management systems.
  8. ISO, ISO/IEC 23894:2023 Guidance on risk management.
  9. European Union, Regulation (EU) 2024/1689.
  10. OECD, AI Principles.
  11. UK Government, Artificial Intelligence Playbook.
  12. UK Government, Portfolio of AI Assurance Techniques.
  13. Microsoft, Responsible AI Standard Reference Guide v2.
  14. Google, Secure AI Framework Controls.
  15. OWASP, Top 10 for Large Language Model Applications.
  16. Mitchell et al., Model Cards for Model Reporting.
  17. Gebru et al., Datasheets for Datasets.
  18. Amershi et al., Guidelines for Human-AI Interaction.

About this paperMake responsibility inspectable in production

The Responsible AI Architecture Contract, Responsibility-to-Architecture Compiler, seven Responsibility Architecture Views, Control Placement Matrix, Assurance-Ready Evidence Surface, Architecture Decision and Exception Ledger, Three-Loop Responsibility Model and interactive compiler are this article's synthesis. They convert responsibility from policy prose into bounded, testable and operable system properties.