Home / Who it is for

Logging AI decisions without touching the inference path

Auditrek logs AI decisions from outside the inference pipeline: your service posts an event to a REST endpoint, or your platform fires a webhook, after the prediction has already gone back to the caller. There is no bespoke platform SDK in this build, so the integration is an outbound HTTP call from code you already own rather than a change to the request path your latency budget is built around.

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

The request that lands on your desk, not compliance's

It usually arrives as a forwarded thread in which someone has written the phrase "record-keeping and logging obligations" and asked whether the scoring service can produce an audit trail of its decisions, per system, with the model version attached, for a date range a supervisory authority might ask about. Auditrek answers that request from outside the pipeline: one outbound REST call or one webhook per decision, stored as a SHA-256 hash-chained, append-only record for that system, with the event's own timestamp bound into the hashed payload and a server-side endpoint that recomputes the chain on demand.

The reason that placement matters is the shape of the problem you have already costed:

  • The serving path is the one piece of the stack you are least willing to touch. It has a latency budget, a rollback story, and a change-approval process that exists precisely because a bad deploy there is a customer-facing incident.
  • Your existing logs were built for debugging, not evidence. They are sampled, they rotate, they live next to everything else, and nobody can prove a line was not edited after the fact.
  • The actual question is not "do you have logs" but "can we prove the logs are the originals, and that they say what they said on the day."

So the decision in front of you is narrow. You can build an append-only ledger yourself, which means a hash-chain write path, a verification routine, retention rules, a pseudonymisation layer, and then a reporting surface a non-engineer can operate without asking you for a CSV every quarter. Or you can treat decision logging as a separate system that receives events from your pipeline rather than living inside it. Auditrek is the second option, deliberately, and the ingestion layer is a generic REST and webhook API so the integration point is wherever your code already has the prediction in hand.

The workflow, from first call to a verifiable chain

  1. Register the system and clear the DPA gate

    An ai_system cannot be connected until a dpa_confirmation with a signed_at timestamp is recorded. No API key and no webhook secret are issued before that, and the check is enforced server-side rather than in the client, so an unsigned system returns a 403 instead of credentials. This is usually the one step you hand back to legal, and it is the step that stops raw pipeline data arriving before anyone has agreed on lawful basis.

  2. Post the decision record after the prediction returns

    The capture API accepts an inference event payload: input hash, model id and version, output, confidence, timestamp, and a human override flag. You send the input hash rather than the input, which is why the call does not become a data-exfiltration review. One POST per decision, from your handler, your consumer, or your batch job, after the response has already left.

  3. Or map an event you are already emitting

    Ingestion is generic REST and webhook, with documented payload mapping guides for AWS SageMaker and Azure ML, published with the field list and copyable request examples. There are no bespoke platform SDKs in the current build, so there is no Auditrek library to install anywhere. Deeper native integrations are fast-follow, not part of this scope.

  4. Let the write path chain the record

    On write, Auditrek computes the sequence number and prev_hash from the last record for that ai_system, computes the record hash as SHA-256 over prev_hash plus payload, and stores the fields atomically in a transaction. The hashed payload binds the record's created_at alongside sequence number, input hash, output, confidence, human override flag and the pseudonymised subject reference, so the recorded time is covered by the chain rather than sitting beside it. Records are append-only per system, so there is no update path to reason about.

  5. Take a trusted timestamp over the hash, where an authority is configured

    Where an RFC 3161 time stamping authority is configured, it signs a trusted timestamp over each decision record's hash. The authority receives the hash only, never the record contents, so adding third-party proof of time does not widen what leaves your boundary. Where no authority is configured, the chain's own ordering and the bound created_at are what you have.

  6. Watch sensitive fields bounce before the write

    A data-minimisation gate inspects incoming payloads for recognisable raw sensitive-field patterns, including SSN formats, ICD-10 style diagnosis codes, and unredacted credit bureau fields, and rejects the request with a 422 and a clear error body before anything is written. Subject identifiers are pseudonymised by default. If a teammate wires up the wrong field, you find out at integration time from an error body, not at a review two quarters later.

  7. Verify the chain from the server, not from a flag

    The verification endpoint walks the chain for that record's ai_system from sequence 1, recomputes each hash from the stored prev_hash and payload, and returns a tamper status of valid or broken, with the first broken sequence number when it finds one. It recomputes rather than reading a stored boolean, which is the only version of this check worth having, and it is a plain HTTP call you can assert against in a test. The decision record table pages through records for a chosen system and carries the same verify action per row.

  8. Hand the surface to the person who asked

    The dashboard shows decisions logged, systems connected, last report generated, and tamper-verification status, built for a non-technical compliance officer. The report generator produces PDF and HTML for a chosen system and date range, mapped to EU AI Act Article 12 and 13 fields, with a fixed disclaimer embedded in every report stating that the output does not constitute legal advice and has not been reviewed by qualified regulatory counsel. One regulation and format set at launch. The point is that the quarterly request stops routing through you.

