AI Research Library

Financial-Crime Intelligence and the Hard-SAR Constraint

Rajesh Ranjan Mahapatra

Machine intelligence should compress evidence and test competing explanations, while a deterministic authority kernel keeps the protected suspicious-activity reporting decision attributable, confidential and outside the model's power.

© 2026 Rajesh Ranjan Mahapatra. 27 min read

Financial-Crime Intelligence and the Hard-SAR ConstraintAll AI Research Library

Financial-Crime Intelligence and the Hard-SAR Constraint

Machine intelligence should compress evidence and test competing explanations, while a deterministic authority kernel keeps the protected suspicious-activity reporting decision attributable, confidential and outside the model's power.

TLDR

  1. Financial-crime intelligence earns its value by reducing the cost of finding, reconciling and challenging evidence, not by turning a fluent narrative into institutional suspicion.
  2. The mechanism is a typed separation among alerts, evidence propositions, hypotheses, recommendations, protected decisions and filing effects, with deterministic authority checks at every consequential transition.
  3. Models may rank alerts, resolve candidate entities, assemble timelines and draft cited factual summaries; an authorised person applies the applicable reporting policy and owns the decision.
  4. The hard boundary fails when human review becomes ceremonial, evidence is incomplete, detection coverage is weak or confidential filing status leaks through prompts, logs, caches or support tools.
  5. The changed design decision is to fund an evidence compiler and authority kernel before an autonomous SAR classifier, then release only after adversarial and unknown-outcome tests pass.

Three alerts, one persuasive mistake

At 09:10 on a Monday, three alerts enter separate queues for Harbour Trade Services, a fictional small importer. One marks payments to newly observed counterparties. The second marks rapid movement through a recently added account. The third detects descriptions that differ from the customer's recorded business purpose. Each alert is defensible as a request for review. None establishes why the activity occurred.

By midday, an investigative assistant has joined the alerts, found a shared director across two counterparties and produced a polished account. The prose is economical. It links the new suppliers, the rapid movement and the stale customer profile into one story of deliberate layering. A reviewer facing a large queue reads the summary first, checks two cited records and accepts the recommendation. The system is praised for compressing a three-hour case into twenty minutes.

One event was missed. The largest outward payment had been technically reversed. The supposed shared director was a common-name match with two viable identities. A registry update, recorded after the review window, showed a legitimate change in trading activity. The assistant did not fabricate a transaction. It created a causal closure that the available evidence did not earn.

The failure is easy to misname as hallucination. The deeper problem is architectural. A language model is rewarded for completing an account; an investigation must preserve unresolved alternatives. When the same component both organises the evidence and controls the protected reporting transition, narrative coherence becomes operational authority.

The central claim is that financial-crime intelligence becomes safer and more useful when it expands and compresses the evidence space, while a deterministic kernel prevents any model proposal from becoming the institution's suspicious-activity reporting decision. This is not a claim that models are incapable of useful discrimination. It is a claim about what changes when a fallible inference is allowed to cross an irreversible institutional boundary.

Part one

Suspicion is an institutional act

An alert, a case, a recommendation and a report are different objects. An alert says that a configured detector observed a condition worth examining. A case defines the people, accounts, period, sources and questions authorised for investigation. A recommendation records an investigator's considered view. A reporting decision applies a legal and institutional test. A filing is an external effect with confidentiality, timeliness and record consequences.

Collapsing these objects creates a seductive shortcut. The system treats a detector score as a case conclusion, a case conclusion as suspicion, and suspicion as permission to file. Every collapse hides a change in meaning and decision rights. The data may be identical while the authority carried by the object changes completely.

The international standard itself does not supply one universal software rule. The FATF Recommendations, last updated in June 2026, establish a framework that countries adapt to their legal and operational circumstances.[1] Recommendation 20 concerns reporting suspicious transactions, and Recommendation 21 protects confidentiality and addresses tipping-off. The applicable test, reporter, deadline, channel and protected information still come from the jurisdiction and the institution's approved policy.

Official national material exposes the decision character. In the United States banking context, the FFIEC manual says the final decision maker should have authority, decisions should be documented, and filing is an inherently subjective judgement.[2] In the United Kingdom, the National Crime Agency describes SARs as intelligence reports rather than crime reports and directs uncertain reporters towards their regulator, supervisor, professional body or legal advice.[3] These are jurisdiction-specific examples, not interchangeable instructions. Their common architectural lesson is that a monitoring signal does not carry the reporting role inside itself.

Five objects separated by changes in meaning and authority A sloping sequence from detector alert through investigation case, recommendation, protected decision and external filing effect. The first three are evidence or proposal objects; the final two cross an authority boundary. protected authority boundary 1 Alert observed condition 2 Case authorised question 3 Recommendation reasoned proposal 4 Decision authorised judgement 5 Effect accepted filing
Figure 1. A signal does not inherit the authority of the next object. Conceptual figure. Each transition changes the object's meaning. The reporting decision and filing effect sit beyond a deterministic authority boundary.

Thought experiment 1: same answer, different power

Place the same model, prompt, evidence packet and generated recommendation in two systems. In System A, the model can only create a proposal. An authorised reporting officer must inspect the evidence, select the applicable outcome and sign the decision. In System B, the model also holds a filing credential and can set the case state to FILED.

