HIPAA audit evidence architecture for enterprise LLM deployment in healthcare — Reference Architecture

Reference architecture · published 2026-10-16 · healthcare · HIPAA · layout control_review · implementation executed in CI before publish

The control that resolves this is an Attestable Inference Plane, evaluated before the request reaches a model provider rather than audited afterwards. In healthcare the binding constraint is HIPAA, and the question it actually asks is can PHI reach a place the BAA does not cover. The shape below holds p95 ≤ 800ms over gRPC with mTLS, and ships with a standard-library implementation that runs as written.

The control gap

The model works and the pilot passed. The rollout is stopped by a control gap: the team can show that inference happened, but cannot produce per-tenant, tamper-evident evidence of WHAT was processed, by WHOM, under WHICH retention rule — which is the evidence an auditor asks for and a shared application log cannot give.

What HIPAA specifically requires

HIPAA holds the covered entity responsible for PHI wherever it flows. A model provider without a signed BAA is not a permissible destination, and 'the prompt only contained a little PHI' is not a defence — the minimum necessary standard is itself a control.

The artifact that satisfies it is a de-identification record per request plus the BAA chain. The way teams most often fail it: PHI reaching a subprocessor with no BAA, via a logging sidecar nobody mapped.

Risk register with acceptance criteria

Each row carries an acceptance parameter rather than an adjective, because "low latency" cannot be signed off. Retention here is bound by 6 years from creation or last effective date (HIPAA §164.316).

Enterprise implementation parameters

Every value below is a parameter you can hold a vendor or an internal team to. Adjectives are not acceptance criteria.

Questions to answer before approval

• Which destinations hold a BAA, and what structurally prevents PHI from reaching one that does not?
  Destinations carry a BAA flag as attested data, and the routing gate refuses a PHI-classified payload to any destination without it. The refusal is logged with its reason.
• Can you produce, for one named tenant, every inference record in a date range with proof none was altered?
  Yes — the verifier endpoint replays that tenant's hash chain for the date range and reports the first index at which the chain breaks. Each record commits to the previous record's digest, so an edit or deletion is detectable rather than merely unlikely.
• Where exactly in the request path are sensitive values removed, and what is stored in their place?
  In the redaction stage, before the record is sealed. Sensitive values are replaced with a sha256 digest of the value, so you can still prove which payload was processed without retaining the payload.
• Which key seals the records, who can use it, and what happens to verification after rotation?
  An HMAC key held in your KMS, usable only by the sealing service. Each record stores the key id it was sealed with, so the verifier resolves historical records against the KMS key history and rotation does not invalidate past evidence.
• What is the retention clock per data class, and what evidence proves deletion occurred?
  A retention clock per data class, enforced by the retention scheduler, which writes a deletion record when a record passes its horizon. The deletion log is what you show the auditor; reconcile it monthly against records in the store.
• Can tenant A's records ever appear in tenant B's evidence pack, and what makes that structurally impossible?
  No. The chain is keyed per tenant and the verifier rejects any record whose tenant_id does not match the stream being verified, so isolation is structural rather than a WHERE clause that can be forgotten.

The request path

Attestable Inference Plane — the request path, with the decision points that must exist before the first model call:

flowchart LR
    C[Client / Agent] --> G[Gateway]
    G --> PDP{Policy Decision Point<br/>tenant - class - purpose}
    PDP -->|deny| D[403 + denial record]
    PDP -->|allow| R[Redaction stage<br/>values to digests]
    R --> M[Model provider]
    M --> S[Seal: sha256 chain + HMAC]
    S --> L[(Per-tenant audit store)]
    L --> V[Verifier endpoint]
    V --> A[Auditor evidence pack]
    L --> RT[Retention scheduler]
    RT -->|expiry| X[Documented deletion]

Modular implementation framework

1. Policy decision point — Evaluates tenant, data class and purpose before the call. Fails closed.
2. Redaction stage — Strips sensitive values and substitutes digests, BEFORE anything is sealed.
3. Per-tenant hash chain — Each record commits to the previous digest, keyed per tenant.
4. HMAC seal — A KMS-held key makes records unforgeable by anyone with store write access.
5. Retention scheduler — Enforces the per-class retention clock and records the deletion.
6. Verifier endpoint — The function you run in front of the auditor to prove the chain is intact.

Implementation artifact — Per-tenant tamper-evident audit chain

Standard-library Python, no external dependencies, runs as written. Executed by the publish gate: if it raises, this page does not ship. Wire it behind gRPC with mTLS; the failure mode it guards against is a half-open HTTP/2 stream silently dropping the deadline. The output you hand the assessor is the minimum-necessary de-identification log.

"""Per-tenant, tamper-evident audit log for an LLM gateway.

Why this shape: a SOC 2 auditor does not ask "do you log?" — they ask whether a
log entry can be altered after the fact without detection, and whether tenant A
can ever read tenant B's entries. A plain append-only table answers neither.

This answers both with a per-tenant hash chain: each record commits to the
previous record's digest, so any edit or deletion breaks the chain at a
detectable point, and the chain is keyed per tenant so isolation is structural
rather than a WHERE clause someone can forget.
"""
import hashlib
import hmac
import json
import os
import time
from dataclasses import dataclass, field


GENESIS = "0" * 64


