Topic 04  ·  grounded in IMDA MGF for Agentic AI v1.5

Topic 04

RACI — FI calibration

An applied, financial-institution calibration of the §§2.1–2.4 scaffold

An applied calibration — read Topic 03 first

Even more of an interpretation than Topic 03. This takes the Topic 03 template — same four dimensions, same activities — and calibrates it to a financial institution, splitting IMDA’s four illustrative teams into a fuller role set organised by three lines of defence. interpretation

It is one worked example of the “map the columns to your real org” step, not a prescription. Re-derive every cell for your actual structure.

Two things make this more than guesswork. The paper’s PwC worked example already uses a granular split — Use-case owner, Technology Risk Management Team, AI Factory (≈ product/engineering), End users §2.2.1, pp.27–28 — and Topic 03’s own calibration note suggests adding “a dedicated AI Governance Office, Legal/Compliance, or DPO.” The accountability logic follows MAS MindForge interpretation: assign each row’s single A to the function with the most control over that activity — while accountability never leaves the institution.

The FI role set — three lines of defence

The deployer is the institution; internally it is split across the governing body and the three lines of defence, plus the external provider roles (unchanged from Topic 03):

Internal — by line of defence

BOARD
Board / C-suite — governing body; risk appetite & residual-risk acceptance
BIZ
Business / use-case owner — 1st line; accountable use of the use case
PROD
Product / Engineering — 1st line; build, test, run (≈ PwC AI Factory)
INFOSEC
Information Security — 1st line; front-line controls, threat defence, incident response
AIGOV
AI Governance Office — 2nd line; newer GenAI / agentic-AI risk focus
TRM
Technology Risk Management — 2nd line; independent tech-risk oversight (MAS TRM); inherited
COMP
Legal / Compliance / DPO — 2nd line; regulatory, contracts, data
USER
Users / end users — SMEs; runtime review & reliance

Provider roles — external or in-house

MDEV
Model developers — labs that build the SLM/LLM/MLLM
PLAT
Platform providers — agent build/run platforms
SYS
System providers / app developers — in-house or third-party app builders
TOOL
Tooling providers — MCP servers, APIs
VENDOR
External agentic-AI provider — not a box in IMDA’s value chain (interpretation)

Lines of defence — who executes vs who challenges. The split follows the IIA’s Three Lines Model: the 1st line owns and runs the agent, the 2nd line oversees and challenges, and the 3rd line (Internal Audit) gives independent assurance. Two distinctions matter here:

  • Information Security (1st line) vs Technology Risk Management (2nd line). INFOSEC is the front line — it executes technical controls, threat defence and incident response (“how we protect it”). TRM is independent oversight — it challenges the 1st line and runs risk assessments to test whether those controls are adequate (“why we do it”), following MAS’s Technology Risk Management Guidelines. TRM is the inherited technology-risk discipline that predates AI as a distinct concern. interpretation
  • The AI Governance Office (2nd line) is the newer function, stood up to give explicit focus to GenAI and agentic-AI risk — model behaviour, autonomy, agentic harms, AI policy, and AI-related third-party risk — as those risks become more material.

Operational risk is not shown here for simplicity; some firms run it as a separate Operational Risk Management function.

Frameworks referenced (not IMDA): the lines-of-defence structure follows the IIA Three Lines Model (2020); the technology-risk lens follows the MAS Technology Risk Management Guidelines (Jan 2021). RACI itself is defined in PMI’s PMBOK Guide (see Topic 03).

The diagram maps those roles onto the three lines of defence and shows, with an A×N badge, how many activities each is Accountable for; the providers feed in from outside the institution boundary. Click a role for its duties and the rows it owns.

The organisation by lines of defence; the A×N badge counts the activities each role is Accountable for. Click a role. interpretation
The financial institution — the deployer
Governing body
1st line — own & run
2nd line — oversee & challenge
3rd line — assurance
▲ build / provide

Where the single A lands, by dimension

1. Assess & bound the risks upfront
2. Make humans meaningfully accountable
3. Implement technical controls & processes
4. Enable end-user responsibility

3rd-line Internal Audit is shown but sits outside the matrix for width; add it as an assurance column that is I on most rows and C on governance design. interpretation

The matrix

A financial-institution calibration of the RACI, across the four dimensions. The paper has no RACI — this whole matrix is an interpretation. Click any cell.
Governance activityBOARDAIGOVBIZPRODTRMINFOSECCOMPUSER
1. Assess & bound the risks upfront §2.1
Define permitted use cases & data-access limits
CARCCICI
Use-case risk assessment (incl. system complexity & third-party)
IARRCCCI
Threat modelling / taint tracing
ICICCAII
Define agent limits — tools, autonomy, least-privilege
ICARCCII
Define agent identity & authorisation
ICCRCAII
Evaluate & accept residual risk
ARCIRCCI
2. Make humans meaningfully accountable §2.2
Allocate responsibilities across the value chain — contracts / T&Cs
IACICCRI
Define significant approval checkpoints & action boundaries
IACRCCIC
Perform runtime human approvals
IACIIR
Audit oversight effectiveness (override rate, response time)
IACRCCIC
Develop internal capabilities for adaptive governance
IARRRRRR
3. Implement technical controls & processes §2.3
Design & implement technical controls (prefer structural over prompt-layer)
ICCACRII
Pre-deployment testing (accuracy, policy, tool use, multi-agent)
IICACRIC
Gradual / phased rollout
ICARCCII
Continuous monitoring & incident response (deny-by-default, fallback)
ICIACRII
Change management & version control
ICCACCII
4. Enable end-user responsibility §2.4
End-user transparency (UI disclosure, range of actions, escalation)
CARIICC
End-user education & training
CARICIC/R
Maintain tradecraft / business continuity
CIACCIIR

Select a cell for its meaning and basis. Every row has exactly one A — but here it distributes across functions (use-case → the business owner; AI risk & governance → the AI Governance Office; security → Information Security). It still never leaves the deployer.

How the A redistributes

In Topic 03 the single A always sat with one team (the deployer’s Key decision makers). Splitting the org makes the A land with the function that has the most control over each activity:

  • BIZ — use-case appropriateness & limits, phased rollout, end-user transparency, education, and business continuity.
  • AIGOV — AI-specific use-case risk assessment, permitted-use-case policy, approval checkpoints, oversight-effectiveness audit, adaptive-governance capability, and value-chain responsibility allocation.
  • PROD — technical controls, pre-deployment testing, monitoring & incident response, change management.
  • INFOSEC — threat modelling and agent identity & authorisation.
  • BOARD — accepting residual risk against risk appetite.

TRM and COMP hold no single A here — as 2nd-line functions they consult and challenge across the rows rather than own them. Every row still has exactly one A, and accountability never leaves the institution — the A just sits with the right internal function. interpretation

MindForge alignment

Cross-reference — MAS MindForge (not IMDA text). This calibration follows MindForge’s rule: assign final accountability to the party with the most control over an action (MindForge p.128). That is exactly why the A distributes across functions here rather than sitting on one team.

For a financial institution, accountability stays with the FI regardless of build-vs-buy, and MindForge points FIs to this IMDA framework for implementation detail — so the two are complementary. interpretation

Calibrate further — FI open decisions

Decide these for your own structure rather than inheriting the defaults: interpretation

  • Add 3rd-line Internal Audit as an independent-assurance column (I / C), and decide whether BOARD or a delegated risk committee holds the residual-risk A.
  • Senior management vs board. Large or higher-risk use cases may escalate the residual-risk A from BIZ to BOARD — calibrate by autonomy tier and materiality (see Topic 03’s Dayos / MSD / OCBC tiering).
  • Where AIGOV (AI risk) and TRM (technology risk) overlap. The two risk lenses meet on the same use case — have them co-assess rather than contend, with AIGOV leading the AI-specific risk and TRM the technology-risk challenge.

Onboarding scenarios — the FI calibration

The matrix above calibrates the general scaffold. The three tables below calibrate the onboarding lifecycle — intake → due diligence → security & data → build & guardrails → testing & red-teaming → approval → deploy & monitor — for a financial institution, across the same functions and three lines of defence. interpretation

The key rule you asked for: there is always an internal corresponding party for accountability. However many external providers are in the chain, and however much work they do, the single A is always an internal function — providers only ever consult or are responsible within their remit (C / R), never A. The A lands by who has the most control:

  • BIZ — use-case intake, scope, user training & rollout.
  • AIGOV — risk-tiering, autonomy bounding, model-behaviour / bias / safety red-teaming, agentic & systemic risk, process guardrails, and behaviour/drift/agent monitoring.
  • TRM — vendor & model-risk evaluation, independent validation, supply-chain/SBOM, vendor-version & third-party governance, performance/drift monitoring, audit.
  • INFOSEC (1st line) — security & data config, provenance/weights integrity, technical guardrails, the security / injection / exfiltration / tool-misuse red-team rows, and security & abuse monitoring.
  • PROD — tech-stack, model config, RAG, the build, functional testing & deployment.
  • COMP — licence, contracts/DPA & outsourcing-regulatory review.
  • BOARD — risk acceptance & sign-off.

So when a model developer, platform or tooling provider does the work, the matching internal owner above carries the A and the provider sits as C (or C/R on contracts). Toggle the provider columns on to see the external party against its internal owner.

Scenario A · external proprietary model

Onboarding a closed vendor model (Claude / Claude Code, OpenAI / Codex, Gemini). For an FI this is squarely an outsourcing / third-party arrangement — and outsourcing the technology does not outsource accountability. You can’t validate the model, so assurance is contractual, configurational and monitoring-led; the vendor (VENDOR / MDEV / PLAT) supplies disclosures and contract terms as C / C/R, while TRM, AIGOV, INFOSEC, COMP and the BOARD hold every A.

Onboarding an external proprietary model or AI product (e.g. Claude / Claude Code, OpenAI / Codex, Google Gemini). The paper has no RACI — this whole matrix is an interpretation. Click any cell.
Governance activityBOARDAIGOVBIZPRODTRMINFOSECCOMPUSER
1. Intake & risk tiering
Register the use case, intended scope, data touched & out-of-scope uses (AI inventory)
ICAIIIII
Risk-tier & materiality assessment (incl. material-outsourcing determination)
IACICICI
Bound autonomy & define human-oversight points per action class
IACCIIII
2. Vendor due diligence & disclosures
Vendor due diligence (viability, sub-processors, certifications, concentration risk)
IIIIACCI
Review vendor model/system disclosures (model cards, limits, training-use, eval reports)
IAIICIII
Black-box model-risk evaluation vs disclosures (accuracy, bias, robustness, untestable residual)
ICICAIII
3. Security, data & tech configuration
Security review of the SaaS/embedded deployment (tenant isolation, IAM/SSO, encryption, logging)
IIICIAII
Data-protection & residency configuration (region, disable training/retention, DLP, masking)
IIICIACI
Tech-stack & integration setup (LLM gateway, SSO, secrets / key management, connectors)
IIIAICII
Model configuration & version management (version pinning, system prompts / templates, parameters)
ICIAIIII
RAG & vector-store integration (retrieval-source governance, vector access control, grounding / citation)
ICIAICII
Vendor-side fine-tuning / customisation data governance & evaluation (where the vendor offers it)
IAICCIII
4. Guardrails
Technical guardrails (input/output filters, PII/DLP redaction, injection detection, schema validation, rate limits, tool-permission scoping)
ICIAICII
Process guardrails (human-in-the-loop approval checkpoints, acceptable-use policy, segregation of duties, escalation & kill-switch procedures)
IACIIICI
5. Testing & red-teaming
Functional & user-acceptance testing on representative tasks (accuracy, fitness-for-purpose)
IICAIIIC
Red-team — prompt injection & jailbreak (direct + indirect / cross-domain)
IIICIAII
Red-team — sensitive-data exfiltration / disclosure
ICIIIAII
Red-team — model behaviour & safety (harmful / dangerous content, excessive agency)
IAIIICII
Red-team — fairness, bias & discrimination testing
IAIICIII
Red-team — hallucination, factual accuracy & robustness
ICICAIII
Security penetration test of the integration & access (APIs, auth, secrets)
IIIIIAII
6. Legal & approval
Contract / DPA & outsourcing-regulatory review (no-training, SLA, liability, audit rights, version-change notice, exit)
ICIICIAI
Risk acceptance & sign-off; board approval for material / high-impact use cases
ARCICIII
7. Deploy, monitoring & lifecycle
Controlled / staged rollout & user acceptable-use training
ICARIIIR
Monitor — security & access (anomalous authentication, infrastructure events)
IIIIIAII
Monitor — malicious-use & abuse detection (injection, jailbreak, exfiltration attempts)
ICIIIAII
Monitor — model performance & quality (accuracy, latency, cost / token)
IIIACIII
Monitor — output safety, hallucination & bias drift in production
IAICCIII
Monitor — guardrail breaches & human-override rates
IAICIIII
Monitor — vendor & model-version change (silent updates → regression re-test)
ICIRAIII
Audit logging, traceability & periodic independent review / audit
ICIIACII
Incident response, escalation & kill-switch (AI incidents)
ICCIIAII

Select a cell for its meaning and basis. Every row has exactly one A — always an internal function; external providers appear only as R or C, never A.

Scenario B · open-source / self-hosted model

Self-hosting an open-weight model makes the institution the developer-deployer — accountability sits wholly with the FI, with no vendor to share risk. The extra activities (licence clearance, provenance & weights integrity, AI-SBOM, infrastructure hardening, in-house model-risk & guardrail build, fine-tuning/adapter governance) all resolve to an internal A — mostly INFOSEC (provenance, weights, infra, guardrails), TRM (validation, SBOM, drift) and AIGOV (bias/safety, change management) — while MDEV / TOOL appear only as upstream C.

Onboarding a new open-source / open-weight model that the organisation self-hosts (e.g. Llama, Mistral, Qwen, DeepSeek). The paper has no RACI — this whole matrix is an interpretation. Click any cell.
Governance activityBOARDAIGOVBIZPRODTRMINFOSECCOMPUSER
1. Intake & licensing
Register the use case & self-hosted (developer-deployer) posture (AI inventory)
ICAIIIII
Risk-tier & materiality assessment
IACICIII
Open-source licence & acceptable-use clearance (commercial-use thresholds, restrictions, derivative terms)
ICCIIIAI
2. Supply-chain, provenance & weights
Verify model provenance & weights integrity (official source, cryptographic checksums / signing)
IIICCAII
Malware / backdoor scan of the artefact (pickle vs safetensors, LoRA / adapter vetting)
IIICIAII
Build & maintain an AI-SBOM for the model + inference stack (dependencies, quantisation tooling)
IIICACII
Weights & model-registry management (secure storage, access control, quantisation, version pinning)
IIIACCII
3. Tech stack & infrastructure
Provision the inference / serving tech stack (e.g. vLLM / Triton / Ollama, orchestration, model gateway)
IIIAICII
Self-hosting infrastructure hardening (GPU / node isolation, network segmentation, secrets, audit logging, patching)
IIICIAII
RAG & vector-system build (retrieval-source governance, vector DB security / access, chunking / embeddings, grounding, retrieval-poisoning controls)
ICIAICII
4. Customisation & guardrails
Fine-tuning / adapter (LoRA / PEFT) data governance & process
IAICCICI
Evaluate & re-validate fine-tuned / adapter variants before promotion
ICICAIII
Technical guardrails — build the org’s own (input/output filters, PII/DLP, injection detection, jailbreak resistance, schema validation, tool-permission scoping)
ICICIAII
Process guardrails (human-in-the-loop approval, acceptable-use policy, segregation of duties, escalation & kill-switch)
IACIIICI
5. Model-risk testing & red-teaming
In-house model evaluation & validation (conceptual soundness, output-based benchmarking)
ICICAIII
Red-team — supply-chain & model-integrity (backdoor / poisoning, tampered weights / adapters)
IIIICAII
Red-team — prompt injection & jailbreak (direct + indirect)
IIICIAII
Red-team — sensitive-data exfiltration / disclosure
ICIIIAII
Red-team — model behaviour & safety (harmful / dangerous content; no vendor safety layer)
IAIIICII
Red-team — fairness, bias & discrimination testing
IAIICIII
Red-team — hallucination, factual accuracy & robustness
ICICAIII
Security penetration test of the self-hosted stack (serving APIs, GPU nodes, access)
IIICIAII
6. Approval & deploy
Risk acceptance & sign-off (accountability sits wholly with the institution — no vendor to share risk)
ARCICCII
Controlled deployment, version-pin approved weights, integration / acceptance testing & rollback plan
ICIACCII
7. Monitoring & lifecycle
Monitor — security & access (infra, anomalous authentication, GPU-node events)
IIICIAII
Monitor — malicious-use & abuse detection (injection, jailbreak, exfiltration attempts)
ICIIIAII
Monitor — model performance & quality (accuracy, latency, cost, capacity)
IIIRAIII
Monitor — model & data drift (input drift, concept drift, embedding drift)
ICICAIII
Monitor — output safety, hallucination & bias in production
IAICCIII
Monitor — guardrail breaches & human-override rates
IAICIIII
Version & supply-chain change management (re-verify / re-scan / re-validate on new releases & adapters; refresh AI-SBOM; re-check licence)
IAIRCCCI
Audit logging, traceability, incident response & periodic independent review
ICIIACII

Select a cell for its meaning and basis. Every row has exactly one A — always an internal function; external providers appear only as R or C, never A.

Scenario C · integrated agentic solution + tools

A multi-provider chain — model developer, platform/orchestration provider and several tool/MCP providers inside one agent — yet the FI stays fully accountable for the whole chain. Diligence is per-provider and per-tool; the new seam-risks (tool poisoning, identity/privilege abuse, multi-agent cascades) make INFOSEC A for vetting, containment and the agentic red-team rows, and AIGOV A for systemic risk and agent-behaviour monitoring; TRM owns chain-wide third-party governance and exit; each external provider (MDEV / PLAT / TOOL / VENDOR) sits as C / C/R.

Onboarding an integrated agentic solution that bundles a model plus tools / connectors from external service providers. The paper has no RACI — this whole matrix is an interpretation. Click any cell.
Governance activityBOARDAIGOVBIZPRODTRMINFOSECCOMPUSER
1. Intake & autonomy bounding
Register the use case & agent; classify read-only vs state-changing actions (agent inventory)
ICAIIIII
Materiality assessment + bound autonomy per action class (severity × reversibility)
IACCCIII
Map the full external value chain; flag as a (material) third-party arrangement
ICIIAICI
2. Per-provider & per-tool diligence
Per-provider due diligence (model developer, platform / orchestration provider, each tooling / MCP provider)
IIIIACCI
Per-tool / MCP-server vetting & allow-listing (provenance, signing, tool-poisoning scan, vetted registry; reject unvetted by default)
ICICIAII
Embedded model-risk evaluation (fitness, hallucination, bias for customer-facing use), independent of providers
ICIIAIII
3. Architecture, identity & containment
Integration & data-flow / taint-trace review across providers (what each tool / model sees; credential flow)
IIICCAII
Orchestration tech-stack & MCP-gateway setup (central broker, secrets, logging at the seams)
IIIAICII
Least-privilege + JIT / short-lived non-human identity per tool / agent
IIICIAII
Containment / sandboxing strategy (isolate tool execution; restrict third-party agents to their own ecosystem)
ICICIAII
RAG & connector data-source governance (retrieval / tool data access, grounding, leakage controls)
ICIAICII
4. Guardrails
Technical guardrails (input/output filters, tool-call authorisation & schema validation, action-confirmation gates, rate limits)
ICIAICII
Process guardrails (human-in-the-loop approval per action class, acceptable-use, segregation of duties, escalation & kill-switch)
IACIICCI
5. Risk, testing & red-teaming
Consolidated agentic risk assessment incl. aggregate / systemic multi-agent risk (cascading failure, insecure inter-agent comms, rogue agents)
IAICCCII
Red-team — tool misuse & excessive agency (acting outside preset boundaries)
IIICIAII
Red-team — identity / privilege-escalation & confused-deputy abuse
IIICIAII
Red-team — prompt injection (direct + indirect via tools / content) & jailbreak
IIICIAII
Red-team — data exfiltration / sensitive-data disclosure across the chain
ICIIIAII
Red-team — multi-agent / systemic failure (cascading, collusion, inter-agent)
IAIICCII
Red-team — fairness, bias & model-behaviour (customer-facing actions)
IAIICIII
6. Contracts & approval
Chain-wide contracts & SLAs (data handling / residency, security, change notice, audit rights, sub-processor disclosure, liability, exit / decommissioning)
ICIICCAI
Board sign-off vs AI risk appetite for higher-materiality deployments
ARCICIII
7. Deploy & monitor
Integrated pre-deployment red-team & verification against the allow-listed toolset (cannot act outside safe boundaries)
ICIAIRII
Staged rollout (pilot → expand) with central logging of all tool / MCP calls & inter-agent messages; end-user transparency
ICCAICII
Monitor — security & malicious-use (anomalous tool calls, injection / exfiltration attempts)
ICIIIAII
Monitor — agent-action / tool-call behaviour & scope-privilege drift (kill-switch escalation)
IAICICII
Monitor — model & aggregate multi-agent behaviour, performance & drift
IAIRCIII
Monitor — guardrail breaches, human-override rates & output safety
IAICIIII
Ongoing third-party & tool governance (re-vet tools / MCP / models on updates & new sub-processors; keep allow-list & register current)
ICIIACII
Audit logging & lifecycle exit / decommissioning (revoke credentials & tool access, data disposal, replacement plan)
IIIIACCI

Select a cell for its meaning and basis. Every row has exactly one A — always an internal function; external providers appear only as R or C, never A.

Frameworks referenced (not IMDA). These onboarding tables draw on the MAS Guidelines on AI Risk Management and MAS TRM Guidelines, the NIST AI RMF + GenAI Profile, ISO/IEC 42001, OWASP LLM & Agentic Top 10s, the GovTech ARC framework, and model-risk discipline from SR 11-7. Accountability allocation follows MAS MindForge (the party with most control).


End of the R&R track. Topic 01 mapped what an agent is and where its boundaries sit; Topic 02 mapped who the parties are; Topic 03 turned that into a calibratable allocation; and this topic calibrated it for a financial institution. The natural next step is to pressure-test the matrix against one or two concrete agents — a coding assistant, a customer-service agent — and record where the A and the cells move.