Entropa_

A signed record of every AI decision that anyone can verify.

The Entropa Audit Trail is a free, tamper-evident, post-quantum-signed record of what an AI system decided. It stores only hashes and fixed codes, never your data. Independent witnesses and an offline verifier mean you do not have to trust us, or whoever runs it. It is the proof half of Entropa: the Entropa Gate decides and enforces, and writes to the Audit Trail. The Audit Trail also works on its own for any AI system.

Rust · post-quantum (ML-DSA-65) · hash-only · verify offline

Two parts, one mission

The Gate decides and enforces. The Audit Trail records and proves. Each has its own page, so you can see exactly which part does what.

Decides and enforces. It limits what an AI can read, checks what leaves, and asks a person to approve big actions. The primary product.
Status: the parts are built and measured (some fail their own tests, and we say so); the single installable package is in progress.
Open this page →
Entropa Audit TrailAudit Trail (you are here)
Records and proves. A tamper-evident, post-quantum-signed record of every decision, with independent witnesses and an offline verifier. The Gate writes to it; it also works on its own for any AI system.
Status: built and running for our own systems.
This page

The problem

AI systems now decide things people are asked to justify later: whether a claim is denied, whether a transaction is flagged, which patients get a follow-up. When an auditor, a regulator or a patient asks "what did the system decide, and under which policy?", "trust our logs" is not proof. A database row can be edited after the fact. You need a record that holds up, and that anyone can check.

How it works

Every AI decision you send is signed into the log, so nothing depends on trusting your own database. The whole path, end to end:

1
Your agent acts
It decides something, approves something, does something real — any action you need governed.
→
2
The node hashes it
Your node hashes the question and the answer and drops the text. Only the hash, closed codes and model counts are kept.
→
3
Submit the hash
One plain JSON POST — any language, no SDK. The reply carries the event hash and the new checkpoint size, so your system is never stuck waiting.
→
4
It's appended to the log
Your record becomes a leaf in a Merkle transparency log — cryptographically hashed and chained.
→
5
A checkpoint is signed
The log's current root is signed into a checkpoint — the one thing every later proof gets checked against.
→
6
Anyone can verify
Check the signature and the Merkle proof with the public key alone. Tamper with a record and the proof breaks.
Run your own node →

We never see your customer data

Your node hashes the question and the answer and drops the text. Only the hash, closed codes (decision and reason), the model id and token counts are stored — never names, account numbers, health or transaction detail. Text that looks like a real identifier is refused outright. That is structural, not a policy promise: there is nothing sensitive in the ledger to find.

For a bank running third-party risk management under guidance like OCC Bulletin 2013-29, that matters directly: a vendor that structurally cannot access sensitive data is a fundamentally lighter due-diligence lift than one that stores it and promises to protect it.

A readable trail, in closed codes

Events carry codes from a fixed list, not free text, so nothing sensitive can be written by mistake — and the trail still reads like an audit trail:

nl_query : allow : guard_passed      (question turned into safe, read-only SQL)
nl_query : deny  : guard_refused     (the SQL guard blocked a query)
ml_score : info  : within_limits     (a model score, no raw features)
rag_answer : allow : cited_receipts  (an answer that cited its sources)

The code is just as tamper-evident as the hash: it is signed into the same record.

How the Audit Trail works

A decision becomes a signed, hash-only record in an append-only log that anyone can check.

A decisionfrom any AI system,or from the Gate Your nodechecks closed codes, refusesidentifier-shaped data, hashes,signs with ML-DSA-65 Ledgerappend-only Merkle log,signed checkpoints Witnessoptional, independent,co-signs checkpoints Explorerread-only view of the ledger Offline verifierchecks proofs, trusts no one You hold the keys and the records. A witness or your auditor holds an earlier checkpoint, so nobody can quietly rewrite history.

Under the hood: how we run our own node

This is how we run our own node in the cloud, for our own records. Your app runs on your Linux machine instead. Rust, small on purpose: a stateless ingest tier, exactly one writer that signs, an append-only store and static, read-only verification. It replaces an earlier Java, Spring and Kubernetes stack (archived), and costs a fraction to run because nothing runs when nothing is happening.

