Decision record capture: one API call per inference event
If you are looking for an AI decision logging API, this is the write path: one REST call or one webhook per inference event, carrying input hash, model id and version, output, confidence, timestamp and a human override flag. Auditrek stores each event as a link in a SHA-256 hash chain, append-only, kept separately for every AI system you connect.
Auditrek is not open yet, so anything on this page about what it does is what it is being built to do.

The distance between an application log and a piece of evidence
Ordinary logs are mutable by design.
You almost certainly log inference already. The line lands in a cloud log group, a warehouse table, or a tracking run beside the experiment that produced the model. It is enough to debug a bad prediction on a Tuesday afternoon, and not enough when someone outside your organisation asks whether the record in front of them is the record that was written at the time.
Auditrek's decision logging API narrows that gap at the point of capture. One call per inference event, and the event is written as a link in a SHA-256 hash chain held per AI system, append-only, with nothing in the design asking you to route inference through Auditrek: the call is made from your own code after your model has already returned.
One decision record, field by field
| Field | Where it comes from | Why it is in the record |
|---|---|---|
| Input hash | You send it | Identifies the input that produced this decision without moving the input itself into the ledger. |
| Model id and version | You send it | Ties the decision to the exact artefact that made it, so a later retrain does not blur which model decided what. |
| Output | You send it | The decision as your system expressed it. |
| Confidence | You send it | The score attached to the output at the moment it was produced. |
| Timestamp | You send it | When the event occurred in your system, as your system recorded it. Stored with the record, and outside the hashed payload, as the next section sets out. |
| Human override flag | You send it | Whether a person changed or overrode the model's output, captured as a field rather than reconstructed from a ticket later. |
| Subject reference | You send it, pseudonymised by default at ingestion | Lets you group decisions about the same subject without carrying a raw identifier into the ledger. |
| Sequence number | Computed server side | Position in that AI system's chain, derived from the last record written for the same system. |
| Previous hash | Computed server side | The hash of the preceding record, which is what makes the chain a chain. |
| Hash | Computed server side | sha256 of the previous hash concatenated with this record's canonical payload. |
A worked call: one credit decision on retail-credit-scoring
| POST /api/decisions | 201 Created |
|---|---|
| { | { |
| "model_id": "credit-risk", | "id": "8c3f0a21-...", |
| "model_version": "4.2.1", | "ai_system": "retail-credit-scoring", |
| "input_hash": "9f2c4b...", | "sequence_number": 1184, |
| "output": "refer", | "prev_hash": "4e1b7d...", |
| "confidence": 0.82, | "hash": "a07d93...", |
| "timestamp": "2026-11-17T09:14:02Z", | "input_hash": "9f2c4b...", |
| "human_override": true, | "human_override": true |
| "subject_ref": "sub_7d41c9e0" | } |
| } |
What the hash actually covers, and what it does not
The chain is evidence of content and order, not of clock time.
The canonical payload that goes into each record's hash is the sequence number, the input hash, the output, the confidence value, the human override flag and the pseudonymised subject reference. Change any of those in the store after the fact and the recomputed hash no longer matches, the link to every later record is severed, and server-side verification returns a broken status rather than a valid one.
The stored timestamp sits outside that canonical payload. It is captured, it is returned, and it is available for reporting, but editing it in the database does not change the record's hash, so verification would still come back valid. We would rather write that sentence here than let you discover it in an examination.
How a decision record is written
- Your service posts the event
After the model returns, your code sends the payload to the decisions endpoint over REST, or your platform fires it at the webhook endpoint issued for that AI system. One event, one call. The call sits outside the request that served the prediction, so the model's own latency budget is yours to spend elsewhere.
- Auditrek reads the tail of that system's chain
The server looks up the last record written for the same AI system and derives two things from it: the sequence number this record will take, and the previous hash it will be linked to. Chains are kept per AI system, so retail-credit-scoring and a triage model do not interleave into one ambiguous stream.
- The hash is computed over the previous hash plus the canonical payload
The record's hash is sha256 of the previous hash concatenated with the canonical payload: sequence number, input hash, output, confidence, human override flag and pseudonymised subject reference. Every record therefore commits to the canonical content of the one before it, and through that record, to every record before that. The stored timestamp is not part of that computation.
- All fields are stored atomically in one transaction
Sequence number, previous hash, hash and payload are written together or not at all. There is no window in which a link exists with a sequence number but no hash, which is the state that would quietly poison every recomputation performed afterwards.
- You get the record back with 201
The response carries the created record including its hash and sequence number. Keeping that pair in your own system, next to your own log line, gives you a value you can compare against later without asking Auditrek to be the only witness to what Auditrek stored.
What the write path gives you that a log line does not
Order is part of the record, not a property of the query
Sequence numbers are assigned server side from the previous record for that AI system, and the sequence number is inside the hashed payload. The order in which decisions were captured is a stored, chained fact rather than whatever a SELECT with an ORDER BY clause happens to return the day someone asks.
Editing a chained field breaks arithmetic, not a status column
Because each hash is computed from the previous hash and the canonical payload, altering an output, a confidence value or an override flag after the fact changes that record's hash and severs its link to every record written after it. There is no tamper flag to flip, because there is no tamper flag. The stored timestamp is the field this does not cover.
Raw inputs can stay where they already live
The record carries an input hash rather than the input, and subject identifiers are pseudonymised by default at ingestion. For pipelines making credit, hiring or clinical decisions, that keeps the identifying payload inside the system that is already governed for it, while still tying each ledger entry to a specific input.
Human oversight is a field, not an archaeology project
The human override flag travels with the event and is inside the hashed payload. When a reviewer later asks how often a person intervened on a given system in a given quarter, the answer is in the same records as the decisions, captured at the moment it was true.
One integration shape for every system
REST and webhook ingestion accept the same payload structure, so adding the fifth AI system is the same piece of work as the first, whoever built it and whatever it runs on.
What this endpoint deliberately does not do
Capture is one layer, and this page describes only that layer.
- It does not make or influence a decision. Your model produces the output, your reviewers override it, and Auditrek records what happened after both have finished.
- It does not interpret the record. A decision record states what an AI system did and in what order. It does not assert whether that was adequate, and nothing Auditrek produces is legal advice or a substitute for review by qualified regulatory counsel.
- It does not replace your existing observability. Keep your logs, and keep them timestamped. The ledger answers a narrower question, which is whether the hashed fields of a specific set of decision records are still exactly as written, in the order they were written.
- It does not ship native platform SDKs in this release. Ingestion is a generic REST and webhook layer with documented payload mapping guides for AWS SageMaker and Azure ML, so the mapping from your existing event fields is a one-off piece of work per system rather than a vendor library in your inference code.
- It does not issue credentials to an unpapered system. No API key and no webhook secret exists for an AI system until a data processing agreement confirmation with a signed date is recorded against it, and that check is enforced server side, so connection is gated rather than merely recommended.
Auditrek is in waitlist ahead of launch, so what is described here is the capture path as built, not a claim about how many events anyone is sending through it today.
Questions
Why isn't a cloud log group or a warehouse table enough?
Ordinary logs are mutable by design: they are ordered by insert time or by whatever clock wrote them, and nothing ties one line to the line before it. Anyone with write access to the store can change a confidence score, adjust an output or remove a row, and the remaining rows look exactly as they did before. That is a fine property for telemetry and a poor one for evidence. Article 12 of the EU AI Act is written in the language of record-keeping and logging for high-risk AI systems, and both the regulation and the article text are linked at the foot of this page so you can read the wording rather than our summary of it.
What exactly does the decision logging API accept?
An inference event payload containing an input hash, model id and version, the output, a confidence value, a timestamp and a human override flag, with a pseudonymised subject reference where you have one. REST and the webhook endpoint accept the same payload and produce the same record: a REST call suits a code path you control, the webhook suits a platform that already emits events. Auditrek adds the sequence number, previous hash and hash on the server side before storing the record.
How is the hash computed?
Each record's hash is sha256 of the previous record's hash concatenated with that record's canonical payload: sequence number, input hash, output, confidence, human override flag and pseudonymised subject reference. The previous hash and the sequence number both come from the last record written for the same AI system, so every system keeps its own independent chain.
Does the hash chain cover the timestamp?
No. The timestamp you send is stored with the record but sits outside the hashed canonical payload, so editing it in the database would not break the chain and verification would still return a valid status. If the precise moment of a decision is load-bearing for you, keep your own timestamped log line beside the hash and sequence number the API returns, so two independent systems carry the same time.
Do I have to send raw applicant, customer or patient data?
No. The record is designed around an input hash rather than the input itself, and subject identifiers are pseudonymised by default at ingestion, so the identifying payload can stay inside the system that already holds it while the ledger entry still points at one specific input. The data minimisation gate at ingestion is described on its own page.
Does Auditrek sit in the production inference path?
No. You call the API after your model has returned its output, from your own code or from your platform's event mechanism. There is no model migration and no proxy in front of the endpoint that serves your predictions, and the documented mapping guides for SageMaker and Azure ML exist to work out which of your existing event fields go where.
Where does Auditrek run?
Auditrek is hosted on Amazon Web Services.
Can I start sending events today?
Not yet. Auditrek is on a waitlist ahead of launch, and the capture path described here is what it is built to do. Joining the waitlist is the way to be told when systems can be connected.