Home / Features

Data minimisation for AI decision logging

If you are logging AI decisions from credit, hiring or clinical pipelines, the log itself becomes a second copy of your most sensitive data. Auditrek enforces data minimisation at the ingestion API: payloads carrying recognisable raw sensitive fields are rejected with a 422 before anything is written, and subject identifiers are pseudonymised by default.

Auditrek is not open yet, so anything on this page about what it does is what it is being built to do.

Auditrek: Data minimisation for AI decision logging

The log becomes the second copy of your most sensitive data

A decision log for a credit adjudication model, a CV screening model or a clinical triage model is, by construction, a second store of the data the model saw. The inference payload your pipeline already emits tends to carry more than the fields anyone documented: an applicant identifier in raw form, a bureau tradeline that was never redacted, a diagnosis code inside a feature blob nobody has audited.

Route that into an append-only ledger and you have built the one thing you did not want. The ledger has to be immutable to be worth presenting as evidence of what a system decided and when, and immutability is what makes a stray diagnosis code expensive: the record's hash depends on its payload, so there is no quiet edit and no tidy deletion.

Teams meet this trade-off early in a logging project, at the point where someone asks whether it would be simpler to send the whole request body and sort the fields out later. Auditrek's position is that the control has to sit at the door rather than in a retention policy or a runbook. The ingestion API is the narrowest point in the whole path, it is the only place where a payload can be refused before it exists as a record, and it is server-side, so no client library, no mis-mapped webhook and no helpful curl command can route around it.

How the gate works on the ingestion path

  1. Your pipeline posts a decision record

    The event goes to POST /api/decisions as a decision record payload: input hash, model id and version, output, confidence, timestamp and human override flag. Nothing in Auditrek reads from your inference path, so the shape of what leaves your pipeline is still your mapping decision.

  2. Server-side pattern validation inspects the payload

    Before any write, the endpoint inspects the payload for recognisable raw sensitive-field patterns: social security number formats, diagnosis code patterns such as ICD-10, and unredacted credit bureau fields. The scan covers field names and every string value in the payload, including the free-text output field. It runs on the server, on every request, and cannot be satisfied from client-side state.

  3. A match is rejected with 422 and a clear error body

    The request fails with HTTP 422 and an error body naming the field and the pattern that tripped the check, so your engineer can fix the mapping. The rejection happens before any database write, which means there is no record to delete, no chain to rebuild and no erasure question about data you never accepted.

  4. Accepted payloads keep a pseudonymised subject reference

    Pseudonymisation of subject identifiers is the default rather than an option someone has to remember to switch on, and the stored record carries a subject reference so decisions about the same subject can still be grouped inside the ledger. Know this before you map the field: a subject_ref that is itself an identifier, an email address for example, is rejected with 422 and the pattern name email_pattern rather than accepted and pseudonymised on receipt. Derive the reference in your pipeline and send the derived value.

  5. The clean record enters the hash chain

    Only once the payload passes does it become a decision record: a sequence number and previous hash are computed for that ai_system, the SHA-256 hash is written atomically, and the record joins the append-only chain for that system.

What the ingestion check acts on

Pattern familyHow it tends to arriveResult at ingestion
Social security number formatsA raw identifier copied into an output or feature fieldRejected with 422, no database write
Diagnosis code patterns such as ICD-10A clinical code carried inside a model output or feature blobRejected with 422, no database write
Unredacted credit bureau fieldsBureau response data passed through from an adjudication serviceRejected with 422, no database write
A subject reference that is still identifyingAn email address or similar sent straight through as subject_refRejected with 422, so derive the reference before you send it
Everything your mapping does sendThe fields you chose to emit from the inference eventPseudonymised subject reference, hash-chained, append-only

What that buys you

Nothing to unpick later

Because the rejection lands before the write, a bad payload never becomes an immutable record. You are not choosing between the integrity of a hash chain and an erasure request.

The failure is loud, and it is loud early

A 422 naming the field and the pattern surfaces in your staging pipeline while an engineer is still holding the mapping, rather than in a document review months after the fact.

Pseudonymisation is the default, not a setting

Subject identifiers are pseudonymised on the way in, so the default behaviour of the system is the behaviour you would otherwise have had to enforce with policy and code review.

A control you can describe precisely

When someone asks what stops sensitive data entering the ledger, the answer is a named server-side check on a named endpoint with a named response code and a named pattern, not an assurance about internal practice.

It sits beside the consent gate

An ai_system cannot be connected at all, and no API key or webhook secret is issued, until a dpa_confirmation with a signed_at timestamp is recorded. The connect endpoint enforces that server-side and returns 403 if it is unsigned. The ingestion gate is the technical half of the same posture.

Where the check reaches today, and where it does not

We would rather you learned the edges of this control from us than from a 422 at three in the morning, so here is what the current implementation does and does not catch.

  • Field names are matched on separated segments. The key pattern anchors on underscore and hyphen boundaries, which means a camelCase field name is not recognised by its name. We have run them: patientSSN, dateOfBirth, emailAddress, firstName and cardNumber all pass the key check. What catches those cases is the value scan, not the name.
  • The value scan has its own gap. Separated card number forms match, but a contiguous sixteen-digit primary account number passes. A raw PAN sitting in an output string can therefore be stored and hashed, and a hashed record is permanent. Name your fields with separated segments and strip card data in your mapping; do not rely on the scan to find it.
  • It is strict enough to produce false positives. Because the scan reads every string in the payload including the free-text output field, realistic model outputs can trip it. An output of "tier A12.5 approved" is rejected with the pattern name icd10_diagnosis_code_pattern. If your outputs carry alphanumeric tier or band codes, test them against the endpoint before you wire a production system to it.
  • Rejections are not yet shown in the dashboard. The compliance dashboard shows decisions logged, systems connected, last report generated and tamper-verification status. A refused payload is visible to the caller in the 422 response, so the ingestion response is the thing to watch and alert on while you are mapping fields, and a run of rejections will show up as a count that stops climbing rather than as an alert.

