AI Infra Interviews logo

Confidential GPU Inference: Encryption, Attestation and Air-Gapped Deployment

Understand what confidential GPUs protect, where prompts decrypt, how attestation controls model-key release, and why local verification can still fail in an air-gapped deployment.

BY DEVIN PORTER · AIINFRAINTERVIEWS EDITORIAL · UPDATED NOVEMBER 6, 2026 · 4 MIN READ

PRACTICE THIS:Practice the confidential inference design question ·Build the confidential deployment runbook ·Study confidential GPU trust boundaries

Confidential GPU inference protects sensitive execution from specified actors, such as a host operator, by placing the workload inside a supported CPU/GPU trust boundary. Prompts and weights still become plaintext there. Attestation supplies evidence about the environment; a release policy decides whether it may receive protected keys. An air gap adds a separate network constraint and requires a plan for dependencies that normally refresh online.

These distinctions matter in architecture reviews and interviews. “The data is encrypted” leaves several unanswered questions: encrypted where, decrypted by whom, and authorized using which evidence? This guide gives you the starting model. The linked Premium concepts, questions and course module develop the implementation and troubleshooting exercises.

Start where the prompt decrypts

A customer sends a prompt over HTTPS to a gateway. If the gateway terminates TLS on a host the operator controls, it can read the prompt before any GPU executes. Placing a confidential accelerator behind it does not undo that exposure.

For the intended design, the customer accepts an endpoint bound to the approved workload. The outer gateway can route an encrypted payload, while decryption happens inside the protected guest. Tokenization, retrieval, cached attention state and response handling must follow the same data-flow contract.

Three questions before choosing a confidential platform
  1. Where does the request become plaintext?

    Place the protected endpoint inside the intended boundary.

  2. What authorizes that workload to receive keys?

    Verify fresh evidence, workload policy and recipient binding.

  3. What can carry plaintext back out?

    Review responses, tools, logs, caches and failure handling.

These decisions connect network encryption, confidential execution and application behavior.

The Confidential Inference concept follows these paths in detail. It also explains a limitation that hardware cannot remove: approved application code sees plaintext and can disclose it through an authorized output or a bug.

Know what each security term promises

TermMain boundaryWhat still needs a separate answer
TLSData between connection endpointsWhether either endpoint can expose plaintext
Storage encryptionStored bytes and their keysAccess after an application decrypts them
Confidential computing / TEEExecution under a hardware-backed threat modelTrusted code, outputs and excluded attacks
Private or sovereign hostingNetwork placement, residency or operational controlWho can inspect executing workloads
Air-gapped deploymentRestricted or absent external connectivityLocal administrator access and offline dependencies
Fully homomorphic encryptionSupported computation on ciphertextPractical operations, performance and output policy
Secure multiparty computationJoint computation under a defined party/collusion modelWhich parties may collude and what results reveal
Differential privacyBounds on information revealed about individual recordsThe chosen mechanism, privacy budget and implementation

These terms describe different mechanisms and can be combined. A private network is not evidence that its servers execute confidentially. A TEE does not automatically give the outputs a differential-privacy guarantee. See NIST's privacy-enhancing cryptography overview and differential-privacy guidance for those separate guarantees. The Confidential Computing Consortium's comparison with homomorphic encryption explains protected plaintext execution versus computation on ciphertext.

Avoid that blanket claim. NVIDIA's documented threat model describes plaintext in GPU memory protected by hardware access restrictions, alongside protected CPU/GPU transfers. The details depend on the supported configuration.

Multi-GPU support needs particular care. Hopper Protected PCIe and supported Blackwell multi-GPU configurations have different peer-fabric protection. An encrypted host transfer does not establish that a separate GPU-to-GPU path is encrypted. Cloud products can expose a narrower configuration than the underlying hardware supports.

For a two-GPU sketch, draw three logical edges: CPU to GPU A, CPU to GPU B, and GPU A to GPU B. Checking two edges leaves a potentially sensitive third path. The GPU trust-boundary question develops that reasoning and its physical assumptions.

Attestation must connect to a release decision

A signed device report is evidence, not an instruction to release every secret. A verifier checks authenticity and acceptable state. The resource owner then applies a policy for the workload, tenant and requested key. Freshness prevents old evidence from being reused outside its accepted window; recipient binding prevents valid evidence from being relayed to obtain a secret on an unapproved connection.

GPU firmware evidence also does not identify the entire serving application. The approved guest needs to enforce what code and configuration can run, including mutable mounts and downloaded extensions. Remote Attestation and Key Release separates these decisions and explains why decoding a token is not signature verification.

The Kubernetes configuration question maps the process to CPU TEE setup, device passthrough, runtime selection and guest policy. A node label or a running pod selects and reports operational behavior; neither is a substitute for accepted evidence.

An air gap creates a freshness problem

A local verifier may still call an online service for reference measurements or certificate status. NVIDIA states those dependencies in its local-verifier integration. Disconnected operation therefore needs supported provisioning and refresh procedures, not simply a copy of the verifier executable.

Take an illustrative bundle whose earliest required admission input remains usable for 72 hours. With 24 hours reserved for recovery, refresh must start by hour 48. A site that imports material every seven days cannot promise replacement admission throughout that interval using this bundle. Seven days plus the reserve requires 192 hours of usable horizon. That requirement cannot extend a certificate's validity.

The air-gapped deployment concept covers artifact provenance, local identity, time, storage and recovery. Its key acceptance test is a fresh replacement with external routes unavailable. A warm process can conceal missing downloads and resident keys.

Learn it through an acceptance runbook

The new Premium module in Fleet and Reliability produces three artifacts: a plaintext-boundary worksheet, a policy decision table, and a disconnected deployment runbook. The CPU-only policy lab tests one accepted fixture and 15 denied variants. It does not claim to perform hardware attestation.

Continue with failed-attestation diagnosis and confidential-serving performance measurement. A useful design can explain both why a launch is denied and how its accepted configuration meets the service objective. Keep source-reviewed configuration, simulated results and hardware measurements visibly distinct.

PRACTICE THIS

Turn it into offers. Work the real questions and concepts this maps to:

FAQ

It is a GPU operating in a supported protected-execution configuration that restricts access to workload data under a stated threat model. Execution still uses plaintext inside the protected boundary. Transfer encryption, memory protection and multi-GPU fabric support depend on the exact platform.

Discussion (4)

Devin PorterEditor

An image digest becomes a weak workload identifier if the launch configuration can mount a different executable over it. The review needs to follow what actually runs, including extensions loaded after startup.

Deepa VenkateshEditor

That also changes rollback review. Restoring yesterday's image with today's mutable configuration does not restore yesterday's workload. Keep the approved tuple in the release record.

Maya CastilloEditor

A privacy boundary can change batching choices. If several tenants share one accepted process, the process still has to enforce cache and response ownership. Hardware isolation from the host does not make those tenants mutually isolated inside the application.

Jonas WeberEditor

The word offline needs a duration beside it. A replacement that works immediately after import tells us little about the same replacement after the earliest required trust object expires.