Research / Explainers
Confidential computing · 10 minute read

What is confidential compute on non-confidential silicon?

A practical guide to private computation, controlled answers and the boundary an infrastructure operator cannot cross.

A protected core surrounded by ordinary compute infrastructure
Protected information and controlled answers

An AI agent needs to check whether a purchase is allowed. Somewhere inside the business are the account records, supplier terms and purchasing constraints needed to answer.

Giving the agent those records would help it answer the question. It would also put private information into a context that could appear in logs, persist in agent memory or travel to another service through a tool call.

What the agent needs is a decision. A narrowly defined tool can evaluate the purchase and return the permitted answer without returning the records behind it. The more interesting question is whether an outside operator can perform that calculation without reading those records either.

For supported calculations, cryptographic computation provides a route. SCSA combines that route with controls over which operations can run and which results may be disclosed.

The short version
  • 01The worker receives ciphertext or protocol-defined shares, not unrestricted source records.
  • 02Authority decides which calculation and disclosure are permitted.
  • 03Custody controls the capability needed to recover protected information.
  • 04The exact guarantee depends on the admitted protocol and its assumptions.

What the hardware does not have to know

Conventional encryption protects data in transit and at rest. An application normally decrypts that data to work on it, and a sufficiently privileged operator may then be able to inspect application memory.

Hardware-backed confidential computing protects execution inside a trusted execution environment, or TEE. The hardware supplies a boundary against specified threats from the surrounding infrastructure. The industry definition of confidential computing centres on these hardware-based environments.

Cryptographic computation uses a different boundary. Workers operate on encrypted values or shares under a defined protocol. Their administrators may inspect memory and control the operating system; the protocol must account for that access.

An ordinary GPU does not become a hardware enclave. Whether it can participate safely depends on what it receives, the calculation it performs and the protocol's assumptions. There is no promise that arbitrary software gains confidentiality simply by running through a new wrapper.

Make the boundary visible

The operator controls the box. That still does not give it the customer's view.

Take root control of an ordinary worker. Inspect its hardware, job, memory and keys; then run the protected calculation and see which boundary can reveal the answer.

Confidential compute session
Representative terminal replay · no live customer data
Worker
Ordinary L40S GPU
Customer key
Held locally
Operator plaintext
0 bytes
customer@trusted-boundary
In control
$ scsa protect purchase.json --profile cc-demo
inputs encrypted locally
customer key retained locally
$ scsa submit --operation purchase-check/v1
job: cc-7f31
worker input: ct_f91c…7bd2
root@ordinary-worker
$ connected to worker-7f31 · uid=0(root)
operator controls OS, process memory and network
job cc-7f31 waiting

Take control of the ordinary worker and try to recover the private values.

Customer capability isolated

Three ways to arrange the work

Homomorphic encryption lets a worker perform supported calculations on ciphertext. The customer protects its inputs before sending them out, and the worker uses public evaluation material without receiving the secret decryption key. The result remains encrypted until a party with the required capability recovers it.

This is useful for outsourcing work over private inputs. It does not automatically protect a proprietary model as well. A public scoring function over encrypted customer features is a different requirement from keeping both the features and model secret.

Multiparty computation allows participants to calculate together while limiting what each learns. Privacy depends on the selected protocol's corruption threshold: how many parties can collude or behave maliciously before the guarantee fails. Administrative independence matters; three cloud accounts controlled by one recovery administrator may amount to one compromise domain.

A hybrid design can use trusted hardware for some stages and ordinary workers for protected computation. The boundary needs careful checking. Attesting a CPU does not protect plaintext subsequently sent to an ordinary GPU, and an HSM that stores a key does not automatically protect every application that uses it.

Comparison of homomorphic encryption, multiparty computation and hybrid protected execution routes
Homomorphic encryption, MPC and hybrid execution place trust in different parts of the system. Each route needs its own security assumptions.

Execution is separate from permission

SCSA separates three responsibilities. Execution performs the calculation. Authority decides which operations and disclosures are permitted. Custody controls the cryptographic material needed to recover protected information.

