Hash-chain verification: a recomputed tamper status, not a stored flag
Auditrek's hash-chain verification endpoint is GET /api/decisions/:id/verify: it walks the chain for that record's ai_system from sequence 1, recomputes each hash from the stored prev_hash and the record's hashed fields, and returns tamper_status valid or broken.
Auditrek is not open yet, so anything on this page about what it does is what it is being built to do.

The problem with a tamper flag you can edit
Most audit logs answer the tamper question with a column. Something checks the record as it is written, sets a verified field, and every screen afterwards reads that column back. The flag and the record sit in the same database under the same credentials, so whoever can alter the record can alter the judgement on that record, and the flag adds no evidence the record does not already carry.
Auditrek holds each decision record for an ai_system in a SHA-256 hash chain instead. On write, the server computes the record's sequence_number and prev_hash from the last record for that system, computes the record hash as SHA-256 over the previous hash and a canonical set of fields, and stores the fields atomically in one transaction.
One edit breaks every link after it
Change a hashed field directly in the database and the recomputed hash for that record no longer matches the stored hash. Every later record inherits the mismatch, because each was built on the hash of the record before it. There is no single row to flip that makes the chain agree with itself again.
How the verification endpoint works
- You call GET /api/decisions/:id/verify
One request against a single decision record. The work happens server-side; nothing is computed in the browser and nothing is taken on trust from the caller. The server resolves the record, its ai_system and its sequence number before it starts.
- The server walks the chain from sequence 1
Not just the record you named. The endpoint reads that ai_system's chain in order from the first sequence up to the requested record's sequence, so the answer covers the history that record depends on rather than one isolated row.
- Each hash is recomputed from stored material
For every link in that range the server recomputes the hash from the stored prev_hash and the stored hashed fields, repeating exactly the computation the write path performed at ingestion, then compares the result with the hash on record.
- You get tamper_status: valid or tamper_status: broken
Valid when every recomputed hash matches its stored hash across the walked range. Broken when one does not. The status is produced by that walk on that call, which is what makes it different from reading a flag back.
- A broken chain reports where it broke
The response carries the first broken sequence_number, so an investigation starts at a specific record rather than at the whole ledger, and you can see which records came after the break.
The same status surfaces in the app
- Open the decisions list for a system
The decisions list shows the decision records for a selected ai_system, paginated, with columns for sequence_number, created_at, an output summary, confidence and human_override. A compliance officer who will never call the API starts here.
- Press Verify on the record in question
Each row carries a per-record Verify action that calls the verification endpoint and displays the returned tamper_status inline, so the walk from sequence 1 happens behind a button rather than behind a request to an engineer.
- Read the same answer on the dashboard
The web dashboard shows decisions logged, systems connected, last report generated and tamper-verification status, written for a non-technical compliance officer audience. It is the same status the endpoint returns, not a second opinion about it.
Which fields the hash covers, and which it does not
The chain is computed over sequence_number, input_hash, output, confidence, human_override and subject_ref, combined with the previous record's hash. Those six fields and the prior link are what a verify call recomputes, and none of them can change after the write without breaking the chain from that sequence onward.
created_at is not in the hashed set
The decision record's created_at timestamp sits outside the hashed payload as the write path stands. Editing a stored created_at directly in the database changes no recomputed hash, so a verify call over that chain still returns tamper_status: valid. We would rather you read that here than discover it in an examination.
What the chain does fix is order. sequence_number and prev_hash fix the position of each record relative to every record before it for that ai_system, so a record cannot be inserted, removed or reordered without the recomputation failing. Order and clock value are two different claims, and we keep them apart.
Stored flag against recomputed chain walk
| Question | A stored tamper flag | Auditrek's verify endpoint |
|---|---|---|
| Where does the answer come from | A column written at ingest and read back later | A walk from sequence 1, recomputing each hash from the stored prev_hash and hashed fields |
| What can someone with database access do | Edit the record and the flag in the same transaction | Edit a hashed field and the recomputed hash stops matching the stored chain |
| What do you learn when something is wrong | That a field says false | tamper_status broken, plus the first broken sequence_number |
| Which parts of the record are covered | Whatever the writer decided to check | sequence_number, input_hash, output, confidence, human_override and subject_ref, plus the previous record's hash |
| What does the answer say about time | Nothing a reviewer can check independently | Order and position, from sequence_number and prev_hash; the record's created_at value is outside the hashed set today and a verify call will not flag an edit to it |
| What scope does the answer cover | One row at a time | That record's ai_system, sequence 1 through the record's own sequence |
| When is the answer produced | Once, at write time | On every call, from the records as they stand at that moment |
One chain per connected AI system
Decision records are hash-chained per ai_system, and the decisions list shows the records for a selected system with a per-record verify action that calls the endpoint and returns tamper_status inline. Verifying a record walks that system's chain from sequence 1 to that record's sequence, so the system under examination is checked on its own terms and its chain does not depend on the write order of your other models.
What that buys you
The verdict cannot be typed in
There is no tamper field to set. The only way to return valid is for every recomputed hash in the walked range to match the stored hash, which is a property of the stored data rather than an assertion about it.
Order and position are fixed by the chain
sequence_number and prev_hash tie each record to the one before it for that ai_system, so a record cannot be inserted, removed or reordered without the recomputation failing. The record's created_at value is a separate question, and it is outside the hashed set today.
A break has an address
The first broken sequence_number turns a vague worry about the log into a specific record and a specific point in that system's history, which is the difference between an investigation you can scope and one you cannot.
Chains are scoped per AI system
Records are chained per ai_system, so the system under examination can be verified on its own terms without the chains of your other connected models entering the computation.
Verification runs off the stored ledger
The verify endpoint reads records already held in Auditrek. Capture is a separate REST and webhook ingestion API, so a verification call is a read against stored records and not something your models have to take part in.
What verification covers, and what it does not
Verification is a custody check on records after ingestion. It answers whether the hashed fields of the stored decision records for one ai_system still hash to the chain they were written into, and it names the first sequence where they stop doing so. A record carrying a wrong confidence value verifies as valid if nobody altered it after the write.
What reaches the chain is minimised before any of this. The ingestion API accepts an inference event payload of input hash, model id and version, output, confidence, timestamp and human override flag, and a data-minimisation gate at ingestion rejects payloads with recognisable raw sensitive fields and pseudonymises subject identifiers by default. A system cannot be connected, and no API key or webhook secret is issued, until a DPA confirmation with a signed_at value is recorded.
The result feeds the paperwork rather than replacing it. The report generator produces PDF and HTML output for a chosen system and date range, structured against EU AI Act Article 12 and Article 13 fields, and every report carries an embedded disclaimer stating that it does not constitute legal advice and has not been reviewed by qualified regulatory counsel. What a given obligation requires of your organisation remains a judgement for your counsel.
Where this sits today
Auditrek is in build, and access opens through the waitlist. The verification endpoint described here is part of the first release scope: a server-side walk of the chain, recomputed on request, returning a tamper status and the first broken sequence_number rather than a stored verdict. The hashed field set is the six fields named above, and this page will say so for as long as that is what the write path does.
Ingestion is a generic REST and webhook layer with documented payload mapping guides for AWS SageMaker and Azure ML, so nothing has to change in how your models serve and there is no bespoke platform SDK to adopt. Auditrek runs on Amazon Web Services, and people sign in with email and password.
One email when it launches. Join the waitlist and we send the payload schema, the verification endpoint documentation and a sample report mapped to Article 12 and 13 fields. For the background first, our guide to tamper-evident audit logs and hash chains covers the mechanism for a non-technical reader, the decision record capture page sets out the payload the chain is built from, the data minimisation page covers the gate at ingestion, the SageMaker mapping page shows how inference events map onto a record, and the page written for ML engineers covers logging decisions without touching the inference path.
Who is behind it
Auditrek is the product described on this page. The site's terms and privacy policy name the company that sells it, and hello@kaleidoapps.com reaches that company for a security problem or a request about a person's data.
Questions
What exactly does the verification endpoint return?
GET /api/decisions/:id/verify returns tamper_status: valid or tamper_status: broken for the chain belonging to that record's ai_system, walked from sequence 1 to the record's own sequence. When the status is broken, the response also carries the first broken sequence_number, so an investigation starts at a named record rather than at the whole ledger. The status is recomputed by the server on each call rather than read back from a stored flag alone, which is the distinction a reviewer draws: a flag written at ingest sits in the same database, under the same credentials, as the record it describes, so whoever can alter the record can alter the judgement on it.
Which fields are covered by the hash chain?
The hash is computed over the previous record's hash plus sequence_number, input_hash, output, confidence, human_override and subject_ref. Altering any of those six after the write makes the recomputed hash diverge from the stored one and breaks the chain from that sequence onward, and every later record inherits the mismatch because each was built on the hash of the record before it. There is no single row to edit that makes the chain agree with itself again. The record's created_at timestamp is not in that set today.
Can someone change when a decision was logged without it showing?
As things stand, an edit to the record's created_at value alone is not caught by the chain: created_at is outside the hashed payload, so a verify call over that chain still returns tamper_status: valid. If your control objective is demonstrating that the recorded time of a decision has not been moved after the fact, the hash chain as it exists today is not the control that does it. What the chain does fix is order, because sequence_number and prev_hash place each record relative to every record before it for that ai_system, so records cannot be inserted, removed or reordered without the recomputation failing. The exclusion is stated here because it changes which control you rely on.
How is the chain built in the first place?
On POST /api/decisions the server computes the record's sequence_number and prev_hash from the last record for that ai_system, computes the record hash as SHA-256 over the previous hash and the canonical hashed fields, and stores the fields atomically in one transaction, returning the created record with its hash and sequence number. Because the computation on the verify path repeats the computation on the write path exactly, consistency of any one record depends on every earlier link for that system.
Does verifying a chain touch my production inference path?
No. Verification is a separate endpoint that reads records already stored in Auditrek. Events arrive over the REST and webhook ingestion API, with documented payload mapping guides for AWS SageMaker and Azure ML and no bespoke platform SDK, so neither capture nor verification requires changing how your models serve. A verification call is a read against stored records, which is why it can be run as often as a reviewer asks.
Can I verify a whole system rather than one record?
The endpoint is addressed by decision record, and each call walks that record's ai_system from sequence 1 up to that record's sequence. Verifying the most recent record for a system therefore recomputes the chain up to that point. Records are chained per ai_system, so the system under examination is verified on its own terms and its chain does not depend on the write order of your other models. The decisions list also carries a per-record verify action that calls the same endpoint and shows the status inline.
Does a valid status prove we meet EU AI Act obligations?
No. A valid status means the hashed fields of the stored records for that ai_system are internally consistent and unaltered since they were written. It is a custody statement, not an accuracy statement: a record carrying the wrong confidence value verifies as valid if nobody altered it after the write. Auditrek's reports are descriptive, structured against Article 12 and Article 13 fields, and carry an embedded disclaimer that they do not constitute legal advice and have not been reviewed by qualified regulatory counsel.
What happens to sensitive fields before they are hashed?
A data-minimisation gate at ingestion rejects payloads containing recognisable raw sensitive fields and pseudonymises subject identifiers by default, so the record entering the chain is a minimised one rather than a copy of your production data. Raw model inputs never arrive; what is stored is an input hash, the output, confidence, a human override flag and a pseudonymised subject reference. Connecting a system also requires a recorded DPA confirmation with a signed_at value before any API key or webhook secret is issued.