AI system POST /v1/decision Cedar policy gate human approvals for hard actions Ingest stateless · private refuses identifier-shaped data Signing key Cloud KMS (managed key) ML-DSA-65 Single writer signs the event + checkpoint Merkle log (RFC 9162 style) Append-only store object storage records · checkpoints Witness independent co-signer of checkpoints Explorer + verifier read-only · static proofs checked in the browser Serverless · Cloud Run · scales to zero · one writer instance no cluster to run · pay per request · same node runs on-prem as a single binary or container
Run your own node → AI Audit Explorer →

Trust is proven, not claimed

Once a record is signed and a copy of an earlier checkpoint is held by someone other than the operator (an independent witness, your auditor or a second machine), it can't be silently altered or removed, even by the person running the app: the check fails. On a single machine with no outside copy, the operator who holds the key could rewrite everything, so the records are tamper-evident, not tamper-proof.

Data-minimal by design
Only hashes, closed codes and model counts are stored. Identifier-shaped text is refused, so the ledger cannot leak what it never held.
Append-only, checkpointed
Each record is folded into a signed checkpoint over the log's current root. A later record can never rewrite an earlier one's proof — the math that makes the checkpoint valid depends on it.
Cryptographically signed
Checkpoints are signed and independently verifiable — every proof can be checked against the signed root, not just claimed.
Independently verifiable
Every record page runs and displays a real inclusion-proof and signature check — the actual cryptographic result, not just a claim about it.
Transparent to a fault
Every real incident — bugs, mistakes, architecture decisions we later reversed — is documented publicly with root causes and fixes, not summarized after the fact.

Evidence mapped to these controls

Every one of these standards asks you to keep records of what your systems did and to protect those records from alteration. Entropa produces signed, witnessed records you can verify offline. We read each clause in the primary text; this is evidence mapped to a control, not an assessment or a certification, and none of these clauses names a post-quantum signature: that is our choice for records that must stay verifiable for years. See the Trust & Controls page.

DORA RTS 2024/1774, Article 12(2)(d)
Asks for "measures to protect logging systems and log information against tampering, deletion, and unauthorised access". A signed, witnessed ledger is evidence for that measure.
PCI DSS v4.0.1, 10.3.4 and 12.3.3
10.3.4: change-detection on audit logs "to ensure that existing log data cannot be changed without generating alerts". 12.3.3: a cryptographic inventory, reviewed at least every 12 months. Tamper evidence and a crypto inventory of our own estate are evidence for these.
NIST SP 800-53 Rev 5, AU-9(3) and AU-10 (High baseline)
Cryptographic protection of audit information and non-repudiation. ML-DSA-65 signatures and offline verification are evidence for these.
EU AI Act, Articles 12 and 19
High-risk AI systems "shall technically allow for the automatic recording of events (logs)", kept at least six months. Check the current text for application dates.
HIPAA Security Rule, 164.312(b) and (c)(2)
Audit controls that "record and examine activity", and a mechanism to corroborate that data has not been altered.

What is built, in progress and planned

Signed Merkle ledger, node and witness · Built
Append-only log, ML-DSA-65 signatures with a managed cloud key, signed checkpoints, inclusion and consistency proofs. An independent witness on AWS co-signs checkpoints (the earlier Azure witness was retired).
Explorers and offline verifier · Built
Read-only explorers for our own records, an in-browser verifier, and an offline command-line verifier. A one-byte change to a record makes verification fail (demonstrated in our self-assessment).
Controls evidence and self-assessment · Built
Event types for crypto inventory and log-integrity checks, and a published control-by-control assessment of our own estate with the gaps listed first.
Your own explorer and dashboard · In progress
A static explorer generated from a ledger exists and is tested on mock data; no real-browser pass or pilot yet.
Holding against the operator · In progress, measured
Built and tested: you export an outside copy of a checkpoint (to a second machine or to your auditor) and the check then detects a rewrite, a rollback or a fork of the log, refuses malformed or tampered files, and says plainly when there is no outside copy to compare with. Three sealed attack rounds ran against it; each found a real gap and each was fixed (results page has the numbers). Still to come: a non-exportable signing key, host separation and an optional public timestamp. Without an outside copy, an operator who holds the key can still rewrite one machine; that case is stated, not hidden.