These responsibilities answer different questions. A worker's ability to finish a job should not give it permission to choose the recipient. An agent's permission to request a purchase check should not give it an unrestricted decryption key.

For customer-private execution, the customer can hold the decryption capability. Governed disclosure needs a different arrangement when the input owner and output recipient are different organisations. Custodians then contribute to releasing a particular authorised result under a specified threshold protocol. Enough compromised custodians can defeat that boundary, so the threshold and control relationships belong in the threat model.

The distinction becomes practical when a service has to refuse a request. A recipient that already possesses the ciphertext and complete decryption capability cannot be prevented from decrypting it merely by telling an API to say no.

Following the purchase request

The agent submits purchase parameters to a confidential tool endpoint. The protected data source supplies the private features needed by an approved calculation, preparing them inside the data owner's trusted environment.

The operation fixes the calculation, its numerical behaviour and the permitted output. It also binds the intended recipient and applicable policy. If the selected execution route cannot satisfy those requirements, the request is refused.

  1. 01

    Request

    Bind the operation, recipient and allowance.

  2. 02

    Protect

    Prepare the private inputs inside the owner boundary.

  3. 03

    Compute

    Run the admitted protected calculation.

  4. 04

    Verify

    Check the required computation evidence and current authority.

  5. 05

    Release

    Return only the permitted result to the named recipient.

Ordinary workers produce a protected answer and the required evidence. The recipient obtains the permitted result without acquiring general access to the underlying records. The language model can reason about that answer alongside other approved context; it need not ingest the private account records.

There is a simpler option worth considering first: the company could host an ordinary API that performs the check itself. Protected outsourcing becomes useful when substantial computation must run elsewhere, another organisation owns the model, or several parties contribute information they cannot share directly.

An encrypted answer can still be wrong

A malicious worker can return garbage without ever learning the input. Encryption alone does not establish correct execution. Unsafe decryption feedback can also expose secrets in some homomorphic-encryption constructions, so handling malicious results is part of the confidentiality design.

The verification mechanism must address a defined relationship between the protected inputs, approved calculation and returned output. A signed worker response establishes who signed it. A code digest identifies some bytes. Neither alone proves that the requested calculation produced the answer.

Even correct execution has limits. It can faithfully apply a poor model to inaccurate source data. Numerical approximations need separate quality checks, and the business remains responsible for deciding whether the calculation is suitable.

Disclosure also needs care. A purchase decision reveals information by design. Repeated questions can reveal more: an agent changing the requested amount until the answer flips may learn something about a hidden constraint. Query limits and output restrictions therefore form part of the endpoint's security contract.

What customers should measure

Cryptography costs computation and communication. Ciphertexts can expand substantially. MPC may require repeated exchanges between participants, making network latency important. Nonlinear operations can be expensive or require an approved reformulation.

A useful benchmark follows the complete operation through input protection, computation, verification and authorised release. It includes customer-side services, participating workers and failed attempts. Measuring a fast worker kernel while excluding verification will not tell a customer what the service costs.

The comparison also needs equivalent output quality. A small protected scoring calculation cannot stand in for arbitrary encrypted language-model inference.

Control after failure and disclosure

Workers fail. If a replacement receives only the required protected state, it need not receive decryption authority. Recovery must still preserve job identity and prevent stale results from being accepted.

Authority has its own durable state. Restarting an agent must not restore an allowance it already spent or forget a purchase whose outcome is uncertain. Custody recovery must be explicit too: loss of the necessary recovery material can mean permanent loss of access.

Revocation controls future authorised use. It cannot make a recipient forget an answer, erase every copied key or reverse an external transaction.

For the purchase workflow, the benefit is specific: the agent gets its decision without receiving the source records, while eligible external infrastructure performs the protected work.

Sources and further reading
  1. [1] Confidential Computing Consortium. Common Terminology for Confidential Computing.
  2. [2] Viand, Knabenhans and Hithnawi. Verifiable Fully Homomorphic Encryption.
Go deeper

Read the full architecture and security boundaries paper.

The technical paper covers execution profiles, authority and custody, correctness, recovery, mixed fleets, leakage and measurement boundaries.

Open technical paper