SEED: Streamlined End-to-End Data Processing in Cloud Environments
Omar Jarkas (Paper author · The University of Queensland), Ryan Ko (Paper author · The University of Queensland), Naipeng Dong (Paper author · The University of Queensland), MD Redowan Mahmud (Paper author · Curtin University)
Privacy Enhancing Technologies Symposium (PETS) 2026 · Day 2 · Alpaca
Overview
In an era defined by the exponential growth of generative AI and the increasing reliance on cloud infrastructure for data processing, the need for robust data confidentiality and integrity has never been more critical. The SEED talk, presented by Omar Jarkas at PETS, introduces a novel framework for verifiable confidential microservice deployment, addressing the inherent challenges of protecting AI workloads in cloud environments. The core problem tackled is the lack of comprehensive end-to-end confidentiality and integrity guarantees for data processed by AI models, particularly when deployed as microservices within containerized environments like Kubernetes.

Key moments
- 0:00 Introduction to confidential computing and problem scope
- 2:20 Identifying the gap in end-to-end confidential AI deployment
- 4:00 Why modern operating systems are unsuitable for TEEs
- 5:40 Challenges: container workloads and maintaining trust in TEEs
- 6:30 SEED's architecture for verifiable confidential microservice deployment
- 7:10 Core innovation: container runtime statically linked to kernel
- 7:50 Achieving continuous trust and granular container verification
SEED: Streamlined End-to-End Data Processing in Cloud Environments
Speakers: Omar Jarkas (Paper author, The University of Queensland); Ryan Ko (Paper author, The University of Queensland); Naipeng Dong (Paper author, The University of Queensland); MD Redowan Mahmud (Paper author, Curtin University)
Conference: PETS
YouTube: https://www.youtube.com/watch?v=IiWABrKWmsE
Overview
In an era defined by the exponential growth of generative AI and the increasing reliance on cloud infrastructure for data processing, the need for robust data confidentiality and integrity has never been more critical. The SEED talk, presented by Omar Jarkas at PETS, introduces a novel framework for verifiable confidential microservice deployment, addressing the inherent challenges of protecting AI workloads in cloud environments. The core problem tackled is the lack of comprehensive end-to-end confidentiality and integrity guarantees for data processed by AI models, particularly when deployed as microservices within containerized environments like Kubernetes.
The research zeroes in on the perspective of a platform engineer tasked with deploying large language models (LLMs) to the cloud. Such engineers require assurances that their AI model's sensitive components, such as weights and biases, remain protected, and that user data processed by these models retains its privacy and trustworthiness. Traditional confidential computing solutions, while offering strong isolation, often fall short in providing a truly end-to-end verifiable chain of trust, especially for dynamic container workloads. SEED proposes a paradigm shift, integrating container runtimes directly into a minimized kernel within a Trusted Execution Environment (TEE) to achieve granular, continuous verification and maintain confidentiality throughout the data lifecycle.
This work is particularly timely given the explosion of data being shared with and processed by LLMs, making the protection of this data paramount. By leveraging hardware-backed trust mechanisms, SEED aims to provide a superior solution for safeguarding AI systems in the cloud compared to purely software-based alternatives. The framework seeks to empower organizations to deploy sensitive AI applications with confidence, ensuring both the integrity of their models and the privacy of their users' data.
Background
▶ Watch: Introduction to confidential computing and problem scope (0:00)
Confidential computing has emerged as a critical technology for protecting data in use, typically achieved through Trusted Execution Environments (TEEs). These hardware-backed enclaves provide runtime encryption and isolation for specific workloads, shielding them from the underlying operating system, hypervisor, and even privileged administrators. Key components of confidential computing include attestation, which allows a remote party to verify the integrity and configuration of the workload running within the TEE, and sealing, which protects data when it's stored outside the CPU. Further bolstering trust, Trusted Platform Modules (TPMs) and Integrity Measurement Architecture (IMA) are often used to establish and continuously verify the integrity of software components.
Despite these advancements, the research identified a significant gap: while many existing solutions excel at either providing confidentiality (via TEEs) or integrity verification (via TPMs and IMA), few offer a truly end-to-end confidential and integrity-protected deployment for dynamic AI workloads in the cloud. The talk highlights several issues hindering this goal:
- TEE Delay / TCB Size Paradox: The Trusted Computing Base (TCB) represents the sum of all components whose compromise would lead to a breach of the system's security. A small TCB is desirable for minimizing attack surface. However, a TEE with a very small TCB often limits the functionality that can be delegated outside the enclave, potentially weakening security by forcing trust onto untrusted external components. Conversely, a large TCB, which might include a full-fledged operating system, expands the attack surface, contradicting the TEE's isolation benefits.
- Modern Operating Systems' Unsuitability for Cloud/TEEs: The speakers argue that general-purpose modern operating systems, designed for broad usability with graphical user interfaces and extensive feature sets, are ill-suited for cloud environments and, more specifically, for TEEs. Cloud deployments abstract away much of this general-purpose functionality, prioritizing container workflows, security, scalability, and performance. Within a TEE, many OS features become redundant, as the TEE itself provides isolation and other security primitives, leading to an unnecessarily bloated TCB. This observation led the team to explore specialized operating systems like unikernels and light OS, which offer a minimized attack surface.
- Container Workload Integration: Modern cloud deployments heavily rely on containers and orchestration platforms like Kubernetes for streamlined, automated deployment. Achieving end-to-end confidentiality and integrity requires the underlying operating system within the TEE to seamlessly integrate with and support container runtimes. This integration is crucial for maintaining the security posture from the moment a container is deployed to its execution.
- Continuous Trust with Mutable TCBs: A fundamental challenge arises from the typical assumption of an immutable TCB in many TEE designs. Once a TEE is attested, its TCB is considered fixed. However, dynamic cloud environments require deploying new workloads (containers) at runtime after the TEE is running. To maintain end-to-end confidentiality and integrity for these dynamically loaded containers, a mechanism for continuous trust and verification of changes to the TCB (or components within it) is essential. Breaking the immutable TCB paradigm while preserving strong security guarantees is a critical problem for real-world cloud deployments.
These challenges collectively underscore the need for a re-architected approach to confidential computing, one that can provide robust, verifiable, end-to-end protection for dynamic, containerized AI workloads without compromising on security or performance.
Key Findings
▶ Watch: Why modern operating systems are unsuitable for TEEs (4:00)
The SEED research culminates in several key findings that challenge conventional approaches to confidential computing and container deployment in the cloud:
- General-Purpose Operating Systems are Suboptimal for TEE-Based Cloud Deployments: The talk strongly asserts that modern, general-purpose operating systems are fundamentally not suitable for cloud environments, and even less so for execution within TEEs. Their broad functionality often leads to an inflated TCB within a TEE, introducing unnecessary attack surface and redundancy with the TEE's inherent security features. This finding necessitates a shift towards specialized, minimized operating systems or unikernels tailored for TEE and cloud contexts.
- Existing Solutions Lack End-to-End Confidentiality and Integrity for Cloud AI: While individual components of confidential computing (like TEEs for confidentiality or TPMs/IMA for integrity) are well-established, a holistic framework providing verifiable end-to-end guarantees for AI microservices deployed in the cloud was largely absent in the literature. The work identifies this gap as a critical impediment to widespread secure AI adoption.
- Direct Kernel Integration of Container Runtimes Minimizes TCB and Enables Granular Verification: A pivotal discovery is that by statically linking a custom container runtime directly into a minimized Linux kernel (specifically, a Unikernel for Linux or UKL) within a TEE, a significant portion of user-space functionality can be abstracted. This design drastically reduces the TCB size, making the entire system more secure. Furthermore, treating containers as "first-class citizens" of the kernel allows for granular, container-level verification and attestation, which was previously difficult to achieve with traditional TEE architectures.
- A "Push-Run-Prove" Workflow Enables Continuous Trust with Mutable TCBs: The SEED framework successfully addresses the challenge of continuous trust in dynamic environments. By designing a TCB that allows for the runtime deployment and verification of containers after initial attestation, the system breaks the traditional immutable TCB paradigm. This "push run prove" workflow ensures that even as new, encrypted, and signed containers are deployed from a registry into the running TEE, their integrity and confidentiality can be continuously verified, thereby extending the chain of trust throughout the entire lifecycle of the microservice. This is crucial for supporting the agile deployment needs of cloud-native applications.
Technical Deep Dive
▶ Watch: Challenges: container workloads and maintaining trust in TEEs (5:40)
The technical heart of SEED lies in its innovative approach to integrating container runtimes directly within a minimized operating system running inside a TEE. The goal is to provide end-to-end confidentiality and integrity for containerized AI workloads, overcoming the limitations of traditional TEE deployments.
The speaker began by analyzing existing operating systems suitable for TEEs, including light OS, unikernels, and other monitors. The team ultimately chose UKL (Unikernel for Linux), a unikernel developed by Red Hat, as their base. UKL offered a suitable foundation for modification due to its minimized nature and Linux kernel compatibility.
The core architectural innovation involves a radical TCB minimization strategy. Instead of running a full-fledged operating system and a user-space container runtime alongside the application within the TEE, SEED statically links a custom container runtime directly into the Linux kernel. This design choice achieves several critical objectives:
- Reduced Attack Surface: By abstracting away a significant amount of user-space functionality and integrating the container runtime into the kernel, the overall TCB is drastically reduced. This means fewer lines of code and fewer components that need to be trusted, inherently improving security.
- Optimized for Container Workflows: The custom container runtime is specifically optimized for security and the unique demands of containerized workloads within a TEE. This optimization includes stripping unnecessary features found in general-purpose runtimes, focusing solely on what's required for secure execution.
- Granular Verification: By making containers "first-class citizens" of the Linux kernel, SEED enables granular verification at the container level. This means that individual containers, rather than just the entire OS image, can be attested and verified for integrity before and during their execution. This is a significant improvement over traditional TEEs where the TCB is a monolithic unit.
The proposed architecture features a configuration and attestation service running inside the TEE. The workflow for deploying a confidential microservice is as follows:
- A user (e.g., a platform engineer) encrypts and signs their container image on their local machine. This ensures that the container's contents are protected in transit and that its origin can be verified.
- The encrypted and signed container is then pushed to an encrypted container registry. This registry acts as a secure repository, maintaining the confidentiality of the container image at rest.
- At runtime, when the workload needs to be deployed, the encrypted container is fetched from the registry and deployed into SEED's TCB.
Crucially, SEED addresses the challenge of continuous trust in dynamic environments. Traditional TEEs often rely on an immutable TCB, meaning that once the TEE is attested, its internal components are not expected to change. This model struggles with dynamic container deployments. SEED overcomes this by enabling what the speaker calls a "push run prove" workflow.
By exporting containers as first-class citizens of the Linux kernel, SEED breaks the immutable TCB architecture. The integrated container runtime, being part of the kernel, can dynamically load and verify new container images at runtime. The attestation service continuously monitors and verifies the integrity of these newly deployed containers. This dynamic verification allows for a mutable TCB in practice, where new trusted components (containers) can be introduced and verified post-initial TEE launch without compromising the overall security guarantees.
The framework is designed to support OCI (Open Container Initiative) unmodified containers, meaning developers can use standard container images without needing to re-architect them specifically for SEED, enhancing usability and adoption. The team claims to have proven that their end-to-end protocol effectively defends against most attacks documented in the literature, demonstrating the robustness of their design.
Demo / Proof of Concept
▶ Watch: Core innovation: container runtime statically linked to kernel (7:10)
While the talk thoroughly details the architectural design and the proposed "push run prove" workflow, it does not describe a live demonstration of the SEED framework in action. Instead, the speaker mentions, "we were able to prove that our end protocol actually works against most of the attacks that are refined in the literature." This indicates that the validation of SEED's effectiveness was conducted through theoretical analysis and possibly experimental evaluation against known attack vectors, rather than a public, interactive demo during the conference session. The focus remained on the robust theoretical underpinnings and the architectural innovations that enable end-to-end verifiable confidentiality.
Defensive Implications
▶ Watch: Achieving continuous trust and granular container verification (7:50)
The SEED framework offers significant defensive implications for organizations deploying sensitive AI workloads, particularly large language models and other microservices, to cloud environments. Platform engineers and security architects can leverage these insights to build more resilient and trustworthy systems:
- Prioritize End-to-End Confidentiality and Integrity: Defenders must move beyond isolated security measures and strive for solutions that provide verifiable end-to-end protection. This means securing data not just at rest and in transit, but critically, also in use within the TEE, and ensuring the integrity of the entire software supply chain from container creation to runtime execution.
- Rethink OS Choices for Cloud TEEs: For highly sensitive workloads within TEEs, reconsider the use of general-purpose operating systems. Explore specialized, minimized OS or unikernel solutions like UKL that reduce the TCB and eliminate redundant features, thereby shrinking the attack surface. This architectural shift is crucial for maximizing the security benefits of hardware-backed TEEs.
- Implement Secure Container Deployment Workflows: Adopt secure practices for container management, including mandatory encryption and digital signing of container images at the source. Ensure that containers are stored in encrypted registries and only deployed after rigorous attestation and integrity verification at runtime, as exemplified by SEED's "push run prove" model.
- Leverage Granular, Runtime Verification: Defenders should seek out or implement solutions that allow for granular integrity verification of individual containers within the TEE, rather than just the initial OS image. This capability is vital for dynamic microservice architectures where new workloads are constantly being deployed and updated.
- Protect AI Model IP and User Privacy: For AI models, specifically protect sensitive components like weights and biases from unauthorized access, even by privileged cloud administrators. Simultaneously, guarantee users that their data, when processed by these AI models, remains confidential and cannot be accessed or tampered with by external parties. SEED's approach provides a robust mechanism to enforce these guarantees.
- Embrace Attestation and Continuous Trust: Integrate robust attestation mechanisms into deployment pipelines. Critically, adopt solutions that support continuous trust models, allowing for the secure and verifiable introduction of new workloads into an already running TEE, without compromising the established chain of trust. This moves away from the limitations of immutable TCBs in dynamic cloud environments.
By adopting the principles demonstrated by SEED, organizations can significantly enhance the security posture of their cloud-based AI deployments, building trust with users and protecting valuable intellectual property.
Key Takeaways
- End-to-End Protection is Paramount: Achieving comprehensive confidentiality and integrity for AI workloads in dynamic cloud environments requires more than isolated security components; it demands an end-to-end verifiable framework.
- Modern OS are Suboptimal for TEEs: General-purpose operating systems introduce unnecessary bloat and attack surface when deployed within Trusted Execution Environments, necessitating a shift towards minimized or specialized OS solutions.
- Direct Kernel Integration for TCB Minimization: Embedding container runtimes directly into a minimized Linux kernel (like UKL) within a TEE drastically reduces the Trusted Computing Base and enables more efficient, secure execution.
- Granular and Continuous Trust: SEED introduces a "push run prove" workflow that breaks the immutable TCB paradigm, allowing for dynamic, runtime deployment of OCI-compatible containers with granular, continuous integrity verification.
- Enhanced AI Security: This framework empowers platform engineers to protect sensitive AI model weights and biases, while also providing strong privacy guarantees for user data processed by large language models in the cloud.
About the Speaker(s)
The primary presenter for the SEED talk was Omar Jarkas, listed as a paper author from The University of Queensland. He articulated the challenges of confidential computing for AI in the cloud and presented the innovative SEED framework. The research and paper were a collaborative effort, with co-authors including Ryan Ko and Naipeng Dong, also affiliated with The University of Queensland, and MD Redowan Mahmud from Curtin University. Their collective work focuses on advancing secure data processing and confidential microservice deployments in complex cloud environments.
Reviews
Dr. Zero (Offensive Security Researcher) — SOLID
Strip away the obligatory 'AI and LLMs' grant-bait framing, and what you actually have here is a highly elegant systems engineering paper on TEE container attestation. Jarkas and the team tackled the immutable TCB problem by statically linking a custom runtime directly into a Red Hat unikernel. It’s heavy on academic proofs and light on live code, but the 'push-run-prove' architecture is exactly the kind of re-thinking cloud confidential computing desperately needs.
Heather Calloway (CISO) — SOLID
This research bridges the gap between hardware-backed cloud security and modern deployment agility, solving the friction of using Trusted Execution Environments (TEEs) for dynamic AI workloads. If you are hosting proprietary LLM weights or highly regulated customer data in public clouds, your architecture team needs to understand this model.
→ Top-rated talks at Privacy Enhancing Technologies Symposium (PETS) 2026
All talks from Privacy Enhancing Technologies Symposium (PETS) 2026