A signing service often holds the highest-value key in your architecture while sharing a host with logging agents, web routers, and orchestration daemons that never need that key. The same pattern shows up when an AI agent system brokers credentials or evaluates sensitive policy rules alongside untrusted tool outputs. Protecting that critical component comes down to one architectural question: how much software sits inside your trusted computing base (TCB)?
Every operating system service, runtime dependency, and administrative account inside the boundary expands what you have to audit and defend. When you move a sensitive function into a smaller, hardware-isolated environment, you can reduce the amount of surrounding application software and administrative access included in the TCB for that workload's memory-confidentiality protections.
Azure confidential computing is designed to help protect data in use by processing workloads inside hardware-backed trusted execution environments (TEEs). Today, we are sharing upcoming engineering investments planned for future releases to help shrink the workload TCB across three connected layers: the next generation of Confidential Child Capable VMs, confidential enclaves for application-scoped isolation, and support for these next-generation VMs in confidential containers on Azure Kubernetes Service (AKS).
Next-generation Confidential Child Capable VMs
Confidential VMs give an entire virtual machine a hardware-isolated boundary. Many architectures, however, benefit from drawing a tighter box inside the VM itself. We are building the next generation of Confidential Child Capable VMs to serve as the compute foundation for these minimal-TCB designs.
In this architecture, a customer-operated parent VM hosts one or more hardware-isolated confidential child VMs. Each child environment runs inside its own memory boundary backed by AMD Secure Encrypted Virtualization-Secure Nested Paging (SEV-SNP). AMD SEV-SNP helps protect the child environment's memory and helps keep the parent operating system and parent-level administrators outside the child's memory confidentiality boundary within AMD's documented threat model. Meanwhile, the parent VM continues to manage lifecycle operations, CPU scheduling, I/O, and workload availability.
Isolation establishes the boundary, and attestation proves what runs inside it. Before a secret enters a child environment, the processor generates a cryptographic report measuring the child's initial boot state and security configuration. Your relying party or key management service evaluates that attestation evidence against an authorization policy before releasing sensitive material directly to the attested child recipient. If the measured image does not match the measurements authorized by policy, key release is denied. Your application still needs to validate inputs and protect communication across the parent-to-child channel, since the parent controls network and storage I/O.
Isolating critical code with confidential enclaves
Most application teams want smaller trust boundaries without writing custom virtual machine monitors or assembling guest kernels from scratch. To meet that need, we are building confidential enclaves as a feature of our upcoming Confidential Child Capable VMs.
With confidential enclaves, you split out the component that handles raw secrets, such as a transaction signer, cryptographic key broker, or policy verifier, while leaving the rest of your application in the parent VM. You package that sensitive component into a measured enclave artifact, launch it from a supported Azure Linux parent VM, and pass requests to it over a local communication channel.
Because the enclave runs only the minimal guest environment and your isolated application component, without requiring hardware-specific enclave SDKs, the software footprint you must trust and measure stays small. Combined with hardware attestation and policy-gated key release through services such as Azure Attestation and Azure Key Vault, confidential enclaves let key owners bind secrets to approved workload measurements before the enclave processes requests.
Pod-level isolation for confidential containers on AKS
Kubernetes platform teams face a similar boundary choice when running multi-service or multi-tenant clusters. Today, confidential AKS worker nodes let you run standard Linux pods inside a VM-level confidential computing boundary. Workloads scheduled onto that worker node share the node's protection boundary, which fits clusters where pods and node administrators belong to the same trust domain.
When individual pods handle sensitive keys or regulated data that must stay isolated from the worker node host and cluster operators, the boundary has to move from the node to the pod. The AKS team is building support for our next-generation Confidential Child Capable VMs in confidential containers on AKS.
Built on Kata Containers and the open-source Confidential Containers project, confidential containers on AKS run an opted-in pod inside its own hardware-isolated confidential child guest. An in-guest security policy defines which container images, environment variables, and management commands the pod guest accepts. That combination gives platform engineers familiar Kubernetes deployment workflows while helping reduce the workload TCB to the individual pod guest and its declared policy.
Designing for a smaller TCB
Shrinking your TCB starts with how you partition your software. Teams planning for these capabilities can prepare their architectures around three boundaries:
- Separate secret-bearing code from general application logic. Isolating signing, decryption, or credential-brokering paths behind a narrow request-response interface makes those components straightforward to move into confidential enclaves or dedicated confidential pods.
- Treat measurement and secret release as distinct gates. Plan who owns the key-release policy and which exact workload measurements authorize secret delivery.
- Design for an untrusted transport path. Because the parent VM or host node manages I/O and scheduling, authenticate messages crossing the boundary and build clean retry handling for interrupted calls.
Because all three options build on the same hardware virtualization foundation, you can match the boundary to how you operate: use confidential containers on AKS for Kubernetes pod workflows, confidential enclaves when splitting a secret-bearing component out of a single Linux VM, or Confidential Child Capable VMs directly when you need full control over child guest orchestration and packaging.
Next-generation Confidential Child Capable VMs, confidential enclaves, and Confidential Child Capable VM support for confidential containers on AKS are under active development and planned for a future release. Capabilities described in this post remain subject to change, and availability, timelines, regions, and supported configurations might vary as engineering and launch milestones complete.
If you are evaluating minimal-TCB designs on Azure, share your workload and trust-boundary requirements through our workload interest form to connect with the engineering team on architecture feedback and early testing consideration across confidential enclaves, confidential containers on AKS, or direct Confidential Child Capable VMs. Information submitted through the form is processed in accordance with the Microsoft Privacy Statement. To learn how you can protect sensitive workloads on Azure today, read the Azure confidential computing documentation.