Caution is backed by Y Combinator. Learn more.

All posts

Sovereign compute needs verifiability

An engineer compares a three-part design with the matching structure inside a monumental computer, beside two controls connected to its pink-lit core.

TL;DR Compute sovereignty requires control over infrastructure, software, data, and the authority to change them. Caution contributes independent verification: connect reviewed source code to a running enclave, keep sensitive requests encrypted into that enclave, and require a quorum to release application secrets. These controls strengthen sovereignty within the infrastructure you choose.

  1. Sovereignty includes the software
  2. Connect approved source to running software
  3. Make access depend on verification
  4. Apply the same reasoning to sovereign AI
  5. Make verification portable across infrastructure
  6. Build sovereignty people can verify

Imagine a public institution moving a sensitive service into a data centre it owns. It chooses the location, buys the servers, and hires the people who operate them. The source code is available for inspection. On paper, it controls the system.

Now ask who can change the software that handles the data.

If one administrator can replace the application, or one compromised build server can insert code that nobody reviewed, owning the hardware has left a consequential gap. The institution controls the premises, but still depends on someone else’s assurance about what happens inside the machine.

That gap belongs in the discussion about sovereign compute.

Sovereignty includes the software

Compute sovereignty means having meaningful authority over the systems you depend on: where they run, who operates them, what they do with your data, and which dependencies you accept. That matters to a country, a company, or an individual.

Physical ownership and local operation provide important forms of control. So do access to source code, the ability to build and modify it, and the ability to continue operating without a particular vendor. Each addresses a different dependency.

But those choices need to survive deployment. Reviewing an application does little for your control if production can silently run something else. Holding an encryption key does little if an administrator can change the software that receives the decrypted data, or the software that releases the key.

Sovereignty should include the ability to establish what is running and decide whether to entrust it with anything sensitive. That decision should rest on evidence you can check independently.

Connect approved source to running software

Caution starts from that premise. All of our software is fully open source under OSI-approved licences. Inspired by our cypherpunk roots, we designed our software stack from the bottom up to support sovereignty: people should be able to inspect, build, verify, modify, and operate the systems they depend on.

It helps to separate two properties. Confidential computing protects data while it is being processed: hardware isolation keeps the host, its administrators, and the infrastructure provider out of the workload’s memory. But confidentiality alone says nothing about which software is handling the data. You are protected from the operator, yet you still take the operator’s word for what runs inside the enclave.

Verifiable compute keeps every guarantee of confidential computing and adds integrity and transparency for the software itself. Anyone can check that the running enclave was built from specific, reviewed source code, and that nothing else was substituted along the way. Confidential computing hides the data from the operator; verifiable compute also proves which code handles it.

Caution is a verifiable confidential compute platform that puts those principles into practice. It combines hardware isolation, attestation, and reproducible builds in a deployment workflow teams can use without assembling their own enclave infrastructure.

A secure enclave isolates an application from the surrounding host. Hardware-based enclave technologies prevent processes on the host, including those with administrator privileges, from accessing enclave memory. That protects a workload from an important class of operator access.

Remote attestation supplies signed evidence of the enclave’s measured image. But a measurement alone does not tell you which source code produced it. If the operator hands you both a binary and its expected hash, you are still trusting the operator’s build.

Reproducible builds let another party build the same image independently from the same source and inputs. Comparing that result with fresh attestation connects the reviewed source to the deployed enclave. On Caution, caution verify performs that verification workflow.

The build tools matter too. An opaque compiler or base image leaves dependencies you cannot inspect simply by publishing the application. Our work on StageX extends reproducibility and source bootstrapping into the tools and operating system beneath it.

The result is evidence that the intended image is deployed. Reviewing whether that software deserves access to your data remains a separate, necessary task.

Make access depend on verification

Verification becomes much more useful when the result governs access.

Consider a service processing confidential records. Transport encryption must terminate inside the enclave, with the client verifying that the connection reaches the approved workload. If encryption ends at a host-controlled proxy, the host can read the request before it reaches the protected application. Keeping the decryption keys inside the enclave means the host relays ciphertext.

We also provide STEVE, an open-source transport encryption library with a hybrid post-quantum key exchange option, for applications that need an encrypted session bound to enclave attestation.

