HIPAA model release gate and golden set evaluation for enterprise AI — Reference Architecture

Reference architecture · published 2026-10-16 · regulated enterprise · HIPAA · layout diagram_first · implementation executed in CI before publish

The control that resolves this is a Frozen Golden Set Release Gate, evaluated before the request reaches a model provider rather than audited afterwards. In regulated enterprise 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 ≤ 600ms over REST over HTTPS, and ships with a standard-library implementation that runs as written.

The blueprint

Frozen Golden Set Release Gate — the request path, with the decision points that must exist before the first model call:

flowchart LR
    CAND[Candidate model] --> SC[Score per slice]
    BASE[Baseline scores] --> CMP{Compare per slice}
    SC --> CMP
    CMP -->|slice regressed| BLOCK[Refuse release]
    CMP -->|below floor| BLOCK
    CMP -->|all slices hold| REL[Release + decision record]
    BLOCK --> REC[Record which slice and by how much]

Component breakdown

1. Frozen golden set — Versioned and immutable; editing it after freeze raises.
2. Slice taxonomy — Rare-but-critical cases are their own slice, not noise in the mean.
3. Per-slice thresholds — Tolerance for regression plus an absolute floor per slice.
4. Deterministic scorer — Same inputs, same score — a flaky scorer makes the gate decorative.
5. Release gate — Refuses on any slice regression even when the aggregate improves.
6. Decision record — What was compared, which slices moved, who accepted the risk.

Deployment parameters

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

The architecture friction point

A model upgrade is approved on a demo and an aggregate score. Nobody can say which cases got worse, because the comparison is a single number against a test set that changes whenever it is inconvenient.

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.

Reference implementation — Per-slice release gate over a frozen golden set

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 REST over HTTPS; the failure mode it guards against is a retried POST creating a duplicate record. The output you hand the assessor is the minimum-necessary de-identification log.

"""Release gate on a frozen golden set, with per-slice thresholds.

The failure this prevents: a candidate model improves the aggregate score and
regresses badly on one slice that happens to matter. Aggregates hide that
(Simpson's paradox is not a curiosity here, it is the default outcome), so the
gate evaluates per slice and refuses on any slice regression beyond tolerance
even when the headline number improves.
"""
from dataclasses import dataclass, field


@dataclass(frozen=True)
class Case:
    case_id: str
    slice_name: str
    prompt: str
    expected: str


@dataclass
class GoldenSet:
    """Frozen on purpose. A golden set edited to make a release pass is not a
    golden set, so mutation after freeze raises rather than warns."""
    name: str
    cases: list = field(default_factory=list)
    _frozen: bool = False

    def add(self, case: Case) -> None:
        if self._frozen:
            raise RuntimeError(f"{self.name} is frozen; create a new version")
        self.cases.append(case)

    def freeze(self) -> "GoldenSet":
        self._frozen = True
        return self

    def slices(self) -> set:
        return {c.slice_name for c in self.cases}


def score(model, golden: GoldenSet) -> dict:
    per_slice: dict[str, list] = {}
    for case in golden.cases:
        ok = model(case.prompt) == case.expected
        per_slice.setdefault(case.slice_name, []).append(ok)
    return {s: sum(v) / len(v) for s, v in per_slice.items()}


def aggregate(scores: dict, golden: GoldenSet) -> float:
    weights = {s: sum(1 for c in golden.cases if c.slice_name == s)
               for s in scores}
    total = sum(weights.values())
    return sum(scores[s] * weights[s] for s in scores) / total