def _canonical(obj) -> bytes:
    # Digests must be stable across processes and Python versions, so the JSON
    # has to be canonical: sorted keys, no insignificant whitespace.
    return json.dumps(obj, sort_keys=True, separators=(",", ":")).encode()


@dataclass
class AuditChain:
    """Append-only, per-tenant hash chain with an HMAC seal.

    secret: a per-deployment key from your KMS. It makes the seal
    unforgeable by anyone who only has write access to the store.
    """
    secret: bytes
    heads: dict = field(default_factory=dict)   # tenant_id -> last digest

    def append(self, tenant_id: str, event: dict) -> dict:
        if not tenant_id:
            raise ValueError("tenant_id is required: an unattributed audit "
                             "record cannot satisfy per-tenant evidence")
        prev = self.heads.get(tenant_id, GENESIS)
        record = {
            "tenant_id": tenant_id,
            "ts": event.get("ts") or time.time(),
            "actor": event.get("actor"),
            "action": event["action"],
            "resource": event.get("resource"),
            "prev": prev,
            # Redaction happens BEFORE sealing. Sealing a payload you later
            # need to redact forces you to break your own chain.
            "payload": redact(event.get("payload") or {}),
        }
        digest = hashlib.sha256(_canonical(record)).hexdigest()
        seal = hmac.new(self.secret, digest.encode(), hashlib.sha256).hexdigest()
        record["digest"] = digest
        record["seal"] = seal
        self.heads[tenant_id] = digest
        return record

    def verify(self, tenant_id: str, records: list) -> tuple:
        """-> (ok, first_broken_index). This is the function you demo to the
        auditor; without it the chain is a claim rather than evidence."""
        prev = GENESIS
        for i, r in enumerate(records):
            if r.get("tenant_id") != tenant_id:
                return False, i          # cross-tenant record in the stream
            body = {k: r[k] for k in
                    ("tenant_id", "ts", "actor", "action", "resource",
                     "prev", "payload")}
            if r.get("prev") != prev:
                return False, i
            if hashlib.sha256(_canonical(body)).hexdigest() != r.get("digest"):
                return False, i
            expect = hmac.new(self.secret, r["digest"].encode(),
                              hashlib.sha256).hexdigest()
            if not hmac.compare_digest(expect, r.get("seal", "")):
                return False, i
            prev = r["digest"]
        return True, -1


SENSITIVE_KEYS = {"prompt", "completion", "email", "ssn", "dob", "mrn",
                  "card", "iban", "phone", "address", "name"}


def redact(payload: dict, keep_hash: bool = True) -> dict:
    """Drop sensitive values, keep a digest so you can still prove WHICH
    payload was processed without storing the payload itself.

    This is the control that lets you keep audit evidence under GDPR data
    minimisation and an HIPAA BAA at the same time."""
    out = {}
    for k, v in payload.items():
        if k.lower() in SENSITIVE_KEYS:
            out[k] = ("sha256:" + hashlib.sha256(
                _canonical(v)).hexdigest()[:16]) if keep_hash else "[redacted]"
        elif isinstance(v, dict):
            out[k] = redact(v, keep_hash)
        else:
            out[k] = v
    return out


if __name__ == "__main__":
    chain = AuditChain(secret=os.environb.get(b"AUDIT_HMAC_KEY", b"dev-only-key"))
    stream = [
        chain.append("tenant-a", {"actor": "svc:rag", "action": "inference",
                                  "resource": "gpt-4o",
                                  "payload": {"prompt": "patient MRN 9912",
                                              "tokens": 318}}),
        chain.append("tenant-a", {"actor": "u:42", "action": "export",
                                  "resource": "conversation/77"}),
    ]
    print("redacted payload:", stream[0]["payload"])
    print("chain verifies:", chain.verify("tenant-a", stream))
    stream[0]["payload"]["tokens"] = 1          # tamper
    print("after tamper:   ", chain.verify("tenant-a", stream))

Where this friction was observed

This page exists because the problem is reported publicly. The threads below are the primary sources, linked unmodified and not affiliated with this site.

• [Feature Request]: List HIPAA Agent in LlamaHub tool directory github · run-llama/llama_index · 2026-03-14
• Red Flags in HIPAA-Compliant AI hackernews · hn/story · 2025-12-29
• HIPAA-Compliant AI: What developers need to know hackernews · hn/story · 2026-03-04
• Guide on Making AI Solutions HIPAA-Compliant for Healthcare Innovators hackernews · hn/story · 2025-06-12
• Increasingly, HIPAA Can't Stop AI from De-Anonymizing Patient Data hackernews · hn/story · 2026-02-12
• The HIPAA Violations Hiding in Your Team's Browser History hackernews · hn/story · 2026-04-30
• Private and HIPAA Compliant LLM Summarizer for Apple Health's Medical Records hackernews · hn/comment · 2025-08-03
• Zohran and the Short Link hackernews · hn/comment · 2026-08-27

Related architectures

• Part of enterprise ai compliance architecture.
• For the related constraint, see HIPAA data governance framework for enterprise LLM deployment.
• compliance audit evidence architecture for enterprise LLM deployment applies the same mechanism under a different obligation.
• fedRAMP audit evidence architecture for enterprise LLM deployment covers the adjacent case.
• If this is the blocker in front of you: enterprise AI infrastructure review.