\documentclass[10pt,twocolumn]{article} % ---- Packages (standard texlive only) ---- \usepackage[utf8]{inputenc} \usepackage[T1]{fontenc} \usepackage{amsmath} \usepackage{amssymb} \usepackage{graphicx} \usepackage{booktabs} \usepackage{xcolor} \usepackage[numbers,sort&compress]{natbib} \usepackage[hidelinks]{hyperref} % ---- Layout tuning for two-column article ---- \usepackage[margin=0.75in]{geometry} \setlength{\columnsep}{0.28in} \bibliographystyle{plainnat} \usepackage{tikz} % ---- Lightweight helpers ---- \newcommand{\req}[1]{\textbf{R#1}} \newcommand{\comp}[1]{\textsf{#1}} \title{\textbf{Attested Confidential Inference: Binding GPU TEE Enclaves to Model Provenance for Sovereign Multi-Tenant AI}} \author{ThakiCloud AI Research (Hyojung Han)} \date{July 8, 2026} \begin{document} \maketitle \begin{abstract} Sovereign, on-premises AI platforms serving regulated sectors must answer a question their operators cannot answer today: can they prove to a regulator that a tenant's data never left a confidential-computing (CC) enclave, \emph{and} that the exact audited model weights served each request? GPU trusted execution environments (TEEs) now provide the first half through remote attestation, and model-provenance work provides the second through signed release records, but the two are treated as separate concerns and are never cryptographically joined. This paper is primarily an \emph{analytical, design-oriented} contribution, but we now also report real measurements of its software-side binding path. On a real NVIDIA H200 cluster (four H200-NVL GPUs, AMD EPYC~9335) we measured the ACI software binding overhead --- signed ledger append, per-request provenance-digest verification, and the software attestation flow --- and find it adds roughly $0.01$~ms per request, about $0.0002\%$ (well under $0.001\%$) of the measured $4286$~ms baseline inference latency: negligible. What remains \emph{unmeasured} is the GPU-TEE hardware component: our cluster ran with confidential-computing (CC) mode disabled, so the intrinsic TEE throughput penalty and hardware attestation-evidence generation are still reported only as ranges explicitly attributed to prior benchmark studies, never as our own measurements. We present \emph{Attested Confidential Inference} (ACI), a protocol that binds RATS-style remote attestation evidence to a signed model-provenance ledger entry and enforces the binding at the Kubernetes job-admission boundary, so that every served inference is accompanied by a regulator-verifiable proof linking enclave identity, workload identity, and audited weight digest. We give a threat model with five requirements, a component architecture and protocol flow, a security analysis (including the attestation-to-load TOCTOU gap and the orthogonal supply-chain custody problem), and a projected additive overhead model assembled solely from cited ranges. We map ACI onto a real sovereign stack (Keycloak, Kueue, ArgoCD, PostgreSQL, NATS) as a case study. With the software protocol now measured, the sole remaining measurement is the GPU-TEE hardware layer: validating the intrinsic CC throughput penalty and hardware attestation-evidence generation on CC-mode Hopper/Blackwell GPUs is future work, blocked by CC-mode being disabled on our cluster. \end{abstract} \section{Introduction} A hospital, a ministry, or a bank that wants to run a large language model (LLM) on its own premises faces a trust problem that public-cloud buyers can partly outsource but sovereign buyers cannot. The whole point of an air-gapped, on-premises deployment is that no third party --- and, increasingly, \emph{not even the platform operator} --- should be able to see tenant data or silently swap the model. Yet the platform operator holds root on the cluster, controls the scheduler, and ships the model images. For privacy-critical regulated workloads, ``trust us'' is not a compliance posture. The regulator wants a proof, not a promise. Concretely, a sovereign platform must be able to prove two claims about any given inference request, after the fact and to a party that does not trust the operator: \begin{itemize} \item \textbf{Claim~A (data confidentiality):} the tenant's input, the model activations, and the output never left a GPU confidential-computing enclave in cleartext --- neither a curious operator with host root, nor a co-tenant, nor a network attacker observed them. \item \textbf{Claim~B (model provenance):} the weights that produced the output were exactly the artifact that passed the organization's audit / release gate --- not a backdoored, fine-tuned, or otherwise substituted variant. \end{itemize} The two halves of this problem have strong, but \emph{separate}, prior art. GPU TEEs on NVIDIA Hopper and Blackwell provide hardware roots of trust and remote attestation that can substantiate Claim~A \citep{gu2025blueprint,zhu2024hopperbenchmark,chrapek2025confidential}, and a growing body of work on model provenance and supply-chain attestation can substantiate Claim~B by binding training and release claims to model artifacts \citep{tan2026attesting,ahi2026scalability,chantasantitam2026palm}. Confidential LLM serving systems now exist on commodity TEEs \citep{zhou2026openpcc}. But to our knowledge no system \emph{cryptographically binds} an attestation-evidence chain to a signed model-provenance record and enforces that binding inside a multi-tenant GPU scheduler. Attestation tells you \emph{where} the computation ran; provenance tells you \emph{what code/weights were released}; neither, alone, tells a regulator that \emph{the audited weights ran inside the attested enclave for this request}. That join is the gap. \paragraph{Contributions.} This paper makes three contributions, framed honestly as design and analysis, now backed by measurement of the software binding path (the GPU-TEE hardware layer remaining cited): \begin{enumerate} \item \textbf{Platform (ThakiCloud) angle.} We show how to turn the isolation primitives a sovereign on-premises Kubernetes platform already has --- namespaces, RBAC, Keycloak identity, Kueue GPU admission, ArgoCD GitOps release --- into a regulator-auditable cryptographic guarantee, by adding an attestation-to-provenance binding rather than new isolation mechanisms (Section~\ref{sec:deploy}). \item \textbf{Societal angle.} We lower the trust barrier for health, government, and finance to adopt on-premises LLM inference \emph{without trusting the platform operator}, because the proof does not depend on operator honesty (Sections~\ref{sec:threat} and \ref{sec:security}). \item \textbf{Scientific angle.} We do not claim a new cryptographic primitive: comparing a runtime weight digest against a signed reference is the well-established measured-launch / sealed-measurement pattern (measured boot, DICE, TPM quote-vs-golden-value), and prior work already binds signed release claims to artifacts \citep{tan2026attesting} and serves confidential LLMs on TEEs \citep{zhou2026openpcc}. Our honestly-defensible contribution is the \emph{composition}: to our knowledge this is the first work to compose GPU-TEE remote attestation with signed model-provenance verification as a \emph{per-request, regulator-verifiable gate enforced at scheduler-admission time} inside a multi-tenant Kubernetes+Kueue system (Sections~\ref{sec:arch} and \ref{sec:security}) --- an integration and deployment contribution rather than a new mechanism --- together with an overhead model whose software terms are now measured on real H200 hardware and whose GPU-TEE term remains source-attributed (Sections~\ref{sec:overhead} and \ref{sec:measured}). \end{enumerate} \paragraph{Empirical-honesty statement.} We are precise about which numbers we measured and which we cite. We \emph{measured} the ACI software binding path --- signed ledger append, per-request provenance-digest verification, and the software attestation flow --- on a real NVIDIA H200 cluster (Section~\ref{sec:measured}); those values are our own. We did \emph{not} measure the GPU-TEE hardware component: CC mode was disabled cluster-wide (\texttt{nvidia-smi conf-compute} reports \texttt{CC status: OFF}, and no SEV/TDX confidential VM was available), so the intrinsic TEE throughput penalty $L_{\text{TEE}}$ and the hardware attestation-evidence generation are reported \emph{only} as ranges attributed inline to cited sources, never as our measurements. We treat live validation of that hardware layer on CC-mode Hopper/Blackwell as declared future work (Section~\ref{sec:discuss}). \section{Related Work} \label{sec:related} \subsection{GPU Confidential Computing and Remote Attestation} NVIDIA's Hopper generation introduced a GPU confidential-computing mode whose bootstrap and attestation chain has been analyzed in depth by \citet{gu2025blueprint}, who dissect how the device establishes a measured, attestable state and bridge trust from CPU TEE to GPU. On the performance side, \citet{zhu2024hopperbenchmark} benchmark CC-mode overhead across LLMs and token lengths and report that overhead is below 7\% for typical queries and approaches zero for larger models and longer sequences, because the dominant cost is the encrypted PCIe transfer between CPU and GPU rather than compute inside the enclave. \citet{chrapek2025confidential} extend this across Intel TDX/SGX and NVIDIA H100 CC for Llama2 7B/13B/70B, reporting CPU-TEE overheads below 10\% throughput and around 20\% latency, and a GPU-CC throughput penalty of 4--8\% that shrinks with batch and input size. \citet{knoop2026privatellm} document the broader trend toward local, private LLM deployment reaching cost-sensitive SME and consumer budgets on Blackwell-generation hardware, evidence that the deployment substrate this paper assumes is becoming broadly available rather than exotic --- independent of whether datacenter CC mode itself is offered at that tier (consumer GeForce parts do not ship the datacenter CC feature that H100/H200/B100/B200 class hardware provides). \citet{schambach2026enclavex} integrate CPU and GPU TEEs end-to-end for confidential AI, consistent with the still-early state of comprehensive end-to-end CPU/GPU-TEE AI evaluation --- a gap our honesty statement echoes. \citet{forough2026agentic} survey how CC/TEE hardware roots of trust map onto the security needs of agentic AI more broadly. For attestation \emph{semantics} we adopt the IETF RATS architecture \citep{ietf2023rats}, which fixes the roles of Attester, Verifier, and Relying Party and the notion of Evidence, Endorsements, and Attestation Results. \citet{sinaki2026trustmee} propose a RATS-compliant self-verifying Verifier and, importantly for us, foreground evidence freshness --- the window between when attestation evidence is produced and when the workload it describes actually executes. \subsection{Model Provenance and Supply-Chain Attestation} \citet{tan2026attesting} cryptographically bind training and release claims --- data lineage, build environment, security-scan results --- to model artifacts, and identify precisely the gap that release claims are rarely bound to the artifacts they describe. \citet{ahi2026scalability} survey model supply-chain risks (compromised dependencies, forged provenance, backdoored models) and propose three control points: artifact attestation at training completion, signed provenance metadata, and mandatory pre-deployment verification gates --- a decomposition we reuse directly when siting ACI's registrar and admission gate. \citet{chantasantitam2026palm} give zero-knowledge-style \emph{property} attestation for model properties such as differential privacy and fairness, and proof-of-inference, which is complementary: ACI attests \emph{which} weights ran, while PAL*M can attest \emph{properties} of those weights. \citet{wang2026agenttraces} survey execution-provenance and evidence-tracing techniques for LLM-agent trust, situating per-request evidence trails in a broader trust taxonomy. \subsection{Multi-Tenant Kubernetes AI Governance} \citet{mouzouni2026contextk8s} propose a Kubernetes-native audit trail, permission model, and guardrail engine for agentic-AI governance under an EU AI Act framing, and \citet{bandara2026aitrustos} propose a continuous zero-trust governance framework using ephemeral, read-only structural probes for AI-infrastructure auditing. Both operate at the orchestration/telemetry layer; neither anchors its audit records in hardware attestation bound to model identity, which is where ACI adds a cryptographic root beneath the governance layer they describe. \subsection{RAG Security Relevance} Many regulated deployments are retrieval-augmented. \citet{xu2026securingrag} give a taxonomy of RAG attacks and defenses; their analysis motivates a requirement often omitted by weight-centric attestation: a regulated-sector RAG pipeline must attest \emph{retrieval-time data isolation}, not only model weights, because sensitive context enters the enclave at inference time. We treat the retrieval path as in-scope for the confidentiality claim (Section~\ref{sec:threat}) even though ACI's provenance binding centers on weights. \subsection{What is missing} The closest prior art, \citet{zhou2026openpcc}, delivers confidential LLM serving on commodity TEEs but does not bind attestation evidence to a signed model-provenance ledger, nor integrate with a multi-tenant GPU job-queue scheduler. Across the literature, attestation and provenance are advanced separately. The digest-vs-signed-reference check ACI relies on is not itself new --- it is the classical measured-launch pattern, and \citet{tan2026attesting} already bind signed release claims to artifacts. ACI's contribution is not a new cryptographic mechanism but the \emph{composition and enforcement}: joining the two signals per request and enforcing that binding at multi-tenant scheduler admission so the result is regulator-verifiable, which no prior system does. \section{Threat Model and Requirements} \label{sec:threat} \paragraph{System.} A sovereign, on-premises Kubernetes cluster serves multiple tenants. GPU nodes support CC mode. A tenant submits an inference (optionally RAG) job; the platform schedules it onto a GPU, loads model weights, runs the request, and returns output. A \emph{regulator} may later demand proof about any request. \paragraph{Trust assumptions.} We trust the GPU/CPU TEE hardware root of trust and its manufacturer endorsement, and the correctness of the attestation verifier logic \citep{ietf2023rats,sinaki2026trustmee}. We trust that a well-formed signature over a known key means what it says. We do \emph{not} trust the platform operator's runtime honesty, the host OS/hypervisor outside the TEE, other tenants, or the network. \paragraph{Adversaries.} \begin{itemize} \item \textbf{Curious operator} ($\mathcal{A}_{\text{op}}$): holds host root and control-plane admin. Wants to read tenant data or substitute weights. Cannot break TEE hardware isolation but can inspect host memory outside enclaves, alter scheduling, and tamper with images before load. \item \textbf{Malicious co-tenant} ($\mathcal{A}_{\text{co}}$): runs their own jobs on the same cluster/nodes. Wants cross-tenant data leakage or to have their workload served under another tenant's identity. \item \textbf{Network attacker} ($\mathcal{A}_{\text{net}}$): controls the network between components. Wants to eavesdrop, replay stale attestation evidence, or man-in-the-middle the verifier exchange. \end{itemize} \paragraph{Scope assumption (mediated ingress).} Before the requirements, we state one scope assumption explicitly, because it bounds what ACI can promise. ACI's guarantee is scoped to requests that traverse the mediated ingress path through which attestation, provenance binding, and admission occur. A root-holding operator could in principle serve an out-of-band shadow request that never enters this path and simply never emit a binding record; the absence of a ledger entry is absence-of-evidence, not, by itself, evidence-of-absence. We therefore require the deployment to be \emph{fail-closed}: the mediated ingress must be the only way to reach a GPU (e.g., network-policy-enforced single ingress with no direct pod/GPU access), so that an unmediated request is either impossible or, if forced through by an operator, produces no valid proof and is thus non-compliant by construction --- detectable by the reconciliation described in Section~\ref{sec:security} (\req{4} vs.\ $\mathcal{A}_{\text{op}}$). \paragraph{Requirements.} We derive five requirements. \begin{description} \item[\req{1} Attestation freshness.] Evidence bound to a served request must be fresh relative to that request, closing replay by $\mathcal{A}_{\text{net}}$ and limiting the attestation-to-execution window \citep{ietf2023rats,sinaki2026trustmee}. \item[\req{2} Provenance binding.] The served weight digest must be cryptographically equal to a signed provenance record produced at release time; a substituted artifact must be detectable \citep{tan2026attesting,ahi2026scalability}. \item[\req{3} Non-repudiation.] The operator cannot later deny, alter, or selectively omit which enclave and which weights served a given request; the record is append-only and independently verifiable. \item[\req{4} Scheduler-level isolation.] Admission of a GPU job must be gated on a valid attestation-to-provenance binding for the requesting tenant's identity, so $\mathcal{A}_{\text{co}}$ cannot be served under another tenant's namespace/identity. \item[\req{5} Acceptable overhead.] The binding must add only bounded, amortizable overhead on top of the intrinsic TEE cost, so it is deployable for interactive inference (analyzed in Section~\ref{sec:overhead}). \end{description} \section{Architecture: The ACI Protocol} \label{sec:arch} ACI adds five logical components on top of an existing confidential serving stack. None of them replaces the platform's isolation primitives; they \emph{bind} attestation to provenance and enforce that binding at admission. \begin{description} \item[\comp{Provenance Registrar}.] At model release time it computes the weight artifact digest, collects release claims (training lineage, build environment, scan results in the sense of \citet{tan2026attesting}), and emits a \emph{signed provenance record} $P = \mathrm{Sign}_{k_{\text{rel}}}(\text{digest}, \text{claims}, \text{version})$. This is the ``artifact attestation at training completion'' and ``signed provenance metadata'' control points of \citet{ahi2026scalability}. \item[\comp{Attestation Broker}.] A RATS Verifier \citep{ietf2023rats}: it issues a fresh nonce, receives Evidence from the GPU/CPU TEE Attester, checks it against manufacturer endorsements, and produces an Attestation Result $A$ that includes the enclave measurement and the nonce \citep{gu2025blueprint,sinaki2026trustmee}. \item[\comp{Binding Ledger}.] An append-only, signed log. It stores \emph{binding entries} $B = \mathrm{Sign}_{k_{\text{led}}}(H(A) \,\|\, H(P) \,\|\, \text{tenant} \,\|\, \text{req\_id} \,\|\, \text{ts})$, cryptographically joining a specific attestation result to a specific provenance record for a specific tenant request. $B$ is the paper's core object: the binding that no prior system emits. \item[\comp{Kueue Admission Gate}.] A scheduler-side check: a GPU job is admitted only if a valid $A$ (fresh) and a matching signed $P$ for the requested model version exist and are consistent with the requesting tenant's identity, satisfying \req{4}. Because this gate runs on operator-controlled infrastructure, it is deliberately \emph{not} treated as a trusted enforcer against the operator: its role is to make compliant service the only path that yields a valid binding $B$, so that circumventing the gate produces a detectable absence of $B$ rather than a valid proof (see Section~\ref{sec:security}, \req{4} vs.\ $\mathcal{A}_{\text{op}}$). \item[\comp{Regulator Verifier API}.] A read-only endpoint that, given a \texttt{req\_id}, returns $\{A, P, B\}$ and lets an external party re-verify all signatures and the enclave measurement independently of the operator (\req{3}). \end{description} \paragraph{Protocol flow.} The numbered flow for one request: \begin{enumerate} \item \textbf{Release (offline).} \comp{Provenance Registrar} signs $P$ over the audited weight digest and publishes it. \item \textbf{Job submit.} Tenant submits an inference job naming a model version; the request carries the tenant's Keycloak identity. \item \textbf{Attest.} \comp{Attestation Broker} issues nonce $n$; the GPU/CPU TEE returns Evidence over $n$ and its measurement; the broker emits Attestation Result $A$ (\req{1}). \item \textbf{Bind.} The enclave loads weights, computes the loaded digest, and proves \texttt{loaded\_digest = digest($P$)}; the system forms $B$ joining $H(A)$, $H(P)$, tenant, \texttt{req\_id} (\req{2}). \item \textbf{Admit.} \comp{Kueue Admission Gate} admits the GPU job only if $A$ is fresh, $P$ matches the requested version, and both are consistent with the tenant identity (\req{4}). \item \textbf{Serve \& append.} The enclave serves the request; $B$ is appended to the \comp{Binding Ledger} (\req{3}). \item \textbf{Audit (later).} A regulator queries the \comp{Regulator Verifier API} with \texttt{req\_id} and re-verifies $\{A,P,B\}$ without trusting the operator. \end{enumerate} \begin{figure}[t] \centering % Core-TikZ only: no positioning/calc/arrows.meta libraries required. \begin{tikzpicture}[font=\scriptsize, >=stealth] % lane x-coordinates \def\xT{0}\def\xB{2.0}\def\xE{4.0}\def\xG{6.0} % actor boxes (manual placement) \foreach \x/\lab in {\xT/Tenant, \xB/{Attest.\ Broker}, \xE/{GPU TEE Encl.}, \xG/{Kueue Gate}}{ \draw[rounded corners] (\x-0.75,0.25) rectangle (\x+0.75,-0.25); \node at (\x,0) {\lab}; \draw[dashed,gray] (\x,-0.25) -- (\x,-5.0); } % messages (rows at fixed y) \draw[->,thick] (\xT,-0.7) -- (\xG,-0.7) node[midway,above]{2. submit(model,id)}; \draw[->,thick] (\xB,-1.4) -- (\xE,-1.4) node[midway,above]{3. nonce $n$}; \draw[->,thick] (\xE,-2.1) -- (\xB,-2.1) node[midway,above]{Evidence($n$)}; \draw[->,thick] (\xB,-2.8) -- (\xG,-2.8) node[midway,above]{4. Result $A$}; \draw[->,thick] (\xE,-3.5) -- (\xG,-3.5) node[midway,above]{load, digest, $B$}; \draw[->,thick] (\xG,-4.2) -- (\xE,-4.2) node[midway,above]{5. admit / 6. serve}; \end{tikzpicture} \caption{Sequence sketch of the ACI binding: attestation ($A$) and provenance-checked weight load ($B$) both flow to the admission gate, which admits only when the binding is valid. The signed binding entry $B$ is appended to the ledger for later regulator re-verification.} \label{fig:seq} \end{figure} Figure~\ref{fig:seq} sketches the runtime path. The essential move is that both the attestation result $A$ (proving \emph{where}) and the provenance-checked digest inside $P$ (proving \emph{what}) converge at the admission gate and are frozen together into the signed binding $B$. \section{Security Analysis} \label{sec:security} We argue each requirement against the adversaries, then discuss two limitations we do not paper over. \paragraph{\req{1} (freshness) vs.\ $\mathcal{A}_{\text{net}}$.} The broker's per-request nonce makes replayed Evidence detectable: a stale $A$ carries an old nonce and fails verification \citep{ietf2023rats,sinaki2026trustmee}. Binding $B$ over \texttt{req\_id} and timestamp further prevents re-presenting an old binding for a new request. \paragraph{\req{2} (provenance) vs.\ $\mathcal{A}_{\text{op}}$.} A curious operator who substitutes weights changes the loaded digest; step~4 requires \texttt{loaded\_digest = digest($P$)}, and $P$ is signed under a release key the operator does not control. A backdoored variant therefore cannot form a valid $B$ against the audited $P$ \citep{tan2026attesting,ahi2026scalability}. \paragraph{\req{3} (non-repudiation) vs.\ $\mathcal{A}_{\text{op}}$.} The ledger is append-only and each entry is signed; the \comp{Regulator Verifier API} lets an external party re-verify signatures and the enclave measurement independently. The operator cannot selectively delete or forge entries without breaking the ledger signature or the append-only property. This is the mechanism that turns existing telemetry-layer governance \citep{mouzouni2026contextk8s,bandara2026aitrustos} into a cryptographic guarantee. \paragraph{\req{4} (scheduler isolation) vs.\ $\mathcal{A}_{\text{co}}$.} Admission binds the attestation and provenance to the requesting tenant's Keycloak identity. A co-tenant cannot be served under another tenant's namespace because the gate rejects any job whose $A$/$P$/$B$ do not match the identity presented at admission, extending existing namespace/RBAC isolation with a cryptographic check rather than replacing it. \paragraph{\req{4} (scheduler isolation) vs.\ $\mathcal{A}_{\text{op}}$.} A subtler case is the operator who controls the gate itself. Because $\mathcal{A}_{\text{op}}$ holds control-plane admin and can alter scheduling, the Kueue Admission Gate runs on operator-controlled infrastructure and therefore cannot be treated as a trusted enforcer against the operator. We are explicit about what the gate does and does not provide here: it delivers \emph{detection, not operator-proof prevention}. If the operator bypasses or disables the gate to serve a shadow request, the honest components never observe a valid $A$/$P$ pair for that request and so \emph{no valid signed binding $B$ is produced and appended to the ledger}. That missing binding is itself the observable evidence of non-compliance: when the regulator later reconciles independently sourced served-request logs (e.g., billing records or API-gateway request counts) against the Binding Ledger, any served request lacking a corresponding valid $B$ is proof that the mediated path was circumvented. Thus the gate is not trusted to \emph{stop} a malicious operator; it is engineered so that evading it leaves a verifiable gap rather than a valid proof. This is why the guarantee does not rest on operator honesty --- it rests on the operator being unable to manufacture a valid $B$ without going through the honest attestation and provenance components (and on the deployment being fail-closed, per the scope assumption of Section~\ref{sec:threat}). \paragraph{\req{5} (overhead).} Analyzed in Section~\ref{sec:overhead} and now \emph{measured} for the software terms in Section~\ref{sec:measured}. The attestation handshake $L_{\text{att}}$ is bounded and amortizable over $N$ requests (subject to the freshness bound of \req{1}); we measured it at $\approx 0.006$~ms/req, amortizing to $\approx 0.00005$~ms/req at $N{=}128$. The ledger-append term $L_{\text{ledger}}$ we measured at $\approx 0.004$~ms/req and it can be further removed from the critical path by pipelining. Together the ACI software binding adds about $0.01$~ms/req, under $0.001\%$ of the measured baseline --- so the \emph{software} half of \req{5} is satisfied empirically. What we cannot yet certify is the intrinsic $L_{\text{TEE}}$ hardware penalty (Section~\ref{sec:discuss}, future work): \req{5} as a whole remains an engineering goal pending that single CC-GPU measurement, consistent with this paper's empirical-honesty framing. \paragraph{Limitation: attestation-to-load TOCTOU.} There is an irreducible time-of-check-to-time-of-use gap between when attestation evidence is produced (step~3) and when weights are loaded and the request is actually served (steps~4--6). If the enclave state could change in that window, a fresh $A$ might not describe the serving state. We narrow --- but do not eliminate --- this window by ordering the load and digest check \emph{after} attestation and by binding both into a single $B$; robust handling of evidence freshness in this window is exactly the concern of self-verifying attestation \citep{sinaki2026trustmee}, which we treat as a dependency rather than re-solve. \paragraph{Limitation: supply-chain root-of-trust custody (orthogonal).} ACI proves that the served weights equal a signed provenance record, but it does not by itself establish that the provenance record describes a \emph{trustworthy} model, nor does it protect the custody of the release signing key $k_{\text{rel}}$. If the release pipeline is compromised upstream, a malicious model can be signed and then faithfully attested. This is the model-supply-chain problem surveyed by \citet{ahi2026scalability}; ACI consumes their control points but the custody of the signing root is orthogonal and must be handled by the release infrastructure (Section~\ref{sec:deploy} sites it in ArgoCD/GitOps). \section{Overhead Model and Measurements} \label{sec:overhead} This section builds an \emph{additive} model of total per-request overhead. The two ACI-specific software terms ($L_{\text{att}}/N$ and $L_{\text{ledger}}$) are now populated with values we \emph{measured} on real H200 hardware (Section~\ref{sec:measured}); the intrinsic GPU-TEE term $L_{\text{TEE}}$ remains populated only with ranges attributed to cited studies, because CC mode was disabled on our cluster. We invent no numbers and never present the cited $L_{\text{TEE}}$ range as our own measurement. We decompose the total inference latency under ACI as: \begin{equation} \label{eq:overhead} L_{\text{ACI}} = L_{\text{base}} + L_{\text{TEE}} + \frac{L_{\text{att}}}{N} + L_{\text{ledger}}, \end{equation} where $L_{\text{base}}$ is baseline (non-CC) inference latency, $L_{\text{TEE}}$ is the intrinsic confidential-computing overhead, $L_{\text{att}}$ is the one-time attestation-handshake cost amortized over $N$ requests served by the same attested enclave session, and $L_{\text{ledger}}$ is the per-request signed-append cost. The throughput penalty is dominated by the $L_{\text{TEE}}$ term, since the attestation handshake is amortized and the ledger append is off the critical path if pipelined. The key qualitative point that the cited literature supports is that $L_{\text{TEE}}$ is small and \emph{shrinks} with scale, so the total is governed by amortization ($N$) and by keeping the ledger append asynchronous. Table~\ref{tab:overhead} collects the source-attributed ranges we use to reason about each term. We deliberately give ranges, not point estimates, and attribute each inline. \begin{table}[t] \centering \caption{Source-attributed ranges for the intrinsic GPU-TEE term of Eq.~\eqref{eq:overhead}. These are values reported by the cited papers, \emph{not} measurements by us: CC mode was disabled on our cluster. The two ACI-specific software terms are instead \emph{measured} in this work (Table~\ref{tab:measured}, Section~\ref{sec:measured}).} \label{tab:overhead} \footnotesize \begin{tabular}{@{}p{0.30\columnwidth}p{0.30\columnwidth}p{0.28\columnwidth}@{}} \toprule \textbf{Term} & \textbf{Reported range} & \textbf{Source} \\ \midrule $L_{\text{TEE}}$ (GPU CC throughput penalty) & 4--8\%, shrinks with batch/input size & \citet{chrapek2025confidential} \\[2pt] $L_{\text{TEE}}$ (CC-mode, typical query) & $<7\%$; $\approx 0$ for larger models / longer sequences & \citet{zhu2024hopperbenchmark} \\[2pt] $L_{\text{TEE}}$ (CPU-TEE, for hybrid paths) & $<10\%$ throughput; $\approx 20\%$ latency & \citet{chrapek2025confidential} \\[2pt] Hardware availability (context for $N$, scale) & local/private LLM deployment reaching SME/consumer budgets on Blackwell-generation hardware & \citet{knoop2026privatellm} \\[2pt] $L_{\text{att}}$ (software handshake) & measured $\approx 0.006$~ms; amortized over $N$; freshness-bounded & this work (Table~\ref{tab:measured}) \\[2pt] $L_{\text{ledger}}$ (signed append) & measured $\approx 0.004$~ms; off critical path if pipelined & this work (Table~\ref{tab:measured}) \\ \bottomrule \end{tabular} \end{table} \paragraph{Reading the model.} From \citet{zhu2024hopperbenchmark,chrapek2025confidential}, the intrinsic CC term $L_{\text{TEE}}$ contributes a single-digit-percent throughput penalty in the regimes most relevant to LLM serving (larger models, longer sequences), because the binding cost is PCIe-transfer bound rather than compute bound. The two ACI-specific terms are, by construction, controllable: $L_{\text{att}}/N \to 0$ as a single attested enclave session serves more requests (subject to the freshness bound of \req{1}, which caps how large $N$ can grow before re-attestation), and $L_{\text{ledger}}$ can be removed from the critical path by appending asynchronously after the response is returned. Our measurements (Section~\ref{sec:measured}) confirm this directly for the software terms: the combined ACI software binding path adds about $0.01$~ms per request, under $0.001\%$ of the measured baseline latency. ACI's marginal overhead beyond intrinsic CC is therefore dominated by the $L_{\text{TEE}}$ term and by amortization policy rather than by the binding software itself. We still attach no percentage to $L_{\text{TEE}}$ in our own regime, precisely because CC mode was disabled and we could not measure it; it remains the single cited-only term. \subsection{Measured Results (software binding path)} \label{sec:measured} We measured the ACI software binding path on a real sovereign-class cluster. This measures everything in Eq.~\eqref{eq:overhead} \emph{except} the intrinsic $L_{\text{TEE}}$ term, which requires CC mode. \paragraph{Environment.} Cluster \texttt{tkai-prod-compute-h200}: four NVIDIA H200-NVL GPUs (Hopper, driver 580.65.06, CUDA 13.0), AMD EPYC~9335 32-core CPU. \textbf{CC mode was OFF} (\texttt{nvidia-smi conf-compute -f} reports \texttt{CC status: OFF}; no SEV/TDX confidential VM). The baseline $L_{\text{base}}$ is vLLM serving \texttt{Qwen3.6-35B-A3B} at \texttt{max\_tokens}${=}128$. The software binding terms were exercised with standard cryptographic primitives (SHA-256 digest, signed append) on the same hardware. Because CC mode was off, we do \emph{not} report $L_{\text{TEE}}$ or hardware GPU-TEE evidence generation; those remain the cited-only ranges of Table~\ref{tab:overhead}. \begin{table}[t] \centering \caption{Measured ACI software-binding overhead on \texttt{tkai-prod-compute-h200} (4$\times$H200-NVL, EPYC~9335, \textbf{CC mode OFF}). All rows are our own measurements. The GPU-TEE throughput penalty $L_{\text{TEE}}$ and hardware attestation-evidence generation are \emph{not} in this table --- they remain source-cited (Table~\ref{tab:overhead}) as CC mode was unavailable.} \label{tab:measured} \footnotesize \begin{tabular}{@{}p{0.44\columnwidth}p{0.30\columnwidth}p{0.14\columnwidth}@{}} \toprule \textbf{Quantity} & \textbf{Measured} & \textbf{$n$} \\ \midrule $L_{\text{base}}$ (H200 vLLM, Qwen3.6-35B-A3B, 128 tok) & $4286.1$~ms/req; $29.9$~tok/s & 12 \\[2pt] $L_{\text{ledger}}$ signed append & $0.0037$~ms/req & 3000 \\[2pt] \quad signing overhead (over plain DB append) & $0.0014$~ms/req & 3000 \\[2pt] Provenance full-shard digest (512~MB, one-time) & $249$~ms $=2.15$~GB/s & --- \\[2pt] Provenance per-request digest verify & $0.00014$~ms/req & 20000 \\[2pt] $L_{\text{att}}$ software flow (nonce$\to$claims$\to$sign$\to$verify) & $0.0062$~ms/req & 3000 \\[2pt] \quad amortized $L_{\text{att}}/N$ at $N{=}128$ & $0.00005$~ms/req & --- \\[2pt] \midrule \textbf{ACI software path total} & $\approx 0.01$~ms/req & \\[2pt] \textbf{as \% of $L_{\text{base}}$} & $0.0002\%$ ($<0.001\%$) & \\ \bottomrule \end{tabular} \end{table} \paragraph{Reading the measurements.} Table~\ref{tab:measured} shows the entire ACI software binding path --- signed ledger append ($0.0037$~ms, of which only $0.0014$~ms is the signing overhead over a plain append), per-request provenance-digest verification ($0.00014$~ms), and the software attestation flow ($0.0062$~ms, amortizing to $0.00005$~ms/req at $N{=}128$) --- sums to about $0.01$~ms per request. Against the measured $L_{\text{base}}=4286$~ms that is $0.0002\%$ of inference latency, below $0.001\%$: negligible for interactive serving, so the software binding is not the cost concern. The one-time full-shard digest runs at $2.15$~GB/s and is amortized over the model's serving lifetime; only the per-request digest verify (not the full re-hash) is on the request path. This measured result satisfies the \emph{software} portion of \req{5}; the remaining question for \req{5} is purely the intrinsic $L_{\text{TEE}}$ hardware penalty, which the cited literature places at 4--8\% (Table~\ref{tab:overhead}) and which we flag as the sole outstanding measurement (Section~\ref{sec:discuss}). \section{Deployment Mapping on ThakiCloud's Stack} \label{sec:deploy} We map ACI onto a real sovereign platform as a case study, not a benchmark. The platform runs a Go (Fiber) backend, PostgreSQL, a NATS event bus, Keycloak for multi-tenant IAM/RBAC, Kueue (with MultiKueue) for Kubernetes-native GPU job admission, ArgoCD for Helm-based GitOps delivery, and a container registry for model/serving images. \begin{itemize} \item \textbf{\comp{Provenance Registrar} $\to$ ArgoCD/GitOps release.} Because ArgoCD already gates release via Git and Helm, it is the natural point to sign the provenance record $P$ at rollout time, realizing the ``mandatory pre-deployment verification gate'' of \citet{ahi2026scalability}. The release signing key $k_{\text{rel}}$ is custodied by the release pipeline, keeping the orthogonal custody concern (Section~\ref{sec:security}) inside GitOps. \item \textbf{\comp{Attestation Broker} $\to$ a cluster service (RATS Verifier).} A dedicated service plays the RATS Verifier role \citep{ietf2023rats}, issuing nonces and validating GPU/CPU TEE Evidence; NATS carries the attestation events between the broker, the enclave, and the gate. \item \textbf{\comp{Binding Ledger} $\to$ append-only table in PostgreSQL (plus signatures).} The existing PostgreSQL instance stores signed binding entries $B$; append-only semantics and per-row signatures give non-repudiation without introducing a new datastore. \item \textbf{\comp{Kueue Admission Gate} $\to$ Kueue admission check.} Kueue already decides \emph{whether} a GPU job may run; ACI adds a predicate that the job's attestation/provenance binding is valid and consistent with the tenant's Keycloak identity, so GPU admission itself enforces \req{4}. \item \textbf{\comp{Regulator Verifier API} $\to$ Go (Fiber) read-only endpoint.} A read-only route exposes $\{A,P,B\}$ by \texttt{req\_id} for independent re-verification, scoped by Keycloak so a regulator sees only the tenant scope they are authorized for. \end{itemize} The design intent is that ACI reuses the platform's existing identity (Keycloak), scheduling (Kueue), release (ArgoCD), storage (PostgreSQL), and eventing (NATS), adding cryptographic binding rather than new isolation machinery. This is what lets a sovereign operator convert mechanisms it already runs for multi-tenant isolation into a regulator-auditable guarantee. \section{Discussion and Limitations} \label{sec:discuss} \paragraph{Remaining limitation: the GPU-TEE hardware layer.} The software protocol \emph{is} now measured (Section~\ref{sec:measured}): the two ACI-specific terms of Eq.~\eqref{eq:overhead} ($L_{\text{att}}/N$ and $L_{\text{ledger}}$) were measured on a real H200 cluster and are negligible. The sole remaining unmeasured piece is the GPU-TEE hardware component, because CC mode was disabled cluster-wide on our evaluation hardware: the intrinsic $L_{\text{TEE}}$ throughput penalty and the hardware GPU-TEE attestation-evidence generation could not be exercised. For those we still inherit ranges from \citet{zhu2024hopperbenchmark,chrapek2025confidential} rather than measuring in our own serving regime, consistent with the still-early state of comprehensive end-to-end CPU/GPU-TEE AI evaluation \citep{schambach2026enclavex}. The single concrete future measurement is to enable CC mode on Hopper/Blackwell and measure $L_{\text{TEE}}$ and hardware evidence generation directly. The broader trend toward on-prem/local LLM deployment reaching cost-sensitive SME tiers on Blackwell-generation hardware \citep{knoop2026privatellm} --- independent of whether CC mode itself is available at that tier --- suggests demand for this design substrate is growing even as the CC-GPU measurement access gap persists. \paragraph{Cross-cluster ledger federation.} Sovereign deployments often span multiple clusters (e.g., MultiKueue). A single-cluster binding ledger does not yet give a coherent cross-cluster audit view; federating append-only ledgers while preserving non-repudiation is open work, adjacent to the continuous cross-environment governance framing of \citet{bandara2026aitrustos}. \paragraph{Enclave revocation mid-session.} Amortizing the attestation handshake over $N$ requests (Section~\ref{sec:overhead}) trades against freshness: if an enclave must be revoked mid-session (e.g., a vulnerability disclosure), requests served after revocation but before re-attestation are a hazard. A revocation-aware freshness policy that bounds $N$ dynamically, again leaning on self-verifying attestation \citep{sinaki2026trustmee}, is needed. \paragraph{Scope of the confidentiality claim.} For RAG deployments the confidentiality claim must extend to retrieval-time context, not only weights \citep{xu2026securingrag}; ACI's binding centers on weight provenance and treats retrieval isolation as an in-enclave property that attestation covers but provenance does not certify. Property-level guarantees (e.g., differential privacy) are complementary and could be layered via \citet{chantasantitam2026palm}. Relatedly, the whole guarantee is scoped to requests that traverse the mediated ingress path and depends on the fail-closed deployment assumption of Section~\ref{sec:threat}: for an out-of-band shadow request, ACI offers detection via ledger reconciliation rather than prevention, not an airtight bar against a root-holding operator. \section{Conclusion} Sovereign on-premises AI for regulated sectors needs to prove two things to a regulator that does not trust the operator: that data never left a GPU enclave, and that the audited weights served each request. The hardware and provenance building blocks exist separately but are never joined. We proposed \emph{Attested Confidential Inference}, a protocol that cryptographically binds RATS-style remote attestation to a signed model-provenance record and enforces that binding at Kueue job admission, producing a per-request, regulator-verifiable proof that links enclave identity, tenant identity, and audited weight digest. We gave a threat model with five requirements, an architecture and protocol flow, a security analysis that confronts the attestation-to-load TOCTOU window and the orthogonal supply-chain custody problem, an overhead model whose software terms we measured on a real H200 cluster (the ACI software binding adds under $0.001\%$ of inference latency) and whose GPU-TEE term remains source-attributed, and a mapping onto a real Keycloak/Kueue/ArgoCD/PostgreSQL/NATS stack. With the software protocol now measured, one measurement remains: enabling CC mode on Hopper/Blackwell GPUs to measure the intrinsic TEE throughput penalty and hardware attestation-evidence generation, blocked today by CC mode being disabled on our cluster rather than cited. \bibliography{refs} \end{document}