The practical conclusion is the same one most teams reach anyway: derive the fields you send. Hash the input before it leaves your pipeline, send a reference rather than an identifier, and keep free-text out of the output field unless you have checked it. The gate is there to stop the mistakes, not to do the mapping.

What this control asserts, and what it does not

Auditrek records what an AI system did and when. The ingestion gate is a technical control on what the ledger will accept, and it is described here in exactly those terms.

It is not a determination about your lawful basis, your retention schedule, or whether your documentation satisfies any obligation. Auditrek's report generator produces PDF and HTML output for a chosen system and date range, mapped to EU AI Act Article 12 and 13 fields, and every generated report carries an embedded disclaimer stating that it does not constitute legal advice and has not been reviewed by qualified regulatory counsel. That is deliberate. The judgement about sufficiency belongs to you and your counsel; our job is to make the underlying record specific enough to be worth judging.

Two more things we will not imply. There is no independent security audit or certification such as SOC 2 or ISO 27001 behind this product today, and there has been no independent cryptographic review of the hash chain implementation. Both are absent rather than pending a press release.

The division of labour is simple. You decide which fields your pipeline is permitted to emit, and you keep any mapping from a pseudonymised subject reference back to a person inside your own systems. Auditrek refuses what it recognises as raw sensitive data, pseudonymises subject references, and chains what it accepts.

Where this sits today

Auditrek is in build and the waitlist is open. The data-minimisation gate is part of the ingestion path as specified rather than a later hardening step, because a ledger that accepted raw sensitive fields for its first month would carry that month forever.

The product is hosted on Amazon Web Services in a single region, with no multi-region replication and no choice of data residency. People sign in with email and password, with multi-user access scoped to the organisation, and there is no single sign-on.

If you are scoping a decision-logging project for a credit, hiring or clinical model and the open question is what your pipeline is allowed to send, join the waitlist and tell us which fields you are trying to keep out, and which output strings you are worried the scan will refuse. Those are the payload shapes we most want to test against before launch.

Questions

What counts as a raw sensitive field?

The ingestion check inspects field names and string values for recognisable raw sensitive-field patterns: social security number formats, diagnosis code patterns such as ICD-10, and unredacted credit bureau fields. It is pattern recognition on known shapes, with known edges (segment-anchored field names, and a contiguous card number that the value scan does not match), so treat it as a floor underneath your own field mapping rather than a substitute for it.

What does the API return when a payload is rejected?

POST /api/decisions returns HTTP 422 with an error body naming the field and the pattern that tripped the check, for example subject_ref: email_pattern. The rejection happens before any database write, so no partial record, no sequence number and no hash entry is created for that request.

Will the gate reject payloads it should accept?

It can. The scan reads every string in the payload, including the free-text output field, so an output such as "tier A12.5 approved" is rejected with icd10_diagnosis_code_pattern. If your model outputs carry alphanumeric tier or band codes, post a few real examples at the endpoint before you connect a production system, and note that refusals are not yet surfaced in the dashboard.

Can the check be bypassed by a client integration?

The validation runs server-side on the ingestion endpoint, on every request, rather than in a client library or a form, so there is no client-side state a caller can set to skip it. What a caller can do is send a field name the key pattern does not recognise, such as a camelCase name like patientSSN, in which case only the value scan stands between that payload and the chain.

If subject identifiers are pseudonymised, can I still trace a decision back to a person?

The stored record carries a pseudonymised subject reference, so decisions about the same subject stay groupable inside the ledger, and any mapping from that reference back to an identified person stays in your systems. Send a reference you have already derived: a subject_ref that is still an identifier, such as an email address, is refused with a 422 rather than accepted and pseudonymised on receipt.

Do I need a Data Processing Agreement before I can send anything?

Yes. An ai_system cannot be connected until a dpa_confirmation with a signed_at timestamp is recorded, and no API key or webhook secret is issued before that. The connect endpoint enforces it server-side and returns a 403 with a descriptive message if it is unsigned.

Does this mean my logging meets EU AI Act record-keeping obligations?

We do not make that claim. Auditrek's report generator produces output for a chosen system and date range mapped to EU AI Act Article 12 and 13 fields, and every report embeds a disclaimer stating that it does not constitute legal advice and has not been reviewed by qualified regulatory counsel. Whether your records are sufficient is a judgement for you and your counsel.

Where does the data live, and how do users sign in?

Auditrek is hosted on Amazon Web Services in a single region, with no multi-region replication and no choice of data residency. People sign in with email and password, with multi-user access scoped to the organisation, and there is no single sign-on.

Join the waitlist

Leave your work email and we will send the payload schema, the verification endpoint documentation and a sample Article 12 and 13 report before you talk to anyone. Pilot cohort conversations start with your own pipeline, not a demo script.

One email when it launches, and one now to confirm your address. Unsubscribe any time. Privacy.