Partitioned Model Execution for Confidential Computing

This direction is merged into another direction: trusted execution environments. Its last version stays readable and citable here.

Version 1 of 117 papers20 conceptsfrozen 2026-10-04

The deployment of deep learning models on edge devices and untrusted cloud servers creates a fundamental tension between security and performance. To protect intellectual property (model weights) and user privacy (input data), researchers use Trusted Execution Environments (TEEs)—secure hardware enclaves like Intel SGX or ARM TrustZone that isolate sensitive computations from the rest of the system.

However, TEEs are notoriously resource-constrained. They often lack access to high-performance GPUs and suffer from severe memory limitations and execution overhead. To bridge this gap, a new research direction has emerged: Partitioned Model Execution. Instead of running an entire model within a slow, secure enclave, these frameworks split the workload, delegating the heavy lifting to untrusted accelerators while keeping the "secret sauce" or sensitive logic inside the TEE.

The Linear-Nonlinear Split

The most common strategy for partitioning relies on a mathematical observation: the bulk of a neural network's computational cost comes from linear operations (convolutions and matrix multiplications), while its "intelligence" or non-linearity is often concentrated in activation functions (ReLU, Sigmoid).

In Slalom: Fast, Verifiable and Private Execution of Neural Networks in Trusted Hardware, Dan Boneh and Florian Tramèr demonstrate that linear operations can be safely outsourced to an untrusted GPU using cryptographic blinding. By adding random noise to the data before sending it to the GPU and then subtracting it within the TEE, the system achieves a 6x to 20x throughput increase.

Similarly, ShadowNet, developed by Zhichuang Sun and colleagues, uses this partitioning to protect model weights. They execute non-linear layers within the TEE and offload obfuscated linear layers to the accelerator, ensuring that the untrusted hardware never sees the raw weights or the cleartext activations.

Obfuscation and Weight Transformation

A more recent evolution in this field moves away from layer-by-layer splitting toward global model transformations. The goal is to make the data "unreadable" to the GPU while still allowing the GPU to perform valid mathematical operations on it.

Amulet, by Lingchen Zhao and Cong Wang, uses the TEE primarily for initial data obfuscation and final restoration. This "constant-round interaction" minimizes the communication bottleneck between the secure enclave and the GPU. By transforming the model into a secure, GPU-ready format, they achieve speedups of up to 9x over traditional TEE methods.

SLIM applies a similar logic to Large Language Models (LLMs). Wei Wang and Zihao Guan introduce a "T-Way Mixing" algorithm that allows the bulk of the transformer computation to happen on untrusted hardware while restricting secure operations to the network's entry and exit points. This ensures the data remains in a transformed state throughout the untrusted execution phase.

Selective Shielding of Model Components

As models grow larger, protecting every parameter becomes impractical. Researchers like Peter M. VanNostrand and Tian Guo have explored "hybrid execution branching," where only high-level feature extraction—the most proprietary part of a model—is routed to the TEE (Confidential Deep Learning).

This concept is refined in AegisGuard, where CHE WANG and Ziqi Zhang use reinforcement learning to identify and shield only the most "sensitive" adapters in a fine-tuned model. By leaving the massive, public base model in untrusted memory and only protecting the small, task-specific adapters in the TEE, they reduce memory usage by 4x while maintaining high security against model-stealing attacks.

Verification via Distillation

Finally, partitioning can be used for integrity—ensuring the untrusted server actually ran the model correctly. Fides, proposed by Reza Tourani, runs a massive service model on an untrusted server but keeps a tiny, distilled "verification model" inside the TEE. By comparing the outputs of the two, the TEE can detect if the server attempted to manipulate the results, achieving a 26x speedup over running the full model securely.

Why It Works: The Efficiency of Asymmetry

The success of partitioned execution stems from the asymmetry of neural network operations.

  1. Computational Asymmetry: A few layers (linear) account for 99% of the FLOPs, while others (non-linear) define the model's logic.
  2. Information Asymmetry: In modern LLMs, the base knowledge is often public, while the "value" lies in small, fine-tuned adapters.
  3. Verification Asymmetry: It is often much cheaper to verify a result (using a distilled model or cryptographic check) than it is to compute it from scratch in a secure environment.

By exploiting these asymmetries, researchers are moving toward a future where "Confidential Computing" is no longer a synonym for "slow computing." As Ben Dong notes in his evaluation of DeepSeek-R1 in TEEs, the path forward for massive models lies in these hybrid execution models that intelligently split the burden between the fortress (TEE) and the factory (GPU).

Papers in this version

History & citationVersion 1 · 2026-10-04

Merged into another direction · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_partitioned_model_execution_for_confiden_9b4b2d0d,
  title = {Partitioned Model Execution for Confidential Computing},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/partitioned-model-execution-for-confidential-computing/rdr_9b4b2d0dbd034dd190eb30e143c2b70d},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_partitioned_model_execution_for_confiden_9b4b2d0d_v1,
  title = {Partitioned Model Execution for Confidential Computing},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/partitioned-model-execution-for-confidential-computing/rdr_9b4b2d0dbd034dd190eb30e143c2b70d/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}