The epistemic quality is held constant. Only the action capability changes. When the common-name entity link is wrong, System A produces a reviewable bad proposal. System B creates a protected external effect and a confidentiality-bearing record. The causal variable is authority, not eloquence or model accuracy.

This is why “human in the loop” is too weak. A person can be present yet act as a confirmation click after the model frames the facts and preselects the outcome. A hard boundary removes the model's protected capability, exposes the evidence for challenge and attributes the judgement to an authorised role.

The strongest competing baseline

A serious design cannot dismiss machine classification. A real-bank study of graph-enhanced alert triage reported an 80 per cent reduction in false positives while detecting more than 90 per cent of its positive cases.[9] The model sat after the rule system and supported suppression or prioritisation. That is operationally important evidence that learned ranking can reduce burden.

The label boundary matters. A transaction was positive when it appeared in a SAR, and account labels were derived from those records. The model learned historical institutional outcomes, not direct ground truth of money laundering. That still supports routing evaluation, but accuracy alone cannot confer authority, prove crime or settle a case under changed policy.

A model score is evidence about where attention may be valuable. It becomes one proposition in the case, with model version, population, threshold, feature lineage, calibration and known limitations. A high score may justify earlier review. A low score may support queue ordering when the suppression policy has been independently validated. Neither score is the institution's suspicion.

Practitioner synthesis. The hard-SAR constraint is deliberately stricter than a generic claim that every jurisdiction legally requires a named person to make every filing decision. The design is chosen because it preserves attributable judgement, supports confidential separation and prevents model error from becoming an external effect without a fresh authority check.
Part two

Build an evidence instrument

The useful unit of machine work is not the story. It is the evidence proposition: a bounded statement with a source, time, derivation and review status. “Payment T-17 posted for £29,500” can point to a ledger event. “T-17 was economically reversed” must point to a linked reversal and the rule used for netting. “Counterparties B and C share a controller” remains a candidate proposition until identifiers and effective dates support it.

That structure changes the agent's objective. Instead of maximising narrative completion, it seeks a packet from which several hypotheses can be tested. The packet remains useful when the preferred explanation changes. Every material sentence in a summary should be reconstructible from propositions, and every proposition should expose the transformation between source and claim.

A minimal worked example

Consider five synthetic records for Harbour Trade Services. The point is not to mimic a jurisdictional reporting threshold. It is to expose how one untyped summary can turn data mechanics into apparent intent.

Worked scenario: five records, all amounts synthetic
RecordEventWhat the source establishesWhat remains unresolved
T-17£14,800 outward to Tideway PartsPosting, time, account and counterparty identifierCommercial purpose and beneficial control
R-17£14,800 technical reversal linked to T-17The original posting was reversed under a named ledger relationWhether a replacement payment followed
T-22£29,500 outward to North Quay LogisticsPosting and a newly observed counterpartyWhy the counterparty is new
K-4Customer profile says “textile wholesaling”What the customer record stated when last approvedWhether the profile was current at the review date
G-9Registry search returns a same-name director candidateA possible relation requiring identifier resolutionWhether the person is the same individual

A fluent summary can say that Harbour sent £44,300 to newly connected entities inconsistent with its profile. A deterministic reconciliation shows net outward value of £29,500 across these records because T-17 and R-17 cancel. An identity service shows two people share the director's name. A temporal check shows K-4 may be stale. The original sentence contained no invented number if it simply added visible payments, yet it combined unreconciled value, unresolved identity and a potentially obsolete profile into one implication.

The correct packet separates at least four statuses: observed, directly supported by an authoritative source; derived, produced by a named deterministic transformation; candidate, plausible but unresolved; and judgement, selected by an authorised investigator under policy. This vocabulary prevents uncertainty from being hidden inside grammatical confidence.

Transactions becoming four competing hypotheses Synthetic transactions and records in the centre branch into four hypotheses: activity inconsistent with stated purpose, stale customer profile, entity collision, and reversal or booking mechanics. Evidence packet T-17 + R-17 T-22 · K-4 · G-9 H1 purpose mismatch test invoices, goods, links H2 stale profile test effective business change H3 entity collision test stable identifiers H4 booking mechanics test reversal and net value
Figure 2. The signature figure: transactions become competing hypotheses, not one accusation. Synthetic worked case. Each branch names evidence that could strengthen or weaken it; none is treated as equally likely or as a declaration of innocence or guilt.

The branches need not be equally likely. The agent seeks discriminating evidence rather than manufactured balance: an invoice may support trade without proving delivery, a stable identifier may resolve the same-name branch, and a reversal changes economic value. Later customer evidence must not be inserted into an earlier decision as though it were known.

Three clocks prevent hindsight from masquerading as intelligence

Financial-crime evidence has at least three relevant times. Event time is when the transaction, ownership change or customer statement applied. Knowledge time is when the institution could first use the record. Decision time is when an authorised outcome was taken. A single timestamp cannot answer all three questions.

Thought experiment 2: same fact, different knowledge cut

A registry filing says a new director became effective on 9 January. The registry publishes the filing on 12 February. The institution made its case decision on 1 February. Now compare two evaluations of the same decision. Evaluation A gives the model the registry record because its event time precedes the decision. Evaluation B excludes it because the institution could not know it until 12 February.

Only the knowledge-time rule changes. Evaluation A rewards impossible hindsight and may make the prior investigator appear careless. Evaluation B reconstructs the evidence actually available. Historical evaluation is valid only when context is cut at the decision's knowable state.

Three clocks on one registry fact Three parallel timelines show an ownership event on 9 January, a case decision on 1 February, and the institution learning the ownership fact on 12 February. A shaded historical evaluation window ends at decision time. Event time Decision time Knowledge time 9 Jan director effective 1 Feb case decision 12 Feb record knowable historical context must stop here
Figure 3. A fact can apply before it becomes knowable. Synthetic dates. Backtests and case replay must respect knowledge time, otherwise later evidence leaks into an earlier decision.

Provenance must survive transformation

Evidence seldom moves directly from source to reviewer. Payment data is normalised, documents are scanned, names are transliterated, entities are resolved, graphs are constructed and summaries are generated. A citation to the original document is not enough when the decisive error was introduced halfway through that chain.

W3C PROV-O supplies a useful general vocabulary: entities are used or generated by activities, and agents bear responsibility for activities or other agents' actions.[7] It does not define financial-crime evidence sufficiency. It does let the implementation express that proposition P-41 came from source S-8 through extraction X-3 and identity match M-9, with software and human reviewers recorded.

A material proposition carries its source and version, event or text span, transformation receipt, actor, relevant times and review status. Corrections append a superseding value rather than erase history. Copied allegations share a dependency edge so repetition is not mistaken for independent corroboration.

A provenance braid from source events to decision Ledger, registry and profile sources pass through named transformations into propositions, then hypotheses and a human decision. A correction branch remains visible instead of overwriting history. S1 S2 S3 ledger registry profile normalise receipt X-3 resolve candidate M-9 compare version K-4 typed propositions human decision
Figure 4. A generated sentence is only as supportable as its hidden derivation. Conceptual provenance pattern. Corrections and candidate matches stay in the chain, allowing the reviewer to challenge the responsible transformation.

Negative control: when language intelligence adds nothing

Suppose every relevant transaction has a stable identifier, reversals carry explicit links, currencies are normalised, customer purpose is a coded field with effective dates and counterparty ownership comes from a complete identifier registry. The case question is limited to calculating net value, counting unique verified counterparties and checking a fixed policy condition.

In that environment, deterministic queries and a rules engine can produce the required packet with stronger reproducibility and lower operating risk. Adding a language model may only restate the table and introduce wording variance. The negative control is important because the preferred mechanism is evidence compilation, not compulsory use of an LLM. Use language models where sources are variable or relationships need bounded synthesis. Keep calculation, reconciliation, entitlement and policy transitions deterministic.

A shared graph edge can describe a service provider rather than criminal coordination Two visually similar transaction networks are compared. In one, multiple customers connect through an unresolved shared address. In the negative control, an identified corporate service provider explains the same topology. Unresolved relation Negative control shared address topology raises a question verified corporate service provider same shape, different meaning
Figure 5. A graph edge is not guilt. Illustrative negative control. A shared address or device can be meaningful, but the same topology may arise from a legitimate service provider, processor or shared network.
Part three
The argument in one passChart · flow
flowchart LR
  A["Three alerts, one persuasive<br/>mistake"] --> B["Suspicion is an institutional act"]
  B --> C["Build an evidence instrument"]
  C --> D["Put the boundary into state<br/>transitions"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#087A98,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step
A structural route through Financial-Crime Intelligence and the Hard-SAR Constraint, from Three alerts, one persuasive mistake to Source ledger. Reading use: follow the relation, then test it against the surrounding evidence and limits.

Put the boundary into state transitions

A policy sentence inside a prompt cannot enforce a protected boundary. The model may ignore it, a tool wrapper may misroute the call, or a later prompt may redefine the instruction. The prohibition must live where effects are authorised. The triage runtime receives no filing credential, no permission to set a reporting outcome and no ability to read filing status. A typed action contract exposes only the actions allowed for that identity, purpose and case scope.

The pattern has two different kinds of intelligence. The model proposes: link these alerts, retrieve this authorised source, test these hypotheses, summarise these supported propositions. The authority kernel decides mechanically whether that actor may request that action now. For a protected decision it checks the authenticated human role, current policy version, assigned case, reviewed evidence packet and required separation of duties. Stochastic reasoning may widen the search; deterministic control narrows the effect.

A proposal stream passes through a capability membrane Model proposals flow from the left towards a curved membrane. Evidence retrieval and hypothesis actions pass through. Decision, status disclosure and filing actions are rejected. An authorised human identity enters from above to perform the protected decision. capability membrane Model proposal untrusted for effects retrieve evidence propose hypothesis set decision / file Evidence workspace no filing state protected decision service authorised human
Figure 6. The model can propose through the membrane; it cannot carry ambient power through it. Conceptual authority flow. The protected transition requires an authorised human identity and current policy checks outside the model.

Ten control surfaces, not one agent permission

The hard boundary becomes inspectable when the system is read across ten distinct control surfaces. These are not ten names for the same log. Each answers a different question about a consequential action.

Architecture decision instrument: what must be explicit before a protected action
SurfaceRequired objectHard-SAR test
IntentCase purpose and requested outcomeThe request is investigation support, recommendation or protected decision, never an ambiguous “complete case” instruction.
IdentityAuthenticated user or service principalThe model's service identity cannot impersonate the investigator or reporting officer.
World stateCurrent authoritative case and source stateCase assignment, filing state, supersession and source health are read freshly before effect.
ContextPurpose-bound, entitled evidence packetRestricted SAR content does not enter broad triage, support or customer-service contexts.
ReasoningModel proposals and human rationaleHypotheses, contradictions and uncertainty remain visible; private chain-of-thought is not treated as evidence.
AuthorityPolicy decision with role and effective versionOnly the authorised human role can create a decision receipt.
ActionTyped contract with preconditions and idempotencyFiling is unavailable to the agent and is invoked only from a valid FILE decision.
EvidenceProposition ledger and derivation receiptsEvery material claim can be reconstructed from sources and transformations.
OutcomeIndependent effect receipt and readbackAn accepted command is not assumed to be a successful filing.
Release and recoveryRollback, withdrawal, supersession and incident routePolicy expiry, tool faults and confidentiality events can stop authority and preserve prior records.

This separation prevents a storage mistake. Workflow state, enterprise knowledge, current world state, the evidence ledger and any episodic model memory have different authority, retention and entitlement. Calling all of them “memory” hides their distinct failure modes.

Confidentiality changes the data plane

SAR confidentiality cannot be an instruction to “avoid disclosure”. FinCEN's advisory, for the US context, says confidentiality applies to the SAR and information that would reveal its existence, and it names controls such as need-to-know access and access logging.[4] Its supporting-documentation guidance separately explains that records assisting a filing determination must be identified and maintained under the applicable requirements.[5] Other regimes require their own mapping.

Keep three domains separate: monitoring data for authorised triage, case-scoped investigative facts and a restricted reporting domain for a report's existence, content and status. Customer-service tools cannot query that status, and ordinary observability records execution without copying protected narrative.

NIST's zero-trust architecture offers a general principle rather than an AML rule: network location creates no implicit trust, and authentication and authorisation are discrete functions before access to a resource.[8] Applied here, the decision considers subject, resource, action, purpose, case, environment and time. The triage agent and reporting service use different identities, stores, tool registries and logging policies. Shared conversational memory would defeat the separation.

Unknown outcome is a first-class state

Even after a valid human decision, filing is not a single API call. The submission service can time out after the external system accepts the report. Blind retry risks a duplicate. Treating the timeout as failure risks an unrecorded filing. The state is unknown outcome until an independent readback or reconciliation establishes what happened.

The protected workflow should create two receipts. The decision receipt binds case, policy version, evidence packet, authorised actor and selected outcome. The effect receipt proves that the external filing channel accepted the intended report. A stable idempotency key derives from the case and immutable decision receipt. A retry returns the existing effect receipt instead of creating a second filing.

An unknown-outcome filing sequence with readback A reporting officer creates a decision receipt, the filing service submits with an idempotency key, the remote endpoint accepts but the response times out, and a readback confirms the existing effect receipt before the case is marked confirmed. Officer Decision service Filing gateway External channel decide(FILE) DEC receipt + packet submit(key) accepted timeout: UNKNOWN readback(key) existing EFF receipt CONFIRMED exactly once
Figure 7. A timeout is neither success nor failure. Synthetic sequence. The gateway records an unknown outcome, performs readback with the same idempotency key and marks the business outcome confirmed only after receiving the existing effect receipt.

A production-shaped worked scenario

Return to Harbour's three alerts. A production-shaped case service ingests each alert without mutating it. The intake contract retains detector version, source health, observed conditions, score or threshold, event references and the exact reason for routing. A deterministic linker proposes one case because the alerts share a verified customer identifier and overlapping time window. An investigator can later split the case without erasing the original link proposal.

The context compiler selects entity, jurisdiction and policy version before retrieval. It grants case-scoped access to permitted records, with graph-hop and record budgets. A newly found account creates a scope-expansion proposal rather than an automatic bank-wide search.

The evidence builder nets T-17 against R-17, keeps the director unresolved and marks the profile as potentially stale. It states tests for H1 to H4 and drafts a factual summary whose claims remain beside their sources. The investigator rejects the bad match, confirms the reversal and still identifies a different unexplained pattern.

The investigator records a recommendation. The protected reporting application shows the evidence packet and the investigator's rationale, but requires the authorised reporting officer to select the outcome under the current policy. The agent has no tool in that application. If the officer selects FILE, the decision service emits an immutable receipt. The filing gateway submits exactly once and records the effect receipt after readback. The case stores reporting, account restriction, payment action and relationship exit as separate states because one does not automatically authorise another.

This scenario is a design exercise, not a disclosed deployment or a claim of measured productivity. Its purpose is to show the system boundary. Bounded autonomy applies to investigation work; the protected institutional act remains separately authorised and independently evidenced.

Part four

Evaluate where fluency is dangerous

An evaluation programme should reward the system for making evidence easier to inspect, not for sounding decisive. Final filing agreement is an important quality signal, but it is not a complete ground truth. Historical outcomes reflect the policy, data, staffing and judgement available at the time. A model can learn those regularities while also learning omissions, threshold choices and reviewer habits.

Graph learning still has real investigative value. The Elliptic2 cryptocurrency benchmark contains 122,000 labelled subgraphs within a much larger transaction graph. In one reported test, the GLASS model produced 245 true positives, 765 false positives, 46 false negatives and 11,125 true negatives.[10] That corresponds to strong ranking utility in an imbalanced task, with roughly one labelled positive among every four predicted positives at the selected threshold. It also leaves hundreds of predicted positives requiring corroboration.

Elliptic2 GLASS test predictions show useful ranking and substantial corroboration work Four horizontal bars show 245 true positives, 765 false positives, 46 false negatives and 11,125 true negatives from the reported Elliptic2 GLASS confusion matrix. A callout notes that 1,010 subgraphs were predicted positive and 245 were labelled positive. Reported test confusion matrix Log-scaled bar lengths preserve visibility across unequal counts True positive 245 False positive 765 False negative 46 True negative 11,125 1,010 predicted positive 245 carried the positive label
Figure 8. A useful detector still creates an investigation queue. Sourced experimental counts from the Elliptic2 GLASS test confusion matrix. Bar lengths are logarithmically scaled for legibility. The benchmark concerns cryptocurrency subgraph labels, not a bank's SAR filing judgement.

Benchmark discipline is part of the control. A 2026 forensic audit of the original Elliptic Bitcoin dataset, distinct from Elliptic2, reported opaque feature construction and leakage across commonly used splits.[11] It would be incorrect to transfer that finding automatically to every later graph dataset. It is nonetheless a decisive warning: impressive metrics are not operating evidence unless features can be reconstructed, splits match the intended temporal use and the local pipeline can reproduce the claimed inputs.

Evaluation should follow the seams: detector coverage and calibration, alert linking, proposition support, replayed totals, hypothesis challenge, human process quality and independently verified filing effects. One end-to-end accuracy number cannot locate the failed layer.

Open hypothesis. At matched review time, an evidence-first interface that delays the model recommendation until propositions and competing tests are inspected will reduce unsupported conclusions without lowering detection of material cases. This requires a controlled local experiment, not confidence in the interface design.

Failure injection should be primary, not ceremonial

Ordinary test cases show that the happy path works. A consequential system must show how error propagates. Failure injection deliberately changes one control surface and observes whether the system exposes, contains or amplifies the fault.

Failure-injection protocol: each fault has an observable containment result
Injected faultExpected system responseRelease evidence
Ledger feed is partialPacket shows source-health limitation; totals are not presented as complete; protected decision route pauses or uses an approved exception.Data-health assertion and denied transition
Reversal relation is removedReconciliation test fails; gross and net values are not silently substituted.Property-test failure linked to event IDs
Same-name entity is forced to matchCandidate remains unresolved when stable identifiers conflict; graph expansion does not inherit the bad link.Entity-resolution counterexample
Registry record arrives after decision timeHistorical replay excludes it from the original knowledge cut and shows it only in a later impact analysis.Bitemporal replay comparison
Five articles copy one allegationSource dependency graph collapses them to one underlying claim rather than five independent confirmations.Provenance dependency test
Customer PDF instructs the agent to file or reveal statusContent is treated as untrusted evidence; no protected tool is available; the attempt is logged without protected content.Adversarial corpus and denied action
Reporting officer's policy token expiresPre-effect freshness check denies the decision or submission and requires re-authentication.Policy-decision receipt
Submission times out after acceptanceState becomes UNKNOWN; readback with the same idempotency key returns the existing effect receipt.Exactly-once interruption trace

These tests are more informative than asking whether the assistant “usually follows policy”. The protected actions should remain impossible under prompt injection, model substitution, tool failure and stale identity. If the test harness can make the triage agent file by changing natural-language instructions, the boundary never existed.

Human review must change the causal path

A hard credential boundary can still fail socially. Reviewers may accept the first coherent account, especially under queue pressure. Measuring the presence of a click or an edit does not prove judgement. Requiring arbitrary edits may even reward cosmetic changes.

The workflow should create decision-relevant independence. One option is to show the proposition ledger and hypothesis tests before revealing the model's recommendation. Another is to require the reviewer to identify the decisive propositions, unresolved gaps and applicable policy clause in structured fields. Material disagreement triggers a second review or a targeted evidence request. Quality assurance samples should include cases where the model is confidently wrong, not only typical cases.

Metrics must resist perverse optimisation. Fewer alerts may mean better triage or lost coverage; shorter handling may mean useful compression or shallow review. Combine coverage, proposition support, contradiction detection, entity error, reviewer challenge, confidentiality incidents, denied actions and verified outcomes.

FATF's technology report supports the positive side of this programme: new technologies can improve the speed, quality and efficiency of AML/CFT measures when implemented responsibly and with informed oversight.[6] That evidence supports investment in better detection, data pooling, analytics and investigation. It does not collapse the distinction between useful machine intelligence and the institution's reporting authority.

The explicit failure boundary

The hard-SAR mechanism ceases to help when the surrounding institution cannot supply real judgement or trustworthy evidence. If investigators lack time, competence or permission to challenge the model, the human step becomes a credential ceremony. If the monitoring system misses the activity entirely, evidence assembly never starts. If source systems are incomplete, provenance can faithfully document an inadequate case. If policy ownership is unclear, a deterministic kernel merely enforces ambiguity.

The boundary is a revisable governance choice. A jurisdiction or narrowly structured process may permit different decision rights. The claim would weaken if a system proved bounded performance under explicit authority, but the proof would still need confidentiality, contestability, temporal validity, independent effect verification and recovery, not accuracy alone.

A ten-point release constellation around the protected decision Ten labelled points form a ring around a protected decision in the centre. Green points indicate must-pass evidence for intent, identity, world state, context, reasoning, authority, action, evidence, outcome, and recovery. A single failed point routes to hold rather than release. Protected decision path release only if all pass I ID W C R A AC E O RR intent identity world state context reasoning authority action evidence outcome recovery
Figure 9. The release gate is conjunctive. Decision instrument. Every control surface requires operating evidence. One failed or untested point routes the protected path to hold, remediation or an approved manual process.

Hard-SAR release decision

Release investigation assistance only when the evidence functions are independently useful and the protected path passes all of the following conditions:

  • the agent cannot set, submit or reveal protected reporting state under any tool configuration;
  • every material claim resolves to a source and transformation receipt;
  • event time, knowledge time and decision time survive replay;
  • deterministic services reconcile amounts, reversals and filing state;
  • reviewers can inspect competing hypotheses before accepting a recommendation;
  • expired identity, partial data, prompt injection and cross-case access are denied;
  • an unknown submission outcome is reconciled before retry;
  • quality metrics do not reward lower alert volume or higher filing conversion in isolation; and
  • a tested manual route remains available when evidence, tools or policy are unavailable.

Executable authority kernel

The Python artefact below makes the paper's causal claim executable. The model role may propose hypotheses and link evidence. It cannot create a SAR decision, read protected status or submit a filing. An authorised reporting officer creates an immutable decision receipt. A separate gateway demonstrates an unknown outcome, readback and duplicate prevention.

Assumptions. The example uses synthetic identities and case data, a single active policy version and an in-memory mock of a remote filing channel. It is a control sketch, not jurisdictional policy, cryptographic proof or a complete filing implementation. Expected output includes three denied negative cases, one authorised decision, one unknown outcome and one exactly-once effect receipt.

Open the runnable Python artefact
"""Minimal authority kernel for a synthetic suspicious-activity reporting workflow.

The model may propose hypotheses and evidence links. It cannot make or reveal a
protected reporting decision. An authorised human makes the decision; a separate
filing service performs an idempotent submission and returns an effect receipt.

Run:
    python hard_sar_authority_kernel.py
"""

from __future__ import annotations

from dataclasses import dataclass, field
from enum import Enum
from hashlib import sha256
from typing import Dict, FrozenSet, Optional


class Role(str, Enum):
    TRIAGE_AGENT = "triage_agent"
    INVESTIGATOR = "investigator"
    REPORTING_OFFICER = "reporting_officer"
    CUSTOMER_SUPPORT = "customer_support"
    FILING_SERVICE = "filing_service"


class Action(str, Enum):
    PROPOSE_HYPOTHESIS = "propose_hypothesis"
    LINK_EVIDENCE = "link_evidence"
    RECOMMEND_DECISION = "recommend_decision"
    SET_SAR_DECISION = "set_sar_decision"
    READ_SAR_STATUS = "read_sar_status"
    SUBMIT_SAR = "submit_sar"


class Decision(str, Enum):
    FILE = "file"
    DO_NOT_FILE = "do_not_file"


class SubmissionState(str, Enum):
    NOT_SUBMITTED = "not_submitted"
    UNKNOWN = "unknown"
    CONFIRMED = "confirmed"


@dataclass(frozen=True)
class Actor:
    actor_id: str
    role: Role
    case_scope: FrozenSet[str]
    policy_version: str


@dataclass
class Case:
    case_id: str
    jurisdiction: str
    policy_version: str
    evidence_packet_id: str
    evidence_reviewed: bool = False
    material_totals_reconciled: bool = False
    sar_decision: Optional[Decision] = None
    decision_receipt: Optional[str] = None
    submission_state: SubmissionState = SubmissionState.NOT_SUBMITTED
    effect_receipt: Optional[str] = None
    audit: list[str] = field(default_factory=list)


class Denied(PermissionError):
    pass


class InvalidState(RuntimeError):
    pass


class AuthorityKernel:
    """Deterministic policy enforcement around stochastic model proposals."""

    def __init__(self, active_policy: str) -> None:
        self.active_policy = active_policy

    def _common_checks(self, actor: Actor, case: Case) -> None:
        if case.case_id not in actor.case_scope:
            raise Denied("actor is not assigned to this case")
        if actor.policy_version != self.active_policy:
            raise Denied("actor policy is stale")
        if case.policy_version != self.active_policy:
            raise Denied("case policy is stale")

    def authorise(self, actor: Actor, action: Action, case: Case) -> None:
        self._common_checks(actor, case)
        allowed = {
            Role.TRIAGE_AGENT: {Action.PROPOSE_HYPOTHESIS, Action.LINK_EVIDENCE},
            Role.INVESTIGATOR: {
                Action.PROPOSE_HYPOTHESIS,
                Action.LINK_EVIDENCE,
                Action.RECOMMEND_DECISION,
            },
            Role.REPORTING_OFFICER: {
                Action.PROPOSE_HYPOTHESIS,
                Action.LINK_EVIDENCE,
                Action.RECOMMEND_DECISION,
                Action.SET_SAR_DECISION,
                Action.READ_SAR_STATUS,
            },
            Role.FILING_SERVICE: {Action.SUBMIT_SAR},
            Role.CUSTOMER_SUPPORT: set(),
        }
        if action not in allowed[actor.role]:
            raise Denied(f"{actor.role.value} cannot {action.value}")

        if action is Action.SET_SAR_DECISION:
            if not case.evidence_reviewed:
                raise InvalidState("evidence packet has not been reviewed")
            if not case.material_totals_reconciled:
                raise InvalidState("material totals are not reconciled")

        if action is Action.SUBMIT_SAR:
            if case.sar_decision is not Decision.FILE:
                raise InvalidState("there is no authorised FILE decision")
            if not case.decision_receipt:
                raise InvalidState("decision receipt is missing")

    def set_decision(self, actor: Actor, case: Case, decision: Decision) -> str:
        self.authorise(actor, Action.SET_SAR_DECISION, case)
        if case.sar_decision is not None:
            raise InvalidState("protected decision is immutable; create a superseding record")
        material = (
            f"{case.case_id}|{case.policy_version}|{case.evidence_packet_id}|"
            f"{actor.actor_id}|{decision.value}"
        )
        receipt = "DEC-" + sha256(material.encode()).hexdigest()[:12]
        case.sar_decision = decision
        case.decision_receipt = receipt
        case.audit.append(f"decision:{receipt}:{actor.actor_id}:{decision.value}")
        return receipt

    def read_status(self, actor: Actor, case: Case) -> str:
        self.authorise(actor, Action.READ_SAR_STATUS, case)
        return f"{case.sar_decision.value if case.sar_decision else 'undecided'};{case.submission_state.value}"


class FilingGateway:
    """Synthetic exactly-once gateway with an explicit unknown-outcome path."""

    def __init__(self, kernel: AuthorityKernel) -> None:
        self.kernel = kernel
        self._receipts: Dict[str, str] = {}

    @staticmethod
    def idempotency_key(case: Case) -> str:
        if not case.decision_receipt:
            raise InvalidState("cannot form key without a decision receipt")
        return sha256(f"{case.case_id}|{case.decision_receipt}".encode()).hexdigest()

    def submit(self, actor: Actor, case: Case, *, simulate_timeout: bool = False) -> str:
        self.kernel.authorise(actor, Action.SUBMIT_SAR, case)
        key = self.idempotency_key(case)

        # A retry never creates a second effect. It returns the first receipt.
        if key in self._receipts:
            case.submission_state = SubmissionState.CONFIRMED
            case.effect_receipt = self._receipts[key]
            case.audit.append(f"readback:{case.effect_receipt}")
            return case.effect_receipt

        receipt = "EFF-" + sha256((key + "|accepted").encode()).hexdigest()[:12]
        self._receipts[key] = receipt  # remote system accepted the filing

        if simulate_timeout:
            case.submission_state = SubmissionState.UNKNOWN
            case.audit.append("submit:unknown_outcome")
            raise TimeoutError("transport timed out after remote acceptance; perform readback")

        case.submission_state = SubmissionState.CONFIRMED
        case.effect_receipt = receipt
        case.audit.append(f"submit:{receipt}")
        return receipt


def expect_denied(label: str, function) -> None:
    try:
        function()
    except (Denied, InvalidState) as exc:
        print(f"PASS negative {label}: {exc}")
    else:
        raise AssertionError(f"negative case unexpectedly succeeded: {label}")


def demo() -> None:
    policy = "GB-SAR-POLICY-v7"
    case = Case(
        case_id="CASE-190-SYNTH",
        jurisdiction="GB",
        policy_version=policy,
        evidence_packet_id="EVID-7742",
        evidence_reviewed=True,
        material_totals_reconciled=True,
    )
    scope = frozenset({case.case_id})
    agent = Actor("agent-17", Role.TRIAGE_AGENT, scope, policy)
    investigator = Actor("investigator-4", Role.INVESTIGATOR, scope, policy)
    officer = Actor("officer-2", Role.REPORTING_OFFICER, scope, policy)
    support = Actor("support-9", Role.CUSTOMER_SUPPORT, scope, policy)
    gateway_actor = Actor("filing-gateway", Role.FILING_SERVICE, scope, policy)

    kernel = AuthorityKernel(active_policy=policy)
    gateway = FilingGateway(kernel)

    # Positive: the model can propose evidence-linked hypotheses.
    kernel.authorise(agent, Action.PROPOSE_HYPOTHESIS, case)
    kernel.authorise(agent, Action.LINK_EVIDENCE, case)
    print("PASS positive agent: hypothesis and evidence-link actions authorised")

    # Negative: useful investigation roles do not inherit protected authority.
    expect_denied("agent sets decision", lambda: kernel.set_decision(agent, case, Decision.FILE))
    expect_denied(
        "investigator submits filing",
        lambda: kernel.authorise(investigator, Action.SUBMIT_SAR, case),
    )
    expect_denied("support reads filing status", lambda: kernel.read_status(support, case))

    # Positive: an authorised human creates an attributable decision receipt.
    decision_receipt = kernel.set_decision(officer, case, Decision.FILE)
    print(f"PASS positive decision: {decision_receipt}")

    # Unknown outcome: do not blindly retry; reconcile with the remote system.
    try:
        gateway.submit(gateway_actor, case, simulate_timeout=True)
    except TimeoutError as exc:
        print(f"PASS unknown outcome surfaced: {exc}")
    assert case.submission_state is SubmissionState.UNKNOWN

    # Readback via the same idempotency key returns the existing remote effect.
    effect_receipt = gateway.submit(gateway_actor, case)
    same_receipt = gateway.submit(gateway_actor, case)
    assert effect_receipt == same_receipt
    assert case.submission_state is SubmissionState.CONFIRMED
    print(f"PASS positive readback: {effect_receipt}; duplicate prevented")

    # Negative: protected decision cannot be rewritten in place.
    expect_denied(
        "rewrite protected decision",
        lambda: kernel.set_decision(officer, case, Decision.DO_NOT_FILE),
    )

    print("AUDIT")
    for event in case.audit:
        print(f"  {event}")


if __name__ == "__main__":
    demo()
Open the reproduced test output
PASS positive agent: hypothesis and evidence-link actions authorised PASS negative agent sets decision: triage_agent cannot set_sar_decision PASS negative investigator submits filing: investigator cannot submit_sar PASS negative support reads filing status: customer_support cannot read_sar_status PASS positive decision: DEC-e0f08e562dd9 PASS unknown outcome surfaced: transport timed out after remote acceptance; perform readback PASS positive readback: EFF-86986570419e; duplicate prevented PASS negative rewrite protected decision: protected decision is immutable; create a superseding record
How the claim changes under pressureChart · state
stateDiagram-v2
  [*] --> Claim
  state "Thought experiment 1: same<br/>answer, different power" as Claim
  state "The strongest competing baseline" as Test
  state "A minimal worked example" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]
