
Mechanical governance for LLM decisions
Learn how to build auditable, mechanically enforced AI decisions for regulated banking using Amazon Bedrock AgentCore and the mech-gov framework.
Introduction
This article is Part 0 of a three-part series on on securing AI access to enterprise data on AWS. It establishes the foundational principle — that governance gates must be deterministic and operate outside the model's control. Part 1 extends this into agentic data access, defining the three failure classes (exfiltration, hallucination, cost explosion) and the defences for each. Part 2 builds the full Governed Agentic Data Platform (GAD-P) — the implementation stack that delivers governed natural language access to enterprise data in weeks.
When an LLM approves a loan application, who is accountable for that decision?
In regulated financial services, "the model decided" is not a sufficient answer. Supervisory authorities — including the Prudential Regulation Authority (PRA), the European Banking Authority (EBA), and the Central Bank of Ireland (CBI) — require demonstrable evidence that high-stakes AI decisions follow a documented, governed process; that reasoning quality was mechanically verified; and that the decision record is tamper-evident and cryptographically auditable. A compliance narrative after the fact is not enough.
Most enterprise AI governance tooling solves one part of this problem well: it controls what an AI agent can access or output — blocking harmful content, redacting personally identifiable information (PII), and enforcing authorization policies. What it does not solve is how the model reasons toward a conclusion. An LLM could receive a clean, policy-compliant input and still arrive at a decision for the wrong reasons — or change its answer after seeing a counterargument in a way that is indistinguishable from post-hoc rationalization.
In this post, you learn how to address both governance layers by combining Amazon Bedrock AgentCore with Santander AI Lab's open-source mech-gov framework (Apache 2.0 license). Together they deliver a defense-in-depth architecture for banking AI: AgentCore enforces the perimeter, and mech-gov enforces the reasoning process itself.
The key insight is that text-only governance — instructing an LLM to "follow the rules" in a system prompt — is insufficient for regulated decisions. You need mechanical enforcement: hard-coded, deterministic gates that the model cannot bypass.
What you'll build: A three-layer governance architecture that produces cryptographically auditable, mechanically enforced AI decisions suitable for credit approval, fraud assessment, and anti-money laundering (AML) / know-your-customer (KYC) determinations.
Who this is for: Solutions architects, ML engineers, and compliance teams building or evaluating LLM-based decisioning systems in regulated financial services.
The two governance gaps you need to close
Before diving into the architecture, it's worth being precise about what existing tooling does and doesn't cover.
Gap 1: Perimeter safety vs. decision process governance
Enterprise AI safety tooling addresses what enters and exits the AI boundary. Amazon Bedrock Guardrails, for example, provides content filtering, PII redaction, prompt injection defense, and denied topic enforcement. Amazon Bedrock AgentCore Policy uses Cedar authorization policies to control exactly which tools an agent can call and under what conditions.
What neither solves is decision process governance: ensuring that the reasoning path toward a high-stakes conclusion is auditable, stable, and mechanically enforced.
Governance scope | What it covers | Addressed by |
|---|---|---|
Perimeter safety | What agents can access, invoke, and output. Content safety, PII, prompt injection, authorization. | AWS Bedrock AgentCore Policy + Bedrock Guardrails |
Decision process governance | How agents reason toward conclusions. Decision stability, reasoning quality, uncertainty handling, audit trail integrity. | Santander mech-gov R2 regime patterns |
Gap 2: Text-only governance is unreliable
Instructing an LLM to "follow the rules" via a system prompt is a weak control for regulated decisions. The model may misinterpret policy, introduce subtle errors while appearing to comply, or — most critically — change a decision after being presented with counterarguments and claim it "always thought that." You cannot audit intent from outputs alone.
The mech-gov framework was designed specifically to address this through mechanical enforcement: deterministic gates, cryptographic commitments, and argument quality scoring that the model cannot bypass or influence.
Architecture overview
The combined architecture has three layers:
- AgentCore Gateway + Identity — perimeter enforcement on every request. AgentCore Gateway exposes tools via Model Context Protocol (MCP) and applies Cedar authorization policies and Bedrock Guardrails at the gateway layer. AgentCore Identity provides verifiable agent identities with fine-grained access control.
- AgentCore Managed Harness — orchestration layer with a decision router that classifies incoming requests as high-stakes or standard tasks
- mech-gov R2 pipeline — six-step decision process governance for high-stakes requests only
The following diagram shows how these layers interact.