Why this shape matters to the person who owns the pipeline

No model migration, and no SDK of ours to install

Ingestion is a generic REST and webhook layer with no bespoke platform SDKs in this build, so there is no Auditrek library to add anywhere and no reason to move or rebuild the model. The integration is an outbound HTTP call from code you already own, which makes the change-approval conversation a question about a new egress destination rather than a new serving topology.

Out of the request path by construction

Because the event is sent after the prediction has returned, Auditrek is not a dependency of your inference response. You keep control of the failure mode: buffering, retries and backpressure stay in your code, where you can reason about them, rather than inside a library you cannot step through.

One payload contract across platforms

The same event schema covers a SageMaker endpoint, an Azure ML deployment and the service someone wrote in-house three years ago. Mapping guides exist for the first two; the third just posts the same JSON. One contract to document internally beats three integrations to maintain.

Time is inside the chain, not beside it

The record's created_at is part of the hashed payload, so editing a recorded time changes the hash and the recomputation reports a broken chain at that sequence number. When the question is "was this decision logged on the day it was made", the answer is a property of the chain rather than a database column anyone could update quietly.

A tamper check you can put in CI

Verification is a server-side recomputation exposed over HTTP with a tamper_status response, so your integration test can seed decisions and assert the chain still verifies. That turns "is the audit trail intact" from a claim in a slide into an assertion that fails a build.

Sensitive data stops being your judgement call

The ingestion gate rejects recognisable raw sensitive fields with a 422 and pseudonymises subject identifiers by default. You are sending an input hash, not an input, so the question of what the ledger holds has a short and defensible answer.

The evidence request routes past you

Once the dashboard and report generator are in the compliance officer's hands, the date-range request becomes theirs to run. Organisation access is multi-user and auth-gated, and an owner can invite colleagues by email, so the person who needs the report does not need your login.

What Auditrek asks of each layer

LayerWhat Auditrek needsWhat Auditrek does not reach into
Model artefact and trainingThe model id and version, carried as fields in the event payload.Your registry, training jobs and artefact storage. Auditrek reads nothing from them and asks for no model migration.
Serving container and endpointNothing of ours installed: there are no bespoke platform SDKs in this build, and ingestion is generic REST and webhook.Your image, runtime, scaling policy and rollback path, which Auditrek has no visibility into.
Application or pipeline codeOne outbound REST call, or one webhook mapped using the SageMaker or Azure ML guide.Everything upstream of the response, and the response itself.
Data leaving your boundaryInput hash, model id and version, output, confidence, timestamp, human override flag, pseudonymised subject reference. Where a time stamping authority is configured, the record hash alone goes to it.Raw inputs, and the record contents, which the timestamping authority never sees. Recognisable raw sensitive fields are rejected at ingestion with a 422.
Access and hostingA signed DPA before credentials are issued, and email and password sign-in for your org members. Auditrek runs on Amazon Web Services in a single region.Your own hosting, VPC and secret management.

The trade-offs, stated plainly

Keeping logging out of the inference path buys you safety and costs you something, and you should know what before you pilot.

You own delivery

Auditrek receives events; it does not reach into your pipeline to collect them. If your process dies between returning a prediction and posting the record, that record does not exist. If completeness of the chain matters to your evidence story, you will want the post to happen from a durable step, a queue consumer or a batch reconciliation job, rather than fire-and-forget inside a request handler.

Mapping guides, not native SDKs