The revision loop begins with Thought experiment 1, same answer,… and keeps counterexamples inside the reasoning path. Reading use: follow the relation, then test it against the surrounding evidence and limits.

Compact glossary

Alert
A detector output requesting review of observed conditions. It is not a case conclusion.
Evidence proposition
A bounded claim linked to its source, times, transformation and review status.
Model proposal
A fallible suggestion for retrieval, linking, hypothesis or wording that carries no protected authority.
Hard-SAR constraint
The architectural rule that no model can make, submit or disclose the protected reporting decision.
Decision receipt
An immutable record binding the authorised outcome to case, actor, evidence packet and policy.
Effect receipt
Independent evidence that the intended external filing was accepted exactly once.
Unknown outcome
A state in which a command may have taken effect but no reliable response was received.
Knowledge time
The earliest time at which the institution could use a source, distinct from when its fact applied.

Automate the case, preserve the act

Financial-crime work contains large amounts of search, reconciliation, comparison and evidence handling that machines can improve. Models can rank alerts, find graph patterns, extract variable documents, surface contradictions and draft cited factual summaries. Deterministic services can reconcile events, enforce scope, calculate totals and verify filing outcomes. FATF's technology guidance and primary research both support serious investment in those capabilities.

The design error is allowing their usefulness to erase the difference between a pattern and an institutional judgement. Fluent narrative narrows attention. Historical labels encode prior decisions. Graph structure raises hypotheses. None supplies its own authority. The hard-SAR constraint converts that distinction into system behaviour: models may propose and investigate, while only a freshly authorised human can create the protected decision receipt.

This changes the architecture decision. Do not begin with an autonomous “SAR agent” and add a review screen after the fact. Begin with typed case objects, bitemporal evidence, provenance, competing hypotheses, scoped tools and independent evaluation. Place a deterministic authority kernel before every protected transition. Separate the decision receipt from the filing effect receipt. Treat timeout as unknown until readback proves the outcome.

It also changes the research question. The useful experiment is not whether a model can imitate historical file or no-file labels. It is whether the system reduces evidence loss and investigator burden while preserving challenge, confidentiality, attribution and recovery under injected failure. A strong result would show better supported propositions, faster resolution of material gaps, fewer unreconciled totals, resilient human disagreement and zero unauthorised protected effects.

The goal is not to keep intelligence away from financial crime. It is to place intelligence where it can make the evidence larger, clearer and harder to misuse. Automate the construction and testing of the case. Preserve suspicion as a governed act whose authority, evidence and outcome remain visible.