class ReleaseGate:
    def __init__(self, tolerance: float = 0.02, floors: dict | None = None):
        self.tolerance = tolerance
        self.floors = floors or {}

    def decide(self, baseline: dict, candidate: dict, golden: GoldenSet) -> dict:
        regressions, floor_breaks = [], []
        for s in sorted(set(baseline) | set(candidate)):
            b, c = baseline.get(s, 0.0), candidate.get(s, 0.0)
            if b - c > self.tolerance:
                regressions.append({"slice": s, "baseline": round(b, 3),
                                    "candidate": round(c, 3),
                                    "delta": round(c - b, 3)})
            floor = self.floors.get(s)
            if floor is not None and c < floor:
                floor_breaks.append({"slice": s, "candidate": round(c, 3),
                                     "floor": floor})
        agg_b, agg_c = aggregate(baseline, golden), aggregate(candidate, golden)
        return {
            "aggregate_baseline": round(agg_b, 3),
            "aggregate_candidate": round(agg_c, 3),
            "aggregate_improved": agg_c > agg_b,
            "slice_regressions": regressions,
            "floor_breaches": floor_breaks,
            "release": not regressions and not floor_breaks,
        }


if __name__ == "__main__":
    g = GoldenSet("claims-triage-v1")
    for i in range(40):
        g.add(Case(f"c{i}", "common", f"p{i}", f"a{i}"))
    for i in range(10):
        g.add(Case(f"r{i}", "rare_high_value", f"rp{i}", f"ra{i}"))
    g.freeze()

    baseline_answers = {c.prompt: c.expected for c in g.cases}
    def baseline_model(p): return baseline_answers[p]

    # Candidate: better on the big slice, broken on the small critical one.
    def candidate_model(p):
        if p.startswith("rp"):
            return "wrong"
        return baseline_answers[p]

    base = score(baseline_model, g)
    cand = score(candidate_model, g)
    gate = ReleaseGate(tolerance=0.02, floors={"rare_high_value": 0.90})
    decision = gate.decide(base, cand, g)

    assert decision["aggregate_candidate"] >= 0.79, decision
    assert not decision["release"], "a slice regression must block the release"
    assert decision["slice_regressions"][0]["slice"] == "rare_high_value"
    assert decision["floor_breaches"], decision

    clean = gate.decide(base, base, g)
    assert clean["release"], clean

    try:
        g.add(Case("x", "common", "p", "a"))
        raise AssertionError("edited a frozen golden set")
    except RuntimeError:
        pass

    print("Evaluation release gate: OK")
    print(f"  aggregate {decision['aggregate_baseline']} -> "
          f"{decision['aggregate_candidate']}, release={decision['release']}, "
          f"slice regressions {len(decision['slice_regressions'])}")

The HIPAA control, as code

Minimum-necessary de-identification with a BAA-pinned egress gate. This is the artifact an assessor asks for under HIPAA specifically — it is not the same control as the one above, and a system that implements one does not thereby implement the other. It executes under the same publish gate.

"""Minimum-necessary de-identification with a BAA-pinned destination gate.

HIPAA holds the covered entity responsible for PHI wherever it flows, so the
control is not "we told people not to paste PHI". Two things must be
structural: PHI is reduced to the minimum necessary BEFORE egress, and the
destination set is pinned to those under a signed BAA, failing closed on
anything else.

Safe Harbor (45 CFR 164.514(b)(2)) lists 18 identifier classes. This implements
the mechanical subset and records a per-request de-identification receipt,
because the auditor asks for proof per request, not a policy document.
"""
import re

SAFE_HARBOR_PATTERNS = {
    "name_mrn": re.compile(r"\bMRN[:\s#]*([A-Z0-9-]{4,})", re.I),
    "ssn": re.compile(r"\b\d{3}-\d{2}-\d{4}\b"),
    "phone": re.compile(r"\b(?:\+1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b"),
    "email": re.compile(r"\b[\w.+-]+@[\w-]+\.[\w.]+\b"),
    "date_full": re.compile(r"\b\d{1,2}/\d{1,2}/(19|20)\d{2}\b"),
    "member_id": re.compile(r"\b(?:member|policy)\s*(?:id|#)[:\s]*([A-Z0-9-]{5,})", re.I),
}


class BAARegistry:
    """Destinations are permissible only as attested data, never by convention."""

    def __init__(self):
        self._signed: dict[str, str] = {}

    def attest(self, destination: str, agreement_ref: str) -> None:
        self._signed[destination] = agreement_ref

    def covered(self, destination: str) -> bool:
        return destination in self._signed

    def reference(self, destination: str) -> str | None:
        return self._signed.get(destination)