The current build ships a generic REST and webhook ingestion layer with documented payload mapping for AWS SageMaker and Azure ML. That is a written mapping you implement, not a one-line install. Deeper native integrations are fast-follow rather than build-time scope, so if your evaluation depends on a platform-specific agent, this is not that yet.

Proof of time has two levels

The record's created_at is bound into the hashed payload, so the chain itself covers the recorded time. A trusted RFC 3161 timestamp over the record hash applies only where a time stamping authority is configured; without one, the time you can demonstrate is the time your system asserted, protected from later edits by the chain rather than attested by a third party. There has also been no independent cryptographic review of the hash chain implementation, and no SOC 2 or ISO 27001 audit of Auditrek, so treat both as open items in your vendor assessment rather than as settled.

One regulation, one format set at launch

The report generator produces PDF and HTML mapped to EU AI Act Article 12 and 13 fields for a chosen system and date range, with the non-legal-advice disclaimer embedded in every output. It is a single regulation and format set at launch. Auditrek records what an AI system did and when; it does not assess whether your practices satisfy any obligation, and nothing in the output should be read as that assessment.

The DPA gate is an attestation, not a document vault

Connecting a system requires a recorded dpa_confirmation with a signer name, a document reference and a signed_at timestamp. It is a self-attestation by a signed-in member of your organisation: the agreement itself is not uploaded, there is no revocation path, and Auditrek does not offer its own standard data processing agreement for customers to sign. Your legal team keeps the document; Auditrek records that someone confirmed it before credentials existed.

Access, identity and residency

Org access is auth-gated and multi-user, people sign in with email and password, and password reset, email verification and invite messages are sent through Resend. There is no single sign-on in this scope, so if your identity team mandates SSO for every vendor, raise it early rather than at procurement. Hosting is Amazon Web Services in a single region, with no multi-region replication and no choice of data residency.

Volume caps and append-only retention

Connecting beyond your plan's system limit is blocked with an upgrade prompt, so size the tier against the systems you actually intend to log. Decision records are append-only and kept for the life of the organisation that owns them, which is the point of the ledger and also means there is no per-record deletion to design around.

Verification is per system

Chains are append-only per ai_system, which keeps ordering unambiguous and lets you verify one system without touching another. It also means a single global chain across every model you run is not what you get.

Questions

Does Auditrek sit in the inference request path?

No. You send the decision record after the prediction has been returned, either as a REST call from your own code or as a webhook from your platform. Auditrek is not a dependency of your inference response, which also means retry and buffering behaviour stays in your code where you can control it.

What exactly goes into a decision record?

The capture API accepts an input hash, model id and version, output, confidence, timestamp, and a human override flag, per ai_system. You send a hash of the input rather than the input itself, and the subject reference is pseudonymised before storage.

Is the timestamp part of what gets hashed?

Yes. The record's created_at is bound into the hashed payload alongside sequence number, input hash, output, confidence, human override flag and the pseudonymised subject reference, so altering a recorded time breaks the chain at that sequence. Separately, where an RFC 3161 time stamping authority is configured it signs a trusted timestamp over the record's hash, receiving the hash only and never the record contents.

Do I need a SageMaker or Azure ML SDK?

No. Ingestion is a generic REST and webhook layer, and there are documented payload mapping guides for AWS SageMaker and Azure ML. There are no bespoke platform SDKs in this build; deeper native integrations are fast-follow rather than current scope.

How do I know the log has not been altered?

Records are stored as SHA-256 hash-chained append-only entries per system, where each hash is computed over the previous hash plus the payload. The verification endpoint walks the chain from sequence 1, recomputes every hash from stored values, and returns a tamper status of valid or broken with the first broken sequence number, rather than reading a stored flag. The same check is available per row in the decision record table.

What happens if a field with a raw identifier slips through?

The ingestion gate inspects payloads for recognisable raw sensitive-field patterns, including SSN formats, ICD-10 style diagnosis codes and unredacted credit bureau fields, and rejects the request with a 422 and a clear error body before any database write. Subject identifiers are pseudonymised by default.

How many decisions a month can I log, and what does it cost?

Both carry a 30-day free trial with no card to start, and billing runs through Stripe.

Can I use it today?

Not yet. Auditrek is in build and access is via the waitlist. Joining gets you the payload schema, the verification endpoint behaviour and the platform mapping guides, which is what you need to size the integration.

Sources

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.