Confidential GPU Computing: Why Intel TDX Changes Everything for AI Privacy

What Is Confidential Computing?

Confidential computing is a hardware-based security paradigm that protects data while it is being processed. Unlike traditional encryption that only covers data at rest (on disk) and in transit (over the network), confidential computing creates a Trusted Execution Environment (TEE) that encrypts data in use, in memory, in GPU VRAM, and across the PCIe bus.

The core idea is that the software layers above your workload cannot read it. The hypervisor, the host OS and other tenants cannot read the contents of a TEE, and that is enforced by the CPU and memory controller hardware rather than by software policy.

Where the boundary actually stops, because it is better said by us than discovered later. Intel states that physical interposer attacks fall outside the protection provided by its memory encryption. On 14 September 2026 researchers from KU Leuven, ETH Zurich, Durham University and Google published DDRop: with a circuit board costing under 200 dollars, inserted between the processor and a DDR5 module by someone who already has software control of the host, they took full control of a protected VM, read its private memory, and overwrote the launch measurement a VM uses to prove its state to a remote verifier. Intel and AMD both answered that physical access is outside their published threat model, and Intel does not plan to assign a CVE. So TDX defends against the software adversary, which is the hypervisor, the host OS, other tenants and remote attackers. It does not defend against someone who can open the machine, and no attestation, ours included, changes that.

Intel TDX: Trust Domain Extensions

Intel Trust Domain Extensions (TDX) is Intel's latest confidential computing technology, available on 4th and 5th Gen Xeon Scalable processors. TDX creates isolated Virtual Machines called Trust Domains (TDs) that are cryptographically isolated from the host, the VMM (Virtual Machine Monitor), and other TDs.

Key capabilities of Intel TDX for GPU workloads:

• Memory encryption with integrity: All TD memory is encrypted using AES-256-XTS with per-TD keys managed by the CPU. Memory integrity checking prevents physical tampering.
• Secure PCIe (TEE-IO): Data flowing between CPU and GPU over PCIe is encrypted, preventing interception. This is critical for GPU workloads where tensor data constantly moves between host and device memory.
• Remote attestation: Before sending sensitive data, clients can cryptographically verify that the TD is running the expected software stack, has not been tampered with, and is on genuine Intel hardware.
• Sealed storage: Encryption keys are bound to the specific TD measurement, so data encrypted by one enclave cannot be decrypted by another, even on the same physical machine.

Why Confidential GPUs Matter for AI

The AI industry has a dirty secret: most GPU providers can technically access your data. When you send a prompt to an API or fine-tune a model on rented GPUs, your data sits in plaintext in GPU VRAM. The provider's sysadmins, a compromised hypervisor, or a nation-state actor with physical access could potentially read it.

For many workloads, this is an acceptable risk. But for regulated industries, it is a dealbreaker:

Healthcare (HIPAA)

Hospitals and health-tech companies need to run AI on Protected Health Information (PHI), medical images, patient records, genomic data. HIPAA requires a Business Associate Agreement (BAA) with any service that processes PHI, and most GPU providers either refuse to sign a BAA or charge a massive premium. With TDX, the provider never has access to PHI, simplifying compliance dramatically.

Financial Services

Banks and hedge funds use LLMs on proprietary trading strategies, customer financial data, and fraud detection models. SEC and PCI-DSS regulations require strict data handling. Confidential GPUs allow firms to run AI inference in the cloud without exposing sensitive financial data to the infrastructure provider.

Legal and Government

Law firms processing attorney-client privileged documents and government agencies handling classified or sensitive data need guarantees that extend beyond software-level access controls. TDX provides hardware-enforced isolation that satisfies FedRAMP and ITAR requirements.

AI Model IP Protection

Companies with proprietary fine-tuned models worth millions in R&D investment can deploy them on confidential GPUs, ensuring that model weights are never exposed in plaintext to the infrastructure provider. This enables deploying proprietary models on third-party infrastructure without risk of theft.

How VoltageGPU Implements Confidential Compute

VoltageGPU runs our confidential compute network to provide confidential GPU compute. Here is how the architecture works:

1. TDX-enabled bare metal: Attested providers provision servers with Intel Xeon Scalable (Sapphire Rapids or Emerald Rapids) CPUs and NVIDIA GPUs. The BIOS is configured for TDX with secure boot enabled.
2. TD provisioning: When you deploy a Confidential VM, VoltageGPU instructs the provider to create a Trust Domain with your specified GPU passthrough. The TD is measured and the measurement is recorded.
3. Attestation flow: Once the VM is up, you generate the Intel TDX quote and the NVIDIA GPU report yourself, on a challenge you choose, and verify them against Intel and NVIDIA on your own machine. VoltageGPU is not in that chain.
4. Encrypted channels: All communication with the TD (SSH, API calls, data transfer) uses TLS 1.3 terminating inside the enclave. The host system only sees encrypted traffic.

Available GPUs in TDX Enclaves

Deploy a Confidential VM via API

Deploying a Confidential GPU VM on VoltageGPU is self-service and takes one API call once an SSH key is registered. The VM runs inside a TDX Trust Domain, and you generate the attestation yourself, inside it. (Updated October 2026: the container tier was retired by the provider on 1 October 2026; only Confidential VMs are sold.)

# 1. Register your ed25519 public key (a Confidential VM binds it at creation)
curl -s -X POST https://voltagegpu.com/api/volt/ssh-keys \
  -H "Authorization: Bearer $VOLTAGE_API_KEY" -H "Content-Type: application/json" \
  -d '{"name":"laptop","public_key":"ssh-ed25519 AAAA..."}'