class PHIEgressGate:
    def __init__(self, registry: BAARegistry):
        self.registry = registry
        self.receipts: list[dict] = []

    def deidentify(self, text: str) -> tuple[str, dict[str, int]]:
        counts: dict[str, int] = {}
        out = text
        for label, pattern in SAFE_HARBOR_PATTERNS.items():
            out, n = pattern.subn(f"[REDACTED:{label}]", out)
            if n:
                counts[label] = n
        return out, counts

    def send(self, text: str, destination: str) -> dict:
        """Refuses rather than redacting-and-hoping when the BAA is absent."""
        redacted, counts = self.deidentify(text)
        phi_present = bool(counts)
        if phi_present and not self.registry.covered(destination):
            receipt = {"destination": destination, "admitted": False,
                       "reason": "no BAA on file for a PHI-classified payload",
                       "identifier_classes": sorted(counts)}
            self.receipts.append(receipt)
            raise PermissionError(receipt["reason"])
        receipt = {
            "destination": destination,
            "admitted": True,
            "baa_ref": self.registry.reference(destination),
            "identifier_classes": sorted(counts),
            "redactions": sum(counts.values()),
            "payload": redacted,
        }
        self.receipts.append(receipt)
        return receipt


if __name__ == "__main__":
    reg = BAARegistry()
    reg.attest("azure-openai-us-east", "BAA-2026-0041")
    gate = PHIEgressGate(reg)

    note = ("Patient MRN: 88213A, contact 555-867-5309 or a.patient@example.com, "
            "DOB 04/11/1974, follow-up scheduled.")
    ok = gate.send(note, "azure-openai-us-east")
    assert ok["admitted"] and ok["redactions"] >= 4, ok
    assert "88213A" not in ok["payload"] and "555-867-5309" not in ok["payload"], ok
    assert "a.patient@example.com" not in ok["payload"], ok

    try:
        gate.send(note, "some-vendor-eval-endpoint")
        raise AssertionError("PHI reached a destination with no BAA")
    except PermissionError:
        pass

    # No PHI means no BAA requirement — the gate must not over-block.
    benign = gate.send("Summarise ward occupancy trends.", "some-vendor-eval-endpoint")
    assert benign["admitted"] and benign["redactions"] == 0, benign

    print("HIPAA minimum-necessary egress gate: OK")
    print(f"  receipts {len(gate.receipts)}, "
          f"refusals {sum(1 for r in gate.receipts if not r['admitted'])}")

Risk mitigation matrix

Each row carries an acceptance parameter rather than an adjective, because "low latency" cannot be signed off. Retention here is bound by per the data class retention schedule, enforced automatically.

Control questions before sign-off

• 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.
• Which slices did the candidate model get worse on, and by how much?
  The gate reports a per-slice delta for every slice, and the decision record keeps it. An aggregate alone cannot answer this, which is why it is not the gate.
• What stops someone editing the evaluation set until the release passes?
  The set is frozen on publish — mutation raises rather than warns, and a change requires a new version with its own identifier recorded on every subsequent decision.
• If the aggregate score improves by two points, can the release still be refused?
  Yes, and it must be. A slice regression beyond tolerance, or any breach of a named slice's floor, refuses the release regardless of the aggregate.
• Where is the record of who accepted a known regression, and on what basis?
  In the decision record attached to the release: the slices that moved, the magnitude, and the named person who accepted it. An unaccepted regression cannot ship.
• How do you know the scorer gives the same answer twice?
  The scorer is deterministic and any sampling is seeded, with the seed recorded. The same candidate against the same frozen set produces the same report.

See also

• Part of enterprise ai compliance architecture.
• A different failure mode of the same component: HIPAA agent permission and delegated access architecture for enterprise.
• Where this interacts with another regime, see HIPAA prompt injection defence architecture for enterprise LLM deployment.
• HIPAA legacy integration patterns for enterprise AI agents covers the adjacent case.
• A different failure mode of the same component: HIPAA retrieval architecture with citation integrity for enterprise LLM.
• If this is the blocker in front of you: enterprise AI infrastructure review.