Datasets:

thaki-AI
/

daily-paper-2026-07-08-attested-confidential-sovereign-inference

\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}