# 2. Live SKUs (the resource_name values) and their attestation status
curl -s https://voltagegpu.com/api/confidential/vm/tiers \
  -H "Authorization: Bearer $VOLTAGE_API_KEY"

# 3. Deploy. One hour is charged upfront, the unused part is refunded on release.
curl -s -X POST https://voltagegpu.com/api/confidential/vm/deploy \
  -H "Authorization: Bearer $VOLTAGE_API_KEY" -H "Content-Type: application/json" \
  -d '{"name":"my-vm","resource_name":"rtx6000b-small","hardstop_hours":1}'

Once the VM is up, you generate both proofs inside it and verify them on your own machine:

# Inside the VM: generate both proofs on a challenge you choose
python3 -m pip install --user --break-system-packages "voltage-verify[attest]>=0.2.1"
export PATH=$HOME/.local/bin:$PATH
voltage-verify manifest --challenge auto -o manifest.json
sudo env PATH=$PATH PYTHONPATH=$(python3 -c 'import site;print(site.getusersitepackages())') \
  voltage-verify attest --manifest manifest.json --mode single-gpu -o bundle.json

# On your own machine: verify the Intel TDX quote and the NVIDIA GPU report
pip install "voltage-verify>=0.2.1"
voltage-verify verify bundle.json --challenge <the challenge printed above>
# RESULT: VERIFIED

Use Case: LLM Inference Under HIPAA Technical Safeguards

Here is a real-world scenario: a telehealth startup needs to run Llama 3.1 70B on patient conversations for clinical summarization. They need to satisfy the HIPAA Security Rule safeguards, which means PHI must never be accessible to the infrastructure provider.

from openai import OpenAI

# All traffic encrypted end-to-end via TDX enclave
client = OpenAI(
    base_url="https://api.voltagegpu.com/v1",
    api_key="YOUR_API_KEY"
)

# Your prompt never leaves the encrypted enclave
response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-70B-Instruct",
    messages=[
        {"role": "system", "content": "You are a HIPAA-aligned medical AI."},
        {"role": "user", "content": "Analyze this patient record: [ENCRYPTED_PHI]"}
    ],
    temperature=0.3,
    max_tokens=2048,
    # Confidential mode: data never persisted, no logging
    extra_body={"confidential": True}
)

print(response.choices[0].message.content)

With confidential mode enabled, VoltageGPU guarantees:

• No logging: Prompts and responses are never logged or stored outside the enclave
• No persistence: GPU VRAM is securely wiped after each session
• Attestation proof: Verifiable cryptographic proof that the workload ran in a genuine TDX enclave
• Audit trail: Compliance-ready audit logs showing attestation verification timestamps

Use Case: Private Training Workloads

Training is where confidential compute becomes critical. When you train or adapt a model, your proprietary data, customer conversations, internal documents, domain expertise, gets embedded directly into model weights. On a non-confidential GPU, this data exists in plaintext in VRAM for hours or days during the job.

When you run training workloads on VoltageGPU Confidential Compute:

• Your training data is encrypted in transit and in VRAM
• The resulting model weights are encrypted and only accessible within the enclave
• You can export the trained model via encrypted channels
• No software layer can read your data or model, VoltageGPU and the host included; someone who can open the machine and insert hardware is a different adversary and TDX does not cover it, see the limit stated above

Use Case: Secure Multi-Party AI

Confidential GPUs enable a new paradigm: multiple organizations can collaboratively train or infer on combined datasets without exposing their individual data. Each party verifies the enclave attestation, sends their encrypted data, and the model processes the combined data inside the TEE. No party ever sees another's raw data.

This is transformative for:

• Federated learning across hospitals: Train better diagnostic models without sharing patient data
• Financial fraud detection: Banks can pool transaction patterns without exposing customer information
• Supply chain optimization: Manufacturers share logistics data without revealing trade secrets

Performance Impact

A common concern is that confidential computing adds overhead. Here is the reality with Intel TDX and modern NVIDIA GPUs:

• Memory encryption overhead: 2-5% on compute-bound workloads (LLM inference, training). AES-256-XTS is hardware-accelerated, so the impact is minimal.
• PCIe encryption (TEE-IO): 1-3% overhead on data transfer. Negligible for large batch inference and training where GPU compute dominates.
• Attestation: One-time cost at VM startup (under 10 seconds). Does not affect runtime performance.
• Total overhead: 3-8% for typical AI workloads. A small price for hardware-enforced data protection.

Getting Started

Confidential GPU compute on VoltageGPU is available today. Here is how to get started:

1. Create an account at voltagegpu.com: sign-up is free, and your first top-up of $10 or more (card or crypto) comes with the first hour offered
2. Generate an API key in your dashboard settings
3. Deploy a Confidential VM using the API or dashboard
4. Verify attestation programmatically before sending sensitive data
5. Run your workload: inference or training in a hardware-secure enclave

If you are in healthcare, finance, legal, or government and need confidential GPU compute for GDPR or HIPAA-regulated work, see the live confidential GPU lineup or reach out at contact@voltagegpu.com for enterprise plans.

Further reading

• GDPR & AI in 2026: why a DPA is not enough, you need hardware sealing , the legal-side companion to this technical piece.
• HIPAA AI inference without a BAA: how confidential compute changes the conversation , what TDX means for protected health information.
• EU AI Act August 2026: high-risk LLM compliance with TDX attestation , how attestation quotes become regulator-grade evidence.
• Confidential GPU pricing, VoltageGPU vs Azure vs AWS , the cost comparison for the same TDX hardware.
• H100 TDX, H200 TDX, and and current prices , per-GPU specs and pricing.