Action assurance for regulated AI workflows
Control before action. Proof after action.

Give selected high-impact AI actions a receipt your customer can verify.

For selected AI-assisted actions, TCD checks the expected policy and control path before the workflow proceeds. It then leaves a signed, policy-bound receipt of the actual governed outcome — without exposing raw customer data, prompts, or model answers.

Buyer trigger
A regulated customer questions one specific AI-assisted action. They want to know what rule applied, what the system actually required, and whether the record can be checked outside the original product UI.
Business friction
The underlying data may already exist. The harder problem is preserving a reviewable link between what triggered an action, why it was taken, which evidence and context supported it, what was checked and ruled out, and which policy or guidance applied. Those elements are often distributed across case tools, transaction systems, KYC records, network analysis, OSINT, RFIs, policy records, and reviewer notes.
Action assurance
TCD records what governed the action, not only that it happened. The receipt can bind the selected action to policy, configuration, the actual terminal outcome, evidence references, and verification status.
External review
The reviewer checks the receipt without opening raw case data. Public Ed25519 verifier vectors, historical HMAC-based runtime evidence, assurance documentation, and private runtime content remain explicitly separated.
Policy-bound action receipts Actual outcomes preserved Public verifier + test vectors Synthetic or redacted design studies No raw customer data

Why TCD Proof

When an AI-assisted action reaches review, the expensive part is reconstructing whether its rationale is defensible.

Transaction data, KYC records, OSINT, RFI responses, notes, policy records, and model outputs may all exist. What often fails to travel with the action is the connection between the trigger, the declared rationale, the supporting and contrary evidence, the source context, and the applicable guidance. A QC or FIU reviewer may then have to reopen systems, request clarification, or reconstruct the case before deciding whether the action should stand.

The buyer moment

An AI-assisted AML action reaches QC or FIU — but the “why” does not travel with it.

The receiving reviewer needs the right information, not simply more information: what triggered the concern, the relevant customer and KYC context, the transaction and counterparty context, what expected activity or benign explanations were checked, which evidence references support the declared rationale, and which policy or guidance applied at the time.

Q1 “What triggered this action, and what declared rationale accompanied it?”
Q2 “Which evidence references and relevant context supported it, and what expected activity or benign explanations were checked?”
Q3 “Which policy, guidance, configuration, and software version governed the action?”
Q4 “Can a reviewer verify those bindings and expected receipt completeness outside the original product UI?”
01

Replace manual reconstruction with a repeatable evidence output.

Instead of rebuilding the decision trail from logs, screenshots, and case notes, TCD creates a bounded receipt and verification path at the time of the action.

02

Give the customer something they can check, not another trust-me export.

The public verifier recomputes signed bytes, verifies an illustrative Ed25519 receipt, and checks expected policy and build bindings outside the product UI.

03

Keep the evidence useful without turning the receipt into another data store.

Public materials use synthetic data, redacted identifiers, references, hashes, bounded metadata, and explicit production boundaries — not raw customer payloads.

Primary wedge

Start where the buyer already has a review problem: AML/KYB vendors selling into regulated financial institutions.

TCD is most relevant when an AI vendor's customer may later question a selected decision, recommendation, escalation, hold, or block. The initial wedge is not every AI interaction. It is the smaller set of high-impact actions that create customer-assurance, model-risk, security-review, or audit friction.

Lending and underwriting Document review, income calculation, fraud signals, credit workflow recommendations, approval holds, and policy-bound underwriting actions.
Insurance claims FNOL review, claim prioritization, adjuster guidance, reserve-related actions, document evidence references, and human-review escalation.
Compliance operations Investigation-to-QC or FIU handoffs, using a workflow-specific assurance profile for trigger-to-rationale linkage, bounded customer and transaction context, expected or benign-activity checks, source provenance and timestamps, applicable guidance bindings, reviewer clarification, and escalation — without placing raw case content in the core receipt.
Enterprise assurance Customer trust packages, vendor reviews, security questionnaires, model-risk evidence, RFP responses, and audit preparation.