The application processes plaintext inside the enclave. Its code still determines whether it logs, retains, or forwards that data. Isolation protects the application from the host; reviewing and verifying the application establishes which rules it follows.

Application secrets can follow the same principle. Caution’s key services support quorum-based release of the shares needed to unlock them. Independent custodians can verify a deployment before releasing their shares to it. A replacement image needs approval before it receives enough shares to operate with those secrets.

For sensitive deployments, the custody design matters as much as the threshold. Holders can approve share releases with passkeys or retain their own external PGP keys. A quorum can combine both methods, with a threshold that requires external holders to participate where needed. Updates, credential recovery, and emergency procedures must preserve the same division of authority.

This gives an institution a concrete form of control: its designated participants decide which verified software receives its secrets. Operating a server does not, by itself, confer that authority.

Apply the same reasoning to sovereign AI

Consider a European financial institution that wants an internal AI assistant to process confidential reports. It wants control over the deployment location, the model, access to the reports, and the credentials the assistant can use.

Those requirements extend beyond selecting a local hosting provider. The institution needs to verify the safeguards governing access to its reports and whether prompts or documents can leave the approved processing path.

A verifiable deployment can support either of two approaches. When the inference software and model weights are open, the institution can review the software, reproduce the enclave image, and verify the model weights against an approved hash. If the weights are loaded after startup, the verified application must enforce that hash. The reviewed configuration can also fix the system prompt and restrict external calls.

When the model or inference software is private, the institution can instead verify the safeguards around it. As we explain in Running proprietary software on confidential data, an open, verifiable confinement layer can restrict a private program’s access to data and its communication paths. The customer verifies that layer, while the vendor supplies its private program and model through an encrypted connection into the enclave. This keeps the implementation private while giving the customer evidence of the restrictions protecting its data. The private model’s internal behavior remains outside that verification.

An AI agent introduces another question: what authority does it have? If it can retrieve private documents or initiate payments, the code enforcing those permissions needs the same scrutiny as the inference service. Quorum-controlled release can govern the credentials that give it that authority.

We have already demonstrated the verification workflow with a CPU-based LLM deployment. Large GPU inference requires additional hardware support and an assessment of the full protected execution path. A verified gateway calling an ordinary external model API does not extend enclave protection to that provider.

The opportunity is to give institutions and their users evidence about the AI service they rely on. That can mean verifying the full application or the safeguards around a private implementation. Neither establishes that a model’s answers are correct.

Make verification portable across infrastructure

We are designing Caution to support bring your own compute, fully managed hosting, and bare-metal deployments across all major clouds and into any data centre. The goal is to let organisations choose infrastructure that meets their requirements while retaining a consistent way to deploy and independently verify their workloads.

Different organisations need different levels of operational control. One may want a managed service. Another may need workloads in its own cloud account. A public institution may require infrastructure in a data centre it controls. The verification workflow should be available in each setting, with the hardware and attestation support appropriate to that environment.

Open-source software gives those organisations the ability to inspect, modify, and operate the platform themselves. Portability should extend that independence to infrastructure choices, so changing a provider does not mean abandoning the verification and approval controls built around an application.

That design still requires explicit decisions about dependencies. Each deployment has hardware, firmware, attestation, and availability assumptions. Organisations should be able to evaluate those assumptions and choose which providers and technologies they rely on. The platform’s job is to make that choice practical and its security properties independently checkable.

A sovereignty assessment therefore needs to examine the whole system: processing, storage, backups, logs, key custody, network services, and recovery. Protecting one enclave is useful, but the other components can still introduce dependencies or expose data.

Build sovereignty people can verify

The practical starting point is one sensitive workflow. Follow the data and authority through it. Identify who can read the data, change the software, release its keys, or stop the service. Then decide which powers should require independent verification or shared approval.

That exercise applies whether the infrastructure belongs to a government, a business, or a hosting provider. It makes the meaning of control concrete.

We are building Caution so that deploying sensitive software also gives the people relying on it a way to verify it. Infrastructure ownership, open software, independent builds, protected execution, and shared control can reinforce each other. Together, they let an organisation exercise authority over what its systems actually do.

If you are building sovereign compute infrastructure or a service that needs these controls, talk to us. We want to make independent verification part of how that infrastructure works.