Run your own node

A node is one small Rust program that signs and stores your AI decisions. You keep the key and the data. It runs in the cloud (we run it on Cloud Run, one instance, scale to zero) or on-premises as a single binary or container. The source code is open source under Apache-2.0: github.com/aimozart/entropa-gate.

entropa-platinum init   ./node        # creates the key and the ledger
entropa-platinum log    ./node < decision.json   # one signed event + checkpoint
entropa-platinum verify ./node        # OK records=1 checkpoints=1
entropa-platinum serve  ./node        # HTTP ingest: POST /v1/decision

Add a caller in any language: build the JSON, POST it. Run the service privately and let your platform authenticate callers. For anything beyond a pilot, keep the key in a managed KMS.

Free. The node is free and open source (Apache-2.0). Contact us to arrange a pilot.

Getting started with the Audit Trail

Run it on a Linux machine you control. No accounts, no sales call.

1. Get a node Binary or container, cloud or on-prem 2. Create a key One command, stays with you 3. Send decisions One JSON POST, any language 4. Signed checkpoint ML-DSA-65 over the Merkle root 5. Verify anywhere Explorer or your own verifier
Run your own node →

Why Rust, and where we use other languages

Everything that makes a security decision or signs a record is written in Rust: the ledger, the signing and verifying, the policy gate, the Egress Guard, the access tokens, the standards retrieval and the servers. Rust is the key to the whole project. Other languages play supporting roles only.

Memory safety, by construction
Most serious vulnerabilities in systems code are memory bugs (buffer overflows, use-after-free). Rust rules out that whole class in safe code, which matters most in software whose job is to be trusted.
One small static program
Rust builds a single, self-contained Linux binary with no runtime to install and few dependencies, and we rebuild it reproducibly so you can check that what you run matches the source.
The compiler as a reviewer
Strict types, explicit error handling and no hidden null values push whole categories of mistakes to compile time, and make "fail closed" the natural way to write a guard.
Fast and predictable
No garbage-collector pauses, so checks on every request stay quick and steady, and the same code can run on a small machine you own.
Supporting languages
Python for test runners and analysis scripts, shell for build and packaging, and a little JavaScript for the in-browser verifier. None of them sign records or make decisions. By GitHub's count about 84 percent of the repository is Rust.
What Rust does not do for us
Safe Rust does not remove logic errors, bad design or weak cryptography choices, and the project is a research prototype with no independent review yet. Our own sealed tests still find real bugs, and we publish them.

Frequently asked questions

What is the Entropa Audit Trail?

A free, tamper-evident record of every AI decision. Each decision becomes a hash-only record signed with a post-quantum signature (ML-DSA-65), appended to a Merkle log with signed checkpoints. Anyone can verify the record offline, without trusting the operator. It is the record-keeping part of Entropa; the Gate is the enforcing part.

Is it a blockchain or a cryptocurrency?

No. There is no token, no mining and no consensus network. It is a signed, append-only Merkle log, the same idea as certificate transparency logs, with optional independent witnesses.

Can the person who runs it change the records?

Not silently, once someone else holds an earlier checkpoint (an independent witness, your auditor or a second machine): any change makes the check fail. On a single machine with no outside copy, an operator who holds the key could rewrite everything, so we say tamper-evident, not tamper-proof.

What do the records contain?

Only hashes and fixed codes, never the text of your questions or answers. Text that looks like an identifier is refused before anything is recorded. You compute the hashes yourself; we never see your data.

Can I use it without the Gate?

Yes. Any system can send a decision to your node and get a signed record. The Gate is the part that decides and enforces and it writes to the Audit Trail, but the Audit Trail does not need the Gate.

Is it certified or compliant with a standard?

No. Evidence is mapped to specific clauses (DORA, PCI DSS, NIST SP 800-53, the EU AI Act, HIPAA) and the gaps are published first in our own self-assessment. It is not a certification, and no independent review has been done yet.