Two-week non-production design study

Start by defining one review contract, not deploying a platform.

For one selected AML/KYB handoff, define what the receiving reviewer must be able to determine: the action trigger, declared rationale, relevant customer and transaction context, bounded evidence references, checks of expected or benign activity, applicable policy or guidance, and the receipts expected for independently identified eligible actions.

Using synthetic or already-redacted cases, the study evaluates whether a signed, policy-bound evidence package can reduce the need to reopen systems or request clarification. No production connection, raw customer data, or effect on a real customer decision is required.

01

One selected handoff

Select one bounded investigation-to-QC or FIU handoff and identify the actions, receiving reviewer, and review decision the study will examine.

02

One reviewer contract

Define the trigger, declared rationale, required context categories, bounded evidence references, expected or benign-activity checks, applicable guidance, and receipt expectations the reviewer should be able to inspect.

03

Synthetic or already-redacted cases

Exercise the proposed contract without production access or raw customer payloads. The study evaluates the handoff and evidence structure, not the correctness of a real customer decision.

Design study scope

Test the handoff before proposing production integration.

The study asks whether the proposed reviewer contract makes selected actions easier to inspect and reconcile. It does not claim regulatory compliance, prove that an AML conclusion is correct, or assume that a separate assurance product is needed.

What the design study measures

  • How many source systems the reviewer must reopen to understand the action
  • How many clarification requests or returns are needed, and why
  • Which required trigger, customer, transaction, counterparty, rationale, or guidance fields are missing
  • Whether each declared rationale can be traced to bounded evidence references
  • Whether expected activity, benign explanations, or other negative checks are documented
  • Whether source provenance, retrieval time, and the applicable guidance version can be identified
  • How long it takes the reviewer to decide whether the action should stand or continue to escalation
  • Whether the independently supplied eligible-action population reconciles with issued, committed, missing, orphaned, failed, or overridden receipts

Separated public proof paths

Public verification and runtime-derived evidence are deliberately separated.

The v0.1-pilot pre-release provides illustrative Ed25519 receipts, public-key material, strict positive and negative test vectors, and completeness reconciliation that any reviewer can run without the private runtime.

The historical AML/KYB artifacts are a separate track generated by an authorized local execution of the current private runtime. They use HMAC-SHA256 and local SQLite. The private runtime has not yet been integrated with the public Ed25519 profile.

What the historical runtime demo demonstrates

The proof package documents an actual local execution, not only an expected story. It includes provenance-labeled artifacts, a customer-facing assurance packet, explicit integration gaps, and a validation gate. All three synthetic actions were actually blocked; the historical result was not rewritten into a more attractive distribution.

Three synthetic AML/KYB action scenarios executed through the current runtime
Three actual terminal outcomes recorded as block
Three authenticated receipts issued
Receipt verification completed successfully
Incorrect expected_build_id produced a real binding failure
Service process restarted and by-reference verification passed
Actual signature algorithm recorded as HMAC-SHA256
Receipt-reference and evidence stores used local SQLite
Public validator, negative safety tests, Markdown links, manifest hashes, and acceptance gate passed

What the reviewer receives

A compact receipt backed by a broader evidence path.

The receipt is the shareable proof artifact. Behind it sits the policy match, actual terminal outcome, signing and key status, configuration bindings, durable evidence references, and verification result.

The receipt proves how a selected action was governed. It does not prove that the underlying model judgment was correct.

What a receipt can bind

  • Action, request, tenant, subject, workflow, route, and deterministic event identity
  • Policy or SOP reference, policy-set identity, version, and digest
  • The actual core outcome — allow, degrade, or block — and its enforcement semantics
  • Any configured buyer-facing workflow consequence mapped from the actual core outcome
  • Bounded risk-controller state and calibration evidence where relevant to the action
  • Hash-only evidence references, audit references, ledger references, and commit references
  • Configuration, route, receipt, build, image, and runtime fingerprints where available
  • Signing algorithm, key identity, integrity status, expected-binding checks, and restart lookup status

Buyer-facing flow

Proposed action → governed outcome → receipt → verification.

TCD sits beside a selected AI-assisted workflow. It does not replace the model, the policy owner, or the human reviewer. It establishes the action context, applies the configured controls, records the actual outcome, and produces a proof path another reviewer can check later.

AC
1
Select the action Choose a bounded decision, recommendation, escalation, hold, approval, or block that creates real review pressure.
ID
2
Bind identity and context Establish tenant, subject, workflow, event identity, route context, idempotency scope, and bounded evidence references.
PC
3
Apply policy and controls Evaluate the configured policy, risk, authentication, rate, route, and security context for the selected action.
TC
4
Resolve the actual outcome Produce an enforceable allow, degrade, or block outcome, which TCD records as a Terminal Contract.
RC
5
Issue and commit the receipt Authenticate the receipt, persist public-safe references, and record durable receipt, audit, ledger, and commit state.
VF
6
Verify and challenge bindings Confirm the receipt and expected context, detect mismatches, and verify again by reference after restart.

Technical architecture

The technical machinery sits behind the buyer-facing receipt.

Once the buyer understands the action, review moment, and assurance output, the underlying implementation can be inspected in more depth. TCD connects hardened request intake, policy and decision controls, authenticated receipts, durable evidence, and verification into one lifecycle.

01

Inference layer

Inference Data Plane

A hard ingress boundary establishes identity, transport context, request budgets, rate controls, and envelope validity before downstream components are allowed to trust the event.

Hardened HTTP/gRPC Surfaces Auth & Identity Layer Rate & Budget Envelope Strict Request Envelope Deterministic Event Identity
02

Decision layer

Decision & Policy Plane

Policy, safety, calibration, risk, route, authentication, and security signals resolve into an enforceable outcome — allow, degrade, or block — which TCD records as a Terminal Contract.

Safety Detector & Calibration AlwaysValid Risk Controller Policy Binding Strategy Router Security Router Terminal Contract
03

Evidence layer

Governance & Evidence Plane

Receipt issuance, signing and key policy, durable evidence commits, binding checks, audit views, and restart-safe lookup make the governed action checkable outside the original application response.

Signing & Key Policy Canonical Receipt Body Binding Verification Durable Evidence Store Audit & Replay Verification Report
Loop
Governed control-plane mutation loop Policy reloads, key changes, configuration updates, calibration changes, evidence retries, rollback, and compensation leave an auditable record instead of becoming invisible side effects.

Inference Data Plane

Hard ingress boundary with identity and budget controls.

The ingress plane receives live AI traffic through hardened HTTP and gRPC surfaces. It establishes request identity, authentication context, rate limits, body/header budgets, idempotency, and a strict envelope before downstream policy, decision, or evidence components trust the event.

Hardened HTTP/gRPC Surfaces Auth & Identity Layer Rate Limiting & Budget Envelope Strict Request Envelope Deterministic Event Identity
Input Inference request, tenant and subject identity, transport context, payload digest, and idempotency scope.
Control Budgeted envelope, authentication normalization, rate zones, and bounded request surfaces.
Output Governed event with stable identity and content-agnostic anchors for downstream policy and evidence processing.

Reveals deeper implementation controls without exposing private source inventory.