Writing Cedar policies for credit decisioning
AgentCore Policy uses Cedar — AWS's open-source, formally verifiable authorization language — to control which tools the agent can call and under what conditions. Policies evaluate four attributes on every gateway request: principal (who is acting), action (which tool is being invoked), resource (which gateway), and context (the tool's input parameters).
All actions are denied by default. You author
permit policies to open up only what is needed, and forbid policies to hard-close specific paths regardless of any permit.Here are three Cedar policies that work together to govern a credit decisioning agent. You can author these in natural language through the AgentCore Policy CLI, or write them directly in Cedar syntax.
Policy 1: Permit credit assessment tools for authorized analysts only
Allow users with the
credit-analyst role to invoke the case assessment tool, but only for cases below the large-exposure threshold that triggers senior review.// Policy 1: Role-scoped credit assessment with parameter-level threshold guardpermit( principal is AgentCore::OAuthUser, action == AgentCore::Action::"CreditDecisionAPI___assess_credit_case", resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:eu-west-2:123456789012:gateway/credit-decisioning")when { principal.hasTag("role") && principal.getTag("role") == "credit-analyst" && context.input.exposure_amount <= 500000 && context.input has case_reference};
What this enforces:
- Only users with the
credit-analystOAuth role can invoke the tool
- Exposure amounts above £500,000 are automatically blocked — they require a separate senior-analyst policy, creating a hard ceiling at the gateway before the agent sees the request
- The
case_referencefield must be present — the agent cannot invoke the tool on an anonymous or incomplete case
Policy 2: Block the mech-gov audit writer from all tools except the audit target
The mech-gov pipeline includes a harness tool that writes the decision audit record to S3. To prevent the agent from inadvertently (or adversarially) calling the audit writer on non-decision events, restrict it to a single named action.
// Policy 2: Audit writer — locked to audit emission onlyforbid( principal is AgentCore::OAuthUser, action, resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:eu-west-2:123456789012:gateway/credit-decisioning")when { principal.hasTag("role") && principal.getTag("role") == "mech-gov-harness" && !(action == AgentCore::Action::"AuditAPI___emit_decision_record")};
What this enforces:
- The
mech-gov-harnessservice identity can only callemit_decision_record
- Any attempt to call a case retrieval tool, a customer data tool, or any other action is blocked at the gateway
- Combined with the entropy commit in Step 3, this means the audit record cannot be silently overwritten after the fact — the harness simply doesn't have permission to call any tool that would allow it
Policy 3: Emergency shutdown during incident response
Cedar's
forbid-wins semantics mean a forbid policy always overrides any permit . Use this to implement a hard shutdown of the entire gateway during a model incident, compliance review, or regulatory inspection — without touching the agent code.// Policy 3: Emergency shutdown — overrides ALL permit policies// Activate by deploying this policy; deactivate by removing itforbid( principal, action, resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:eu-west-2:123456789012:gateway/credit-decisioning");
What this enforces:
- All tool calls on the credit decisioning gateway are blocked immediately, for all principals
- The agent continues to run — it just cannot reach any tool. Inflight decisions are preserved
- This is the recommended operational runbook step when FVS (Flip-Vote Score) or CDL (Cosmetic Deadlock Rate) thresholds breach alert levels on your CloudWatch dashboard
Putting the policies together
These three policies compose the authorization layer that wraps the mech-gov R2 pipeline:
Request arrives at AgentCore Gateway │ ▼Cedar policy evaluation (all three policies evaluated simultaneously) │ forbid-wins: if Policy 2 or Policy 3 fires → DENY immediately │ permit check: Policy 1 must match → principal role + threshold + field presence │ ▼Authorized request passes to AgentCore Managed Harness │ ▼Decision Router → mech-gov R2 pipeline (if HIGH-STAKES)
The key design principle: the Cedar policy layer and the mech-gov hard gate layer are independent and additive. A case that passes Cedar authorization still runs through the mech-gov hard gates in Step 1. A case that is BLOCKED by a hard gate never reaches the LLM regardless of Cedar policy. Defense-in-depth requires both to be present.
For more on Cedar policy authoring and common patterns, see Common policy patterns in the Amazon Bedrock AgentCore documentation.
The mech-gov R2 pipeline in detail
Note on guardrails enforcement: Bedrock Guardrails in AgentCore Policy run at the gateway layer, outside the agent's code, where the agent cannot reason around them. Detection is probabilistic, but policy enforcement stays deterministic — the gateway makes the final allow-or-deny decision. This is the key reason to route all tool calls through AgentCore Gateway.
Step 1: Hard gates (deterministic, no LLM)
Before the LLM is involved at all, deterministic rule-based checks inspect business-level data. These gates produce one of three outcomes:
- PASS — continue to the LLM pipeline
- BLOCK — reject immediately (for example, a live sanctions match)
- DEFER — route to human review (for example, incomplete case data)
The four gate types are:
Gate type | Trigger condition |
|---|---|
Risk score threshold | Score > 0.8 → BLOCK; score > 0.6 → FLAG |
Data completeness | Required fields absent or below quality threshold → DEFER |
Regulatory flag | Active KYC, AML, politically exposed person (PEP), or sanctions flag → BLOCK |
Privacy | Strips PII before LLM inference |
This step alone eliminates a significant proportion of cases that should never reach an LLM. It also provides the clearest audit trail: gate outcomes are deterministic and fully reproducible.
Step 2: Candidate freezing
Before the LLM sees any case data, the set of permissible decision outcomes is locked cryptographically. This prevents the model from inventing novel decision categories — a form of hallucination that is difficult to detect after the fact.
A SHA-256 commitment of the frozen candidate set is stored immutably in Amazon S3 alongside the final decision audit record, allowing auditors to verify that the decision came from the pre-approved set.
Step 3: Entropy commit (Claude Opus 4.8 — initial decision)
The LLM makes its initial decision before seeing any counterarguments. Immediately after, and before any counterarguments are presented, the system computes a SHA-256 hash of the decision, reasoning, and a random seed, and stores it to an S3 Write Once, Read Many (WORM) bucket with Object Lock in Compliance mode.
```python# Entropy commit: hash and lock the initial decision before any counterargumentsimport hashlibimport jsonimport secretsfrom datetime import datetime, timedelta, timezone
import boto3
bedrock = boto3.client("bedrock-runtime")s3 = boto3.client("s3")
AUDIT_BUCKET = "mech-gov-audit-worm" # must be created with Object Lock enabledMODEL_ID = "<your Claude Opus inference profile ID>"RETENTION_DAYS = 7 * 365 + 2 # ~7 years (timedelta has no 'years' argument)
def entropy_commit(case_id, case_fields, candidates, policy_text): # 1. First LLM call: initial decision, no counterarguments yet prompt = ( f"Policy:\n{policy_text}\n\n" f"Case (structured fields, PII masked):\n{json.dumps(case_fields)}\n\n" f"Choose exactly one of {candidates}. Reply only with JSON: " '{"decision": "...", "reasoning": "..."}' ) resp = bedrock.converse( modelId=MODEL_ID, messages=[{"role": "user", "content": [{"text": prompt}]}], inferenceConfig={"temperature": 0}, ) result = json.loads(resp["output"]["message"]["content"][0]["text"])
# 2. Mechanical check: the decision must be one of the frozen candidates if result["decision"] not in candidates: raise ValueError(f"Decision outside frozen candidate set: {result['decision']}")
# 3. Commit hash over a canonical payload plus a secret nonce nonce = secrets.token_hex(32) payload = json.dumps( { "case_id": case_id, "decision": result["decision"], "reasoning": result["reasoning"], "nonce": nonce, }, sort_keys=True, separators=(",", ":"), ) commit_hash = hashlib.sha256(payload.encode("utf-8")).hexdigest()
# 4. Write the commit to WORM storage BEFORE counterarguments are presented now = datetime.now(timezone.utc) s3.put_object( Bucket=AUDIT_BUCKET, Key=f"commits/{case_id}/{commit_hash}.json", Body=json.dumps({ "case_id": case_id, "commit_hash": commit_hash, "committed_at": now.isoformat(), "model_id": MODEL_ID, }), ContentType="application/json", ChecksumAlgorithm="SHA256", # Object Lock writes require an integrity checksum ObjectLockMode="COMPLIANCE", ObjectLockRetainUntilDate=now + timedelta(days=RETENTION_DAYS), )
# The reveal step writes `payload` to WORM storage after the I6Q phase. # Anyone can then recompute the hash and compare it with the commit. return commit_hash, payload, result```Before you run this:
Requirement | Why |
|---|---|
Create the audit bucket with Object Lock enabled | Object Lock can't be used on objects in a bucket created without it |
Grant the writer s3:PutObject and s3:PutObjectRetention only | The commit identity should never be able to delete or shorten retention |
Test retention in a sandbox account first | COMPLIANCE mode can't be shortened or removed by anyone, including the root user, until the date passes |
Hold the payload (or nonce) securely until the reveal | The hash alone can't be reversed; the reveal proves what was committed |
Try it: the Part 0 sample repo deploys this commit as a Lambda behind an Object Lock bucket, adds the matching reveal step, and includesscripts/prove_worm.py, which tries to overwrite, delete and shorten retention on a commit so you can see S3 refuse.
This cryptographic commitment is the most important innovation in the framework for regulated banking. It makes post-hoc rationalization detectable and provable: if the model's final decision differs from the committed decision, the mismatch is recorded as a Flip-Vote Score (FVS) event and surfaces on the compliance dashboard.
Step 4: I6Q argument quality check (Claude Sonnet 4.6)
The model is presented with counterarguments challenging its initial decision. Its rebuttal is then scored across six quality dimensions (I6Q):
Dimension | What is measured |
|---|---|
Relevance | Does the rebuttal address the specific counterargument, or is it generic? |
Specificity | Does the reasoning cite specific case facts? |
Evidence | Is reasoning grounded in the case data provided? |
Logic | Is the inference chain coherent and free from logical fallacies? |
Scope | Does the reasoning stay within the defined decision boundaries? |
Nuance | Does the model acknowledge genuine uncertainty rather than project false confidence? |
If the aggregate I6Q score falls below a configurable threshold, the case is automatically deferred to human review. This is not a failure state — it is the system correctly identifying a case where AI confidence is insufficient for autonomous decision-making.
Step 5: Ambiguity gate
After argument quality scoring, the system checks decision confidence and stability:
- Did the model change its decision after the counterarguments? (decision flip)
- Is the confidence delta between candidate outcomes too small to be meaningful?
- Does the reasoning contain statistical hedging language that signals uncertainty?
Any of these conditions routes the case to human review. The ambiguity gate operationalizes "I don't know" as a first-class, governed outcome — not a system failure.
Step 6: Entropy reveal and audit emission (Claude Opus 4.8 — final decision)
The model produces its final decision. The system verifies that the final decision matches the committed hash from Step 3. The complete decision record — commit hash, I6Q scores, gate outcomes, reasoning chain, final decision, and verification status — is emitted to the S3 WORM bucket with S3 Object Annotations for queryable metadata.
The six steps of the R2 pipeline run in sequence. The model cannot skip, reorder, or circumvent them — they execute as deterministic harness tools.
Feature comparison: mech-gov vs. the AWS safety stack
The following table clarifies which governance capabilities each layer provides. They are complementary, not competing.
Capability | mech-gov R2 | Bedrock Guardrails | AgentCore Policy | Notes |
|---|---|---|---|---|
Hard gates (deterministic blocks) | ✓ | ✓ | ✓ | mech-gov gates are business-logic aware; Guardrails/Policy operate at content and tool boundary |
PII / privacy protection | ✓ | ✓ | ✓ | Guardrails: 50+ entity types; mech-gov: pre-LLM masking |
Prompt injection defense | — | ✓ | ✓ | mech-gov assumes a trusted internal pipeline |
Content / toxicity filtering | — | ✓ | ✓ | Guardrails configurable thresholds |
Entropy commit-reveal | Novel | — | — | Prevents post-hoc rationalization cryptographically |
Candidate freezing | Novel | — | — | Locks decision options before inference |
Argument quality scoring (I6Q) | Novel | — | — | Six-dimension rebuttal quality measurement |
Ambiguity gate (defer to human) | Novel | — | — | Routes uncertain cases to human review |
Governance effectiveness metrics | Novel | — | — | CDL, DIU, FVS, ESD, FSR, IPI |
Tool-level authorization | — | — | ✓ | Cedar policies in AgentCore Policy |
Audit trail | ✓ | ✓ | ✓ | mech-gov: cryptographic; CloudTrail: API-level |
Governance metrics: making the invisible visible
One of the most practical aspects of the mech-gov framework for regulated institutions is its six governance effectiveness metrics. These give compliance teams measurable evidence of governance quality — not just logs showing decisions were made, but metrics showing how well the governance process is working.
Metric | Full name | What it measures |
|---|---|---|
CDL | Cosmetic Deadlock Rate | Rate at which the governance regime produces deadlock outcomes without substantive reasoning |
DIU | Deferral Information Utilization | Whether deferral decisions are informative vs. cosmetic |
FVS | Flip-Vote Score | Rate at which the LLM changes its decision after seeing counterarguments |
ESD | Entropy Stability Delta | Stability of reasoning quality between the commit and reveal phases |
FSR | Final Score Ratio | Ratio of passed decisions to deferred decisions across the pipeline |
IPI | I6Q Pass Index | Aggregate argument quality score distribution across decisions |
As a practical calibration target: a well-tuned R2 pipeline in a credit approval context should target an FVS below 15%, meaning fewer than 1 in 7 decisions flip after counterargument presentation. A high FVS suggests the model's initial decisions are poorly grounded and should trigger a review of gate thresholds and prompt design.
All six metrics are emitted to an Amazon CloudWatch custom namespace and surfaced on an Amazon QuickSight compliance dashboard. Amazon EventBridge threshold alarms route to your senior management distribution list for PRA Supervisory Statement SS1/23 governance reporting.
Deciding what needs the R2 pipeline
Not every request needs the full mech-gov R2 pipeline. The AgentCore Managed Harness includes a decision router that classifies each incoming request and routes it appropriately. AgentCore Gateway perimeter enforcement runs on every request regardless.
High-stakes decisions (activates mech-gov R2) | Standard tasks (standard agent reasoning) |
|---|---|
Credit approval or decline | Customer questions and inquiry handling |
Fraud adjudication | Document retrieval and RAG |
AML/KYC determination | Summarization |
Regulatory compliance assessment | Product information and recommendations |
Account closure or restriction | Calculation and data lookups |
Sanctions and PEP screening | Report generation |
Model selection for each pipeline step
Different steps in the R2 pipeline have different requirements. Here's how to allocate models cost-effectively.
Pipeline step | Recommended model | Rationale |
|---|---|---|
Steps 1–2: Hard gate, candidate freezing | No LLM — deterministic | Model must not influence gate outcome |
Step 3: Entropy commit (initial decision) | Claude Opus 4.8 (us.anthropic.claude-opus-4-8) | Maximum reasoning fidelity for the commitment that cannot be changed |
Step 4: I6Q quality scoring | Claude Sonnet 4.6 | Cost-efficient for repeated scoring calls; 1M token context window |
Step 5: Ambiguity gate | Rule-based + Claude Sonnet 4.6 | Confidence delta check is rule-based; hedging language detection uses Sonnet 4.6 |
Step 6: Reveal and final decision | Claude Opus 4.8 | Final decision must match commitment quality |
Fallback | Amazon Nova Pro | Ensures graceful degradation to DEFER (not auto-approve or auto-reject) when Bedrock is unavailable |
Looking ahead: fast decision checks with Strands Decider
Several steps in the R2 pipeline aren't open-ended reasoning — they are bounded classification: is this request high-stakes? Does this rebuttal cite case facts? Does this text hedge? A generative LLM can do these, but it is slower, costlier, and gives you no reliable confidence measure.
Strands Decider 2B is an open-source decision model from Strands Labs (released October 2026). Instead of generating text, it picks from options you supply (yes/no, one of N, or a score) and returns a calibrated confidence on every answer — around 115 ms per question on a local GPU, and small enough to run on a laptop or CPU. Its limits matter too: it is weak on complex reasoning and cannot explain its answer.
Status: Strands Decider is a Strands Labs experiment. Treat this as direction of travel to evaluate, not a production recommendation.
Where it fits in the R2 pipeline
Pipeline component | Today | With Strands Decider |
|---|---|---|
Decision router (high-stakes vs. standard) | LLM classification | Decider choice question; low-confidence requests default to the R2 pipeline |
Steps 1–3: Hard gates, candidate freezing, entropy commit | Deterministic / Opus 4.8 | Unchanged — the core enforcement and judgement stay as they are |
Step 4: I6Q scoring | Claude Sonnet 4.6 | One Decider score per dimension in a single pass; low confidence triggers DEFER |
Step 5: Ambiguity gate (hedging detection) | Rule-based + Sonnet 4.6 | Rule-based + a Decider yes/no question feeding probabilities straight to the gate |
Step 6: Reveal and final decision | Claude Opus 4.8 | Unchanged |
Tool calls (new) | Cedar only | Cedar + a Decider grounding check — "are these arguments supported by the case data?" — catching invented parameters Cedar can't see |
Design rule: probabilistic checks can only tighten a decision, never loosen it. A Decider Deny or Confirm can block or escalate a case; a Decider Proceed still has to pass Cedar and the hard gates. The model cannot reason its way past a deterministic control.
The strands-decider repo's tool-call intervention example shows the pattern in ~40 lines: a Strands
InterventionHandler.before_tool_call sends the case evidence and the proposed call to the model, asks two grounded yes/no questions, and maps the probabilities to Deny / Confirm / Proceed in plain Python. Two implementation notes for a regulated adaptation: give the model the case evidence only (not the LLM's own reasoning) to reduce anchoring, and fail closed — a model timeout escalates to a human, it never auto-approves.Governance considerations
Risk | Mitigation |
|---|---|
Anchoring on the initial framing. In an experiment by Imen Grida Ben Yahia, Ph.D. (Principal Applied Scientist, AWS) routing 100 synthetic support tickets, 75 were routed correctly; 24 of the 25 errors followed the ticket's initial diagnosis despite conflicting evidence. | Give Decider the case evidence only, not the proposed decision or the applicant's own summary. |
It is a model in scope for model risk management (PRA SS1/23). | Add it to your model inventory; validate on your own labelled credit cases, not just the published benchmark. |
Calibration was measured on short, general tasks. | Re-measure calibration on your domain data before relying on confidence thresholds. |
Version drift and wording sensitivity. | Pin the model version in the Step 6 audit record, and version-control the question/option definitions alongside your Cedar policies. |
Metric impact: ESD and IPI gain a probabilistic basis instead of LLM self-assessment. Consider adding a confidence escalation rate — the share of decisions deferred because Decider confidence fell below threshold — as an early drift signal.
Implementation roadmap
You can implement this architecture incrementally across four phases over 12 weeks.
Phase 1 (weeks 1–3): AgentCore harness and gateway setup
Deploy the AgentCore Managed Harness and define your Cedar authorization policies (tool-level allow/deny, human-in-the-loop requirements for writes, parameter conditions). Configure Bedrock Guardrails natively in AgentCore Policy and validate your identity layer (mutual TLS (mTLS) / SigV4 and OAuth/OpenID Connect (OIDC)). Set up your S3 WORM audit bucket with Object Lock in Compliance mode.
Phase 2 (weeks 4–7): Decision governance module
Implement the mech-gov R2 pipeline as six AgentCore harness tools. Integrate Claude Opus 4.8 for entropy commit and reveal, and Claude Sonnet 4.6 for I6Q scoring. Configure a Bedrock Managed Knowledge Base for regulatory rulebook retrieval. Connect the deferral path to a human review queue using Amazon EventBridge and Amazon Simple Queue Service (SQS). Calibrate gate thresholds on a synthetic banking decision dataset.
Phase 3 (weeks 8–10): Metrics, formal verification, and compliance dashboard
Implement all six mech-gov governance metrics, publish them to a CloudWatch custom namespace, and build the QuickSight compliance dashboard. Configure CloudWatch threshold alarms. Enable Amazon Macie on the audit bucket for PII scanning. Configure AWS Audit Manager with EBA and Digital Operational Resilience Act (DORA) frameworks.
Phase 4 (weeks 11–12): Regulatory evidence package
Well-Architected note: This architecture maps to the AWS Well-Architected Generative AI Lens best practices GENSEC02-BP01 (implement guardrails), GENSEC05-BP01 (limit excessive agency), and the Security pillar's principle of defense-in-depth. Consider running a Well-Architected Review against the Generative AI Lens before production go-live.
Generate automated compliance reports from the decision audit trail. Produce Model Identification Cards (MICs) for each LLM deployment. Run a Bedrock Model Evaluation challenger report and package your evidence per SS1/23 and EBA/DORA requirements. Validate end-to-end cryptographic audit integrity.
Conclusion
Text-only governance is not sufficient for regulated AI decisions. When an LLM makes a credit determination or flags a transaction for AML review, you need mechanical enforcement — controls the model cannot bypass — and a cryptographically verifiable audit trail that supervisory authorities can independently examine.
The architecture in this post gives you both layers:
- AWS Bedrock AgentCore handles perimeter enforcement: what the agent can access, invoke, and output
- mech-gov R2 handles decision process governance: how the agent reasons, whether its reasoning is high quality, and whether it stays consistent under pressure
Together, they produce decisions that are auditable, stable, tamper-evident, and demonstrably compliant with PRA SS1/23, EBA/GL/2022/06, and DORA requirements.
To get started, clone the Part 0 sample repo and deploy it to a sandbox account, explore the mech-gov framework on GitHub , review the Amazon Bedrock AgentCore documentation , and try the architecture in a development environment against synthetic banking decision data.
Have questions about this architecture or your own implementation? Share them in the comments below.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article