Boundary hardening Strict envelope validation, bounded request surfaces, identity projection, rate budgets, idempotency, and explicit overload behavior.
Statistical control AlwaysValid Risk Controller state, e-process values, alpha-wealth accounting, selected source, and auditable trigger conditions.
Evidence hygiene Illustrative, run-derived, public, verification, audit, and storage materials are separated so proof remains bounded and public-safe.
Failure semantics Allow, degrade, block, binding mismatch, fail-closed behavior, restart-safe lookup, and explicit uncertainty states.
AlwaysValid risk control Runtime risk decisions are not reduced to a single static score.
TCD can update and record controller state around selected actions, including the active mode, selected source, guarantee scope, e-process value, alpha-wealth budget, and risk-budget state. Reviewers can distinguish the business outcome from the statistical guardrail that constrained it.
Terminal Contract enforcement Policy and security signals resolve into one enforceable outcome.
TCD combines policy match, route choice, authentication result, rate evaluation, detector evidence, and security signals into one enforceable outcome — allow, degrade, or block — with enforcement mode and reason semantics. TCD records that normalized outcome as a Terminal Contract.
Signing and key policy Receipt authentication is recorded without overstating the deployment profile.
The v0.1-pilot public release contains illustrative Ed25519 receipts that an external reviewer can verify with public-key material. Those fixtures are not runtime-derived. The historical AML/KYB runtime demo uses HMAC-SHA256 under a local demo profile. The current private runtime has not yet been integrated with the public Ed25519 profile. Production deployments can integrate deployment-specific KMS/HSM or hardware-root evidence where configured and validated.
Durable evidence and restart-safe lookup Receipt references survive process restart in the demonstrated local profile.
The historical run-derived AML/KYB demo uses local SQLite receipt-reference and evidence stores. The service was stopped and restarted using the same durable stores, and the receipt was verified again through receipt-reference lookup without relying on the original in-memory response object.
Governed mutation loop Runtime changes can leave evidence instead of invisible side effects.
Policy reloads, configuration changes, key rotation, calibration updates, runtime patch gates, trust updates, and evidence-delivery retries can be governed through audit events, rollback or compensation paths, and separated business and evidence result states.

Capabilities

What TCD checks, records, and verifies around a selected AI action.

The homepage stays focused on the buyer moment and the proof output. The deeper capabilities remain available for technical review once the workflow, action set, and assurance requirement are clear.

Selected action intake

TCD establishes a bounded request surface for the selected action, including identity, transport context, idempotency, request budgets, rate controls, and stable event identity before downstream systems trust it.

Identity and policy binding

A selected action can be tied to request identity, tenant, subject, workflow, route, policy reference, policy digest, receipt settings, configuration fingerprints, and runtime build identity.

Risk and control state

Detector, calibration, multivariate, and AlwaysValid controller state can be recorded separately from the final business outcome so reviewers can inspect the control context without confusing it with the action itself.

Enforceable outcome

TCD combines policy, authentication, rate, route, detector, and security signals into a concrete allow, degrade, or block instruction with enforcement mode, decision identity, route plan, and reason code.

Authenticated receipt and key evidence

TCD builds canonical receipt material and records the receipt head, signing algorithm, key identity, key-policy status, and verification result. The public v0.1-pilot verifier currently operates on illustrative Ed25519 vectors; the historical runtime-derived AML/KYB evidence remains HMAC-based. Deployment-specific KMS/HSM evidence can be added where configured and validated.

Durable evidence and restart-safe lookup

Receipt references, audit references, ledger or commit references, storage references, and evidence identity can be persisted without storing raw customer payloads. The demonstrated local profile supports receipt-reference verification after restart.

Verification and mismatch detection

Verification can check receipt integrity or authentication, expected policy and configuration context, build or image bindings where supported, key status, and evidence-chain state. A genuine receipt can still fail when an expected governance binding is wrong.

Audit, replay, and runtime changes

TCD supports idempotent evidence flow, replay-safe lookup, bounded chain traversal, explicit failure states, and audited changes to policies, configurations, keys, calibration, patch gates, and evidence-delivery state.

Operational telemetry

Bounded metrics, structured logs, runtime diagnostics, health and readiness checks, and privacy-aware telemetry can support production review without turning operational logs into another location where customer content or secrets leak.

Two-week non-production design study

Define one AML/KYB reviewer contract and test it on synthetic or already-redacted cases.

For one selected handoff, define what QC or FIU must be able to determine from the action package. Measure systems reopened, clarification requests, missing context, claim-to-evidence coverage, expected or benign-activity checks, source and guidance traceability, review time, and receipt completeness relative to an independently supplied eligible-action population — without a production connection, raw customer data, or effect on a real customer decision.