Your apps. Your data. Your boundary.
Hardware isolation keeps the ordinary host OS out. Confidential hardware also protects against the machine’s operator.
Build a WebAssembly component once and it runs on every backend. The host's operating system is an implementation detail, never a rewrite.
Our proprietary CPU isolation keeps the host OS out of your app. Masked offload protects your data on GPUs outside the confidential boundary. How Shield works →
Check the chain from the silicon to your app's exact bytes before you connect, in your browser, from the CLI, or in an agent's tool call. Run it now →
Catalog, ledger and payments run on public contracts. Apps are content-addressed, the source is published for audit, and hosts are run by their owners. Designed to outlive any one company, ours included. What still runs on our servers, listed honestly →
Four ways in, one identity. No accounts, no approvals.
Pick an app, fund it, use it: a private model chat, an image generator, a game server, any tool you would not trust with your data anywhere else. Browse the store →
Ship a WebAssembly component to the catalog in a minute, set an hourly fee if you like, and get paid every time someone funds it. The developer guide →
Register a machine you own and get paid for every lease it serves. Your machine proves its protection when it attaches, so buyers never have to take your word for it. Host an enclave →
Everything a person can do here, an agent can do over REST and MCP: browse, deploy, fund, verify. No step assumes a human. The MCP server →
From zero to a live endpoint you have checked. Click a step to see what crosses the wire.
Both paths give every app its own hardware domain. They differ in who is kept out.
Works on any operating system, including CPUs without confidential-computing support.
Protects againstThe host operating system.Does not add protection from the machine’s owner.
Adds processor-backed memory protection against the machine’s operator.
Protects againstThe host OS and operator software.Physical attacks with lab equipment are outside this claim.
Each card is protected according to its own proven mode, whatever the CPU.
In a supported confidential-computing mode, the card runs inside the enclave.
Masked inputs. Checked results. No plaintext protected state. No work is routed to the card until Shield’s checks pass.
One standard on every operating system.
The full contractShield protects machines without confidential-computing hardware. Each app runs in its own domain, kept apart from the host OS by a smaller, measured trusted layer that the hardware's virtualization enforces. The app's identity is measured and its keys and traffic are bound to it. Checks fail closed, and a finished domain leaves nothing behind. Shield does not stop the machine's owner from inspecting data; only a confidential processor adds that. A Shield host is listed only after it passes the common acceptance tests.
Each app keeps its own domain, and the processor adds a boundary around the whole machine: memory is encrypted and integrity-protected against everything outside it, operator included. Before connecting, you check a report signed by the processor and chained to the silicon vendor.
A GPU in a supported confidential-computing mode runs inside the boundary. Any other GPU, even one beside a confidential processor, is used only through Shield's masked offload: the card sees masked inputs, its results are checked before use, and it never receives plaintext protected state. Admission reads proof of the card's own mode, never the CPU, the host, or a missing field. Until that proof checks out, the card is neither advertised nor routed.
Nothing here is called unable to see your data unless hardware enforces it and a signed report says so. A confidential processor defends memory against software, not against physical attacks with lab equipment, and a self-hosted seller has physical access to their own machine. A machine that meets only part of the contract is not listed, and ordinary virtualization with the host OS in charge is never built, listed, or sold. Which hosts are attached, and what each has proven, is on the live fleet panel and in the dated evidence note on the architecture page. The contract, property by property →
A chain of measurements that ends in your browser. Walk each link, then run the check yourself against a live host.
The CPU (AMD SEV-SNP on today's fleet) and the NVIDIA GPU hold keys fused at manufacture that Enclave can't extract or forge. The root of trust is the silicon vendor (AMD, NVIDIA, or Intel on a TDX host), not the operator.
On boot the AMD secure processor signs a report over the launch measurement, a SHA-384 digest of the firmware, the kernel, and the exact runtime image. Change one byte and it changes. Your app is deliberately not in it: the app arrives later by CID, and the runtime refuses any bytes that don't match the CID in your deployment record. (On Intel TDX: a DCAP quote over MRTD + RTMRs.)
With confidential computing on, the GPU signs an attestation report over your nonce, proving CC mode, driver, and vBIOS before any data reaches VRAM. Check it against NVIDIA's NRAS or nvtrust.
The enclave generates its TLS keypair in sealed memory and folds the public-key hash into the quote's report_data. The private key never leaves the boundary, so the operator can't sit in the middle.
Enclave's own open-source verifier (verifier/ in the repo, served from this site) checks it in your browser: it sends the box a fresh nonce, then verifies the signed report up to AMD's root, the firmware floor, the guest policy, the key binding to your nonce and the launch measurement. The API's own selfCheck is only a diagnostic; trust counts when YOUR client computes it. Try it live below.
Your browser checks a live host's hardware attestation itself, with Enclave's open-source verifier.
The page draws a fresh nonce. The relay carries it to the host and brings the host's evidence back untouched, and the verifier (served from this site, hash-pinned) checks it against hardware roots built into it: AMD's for SEV-SNP, Google's for phone pVMs, the TPM maker's for Enclave Shield, where the page also mints the TPM credential itself. The relay can delay a check but cannot fake one. Expected builds come from the operator's list, so a pass reads "genuine and fresh", not "independently reproduced". From a terminal: enclave attest --expect <measurement>.
Hosts set their own rates. Pick the hardware and protection your app needs and see the price before you pay.
Metered by the second.The share of the host your app uses.
Add accelerator resources when you need them.
Included in the quoted rate for paid apps.
Based on the host, resources, and app you choose.
Compare available hosts, hardware, and protection.
Allocate resources to match your app’s requirements.
Start with a small top-up. Add more time as you go.
Rates come from the host. Your rate is your CPU and GPU shares at that host’s posted rates, plus any publisher fee, which goes to the app’s publisher. You see it before you fund.
Payments buy runtime. Prepaid time is metered by the second. Unused time stays on the deployment’s public record so you can stop and resume later, and cancelling returns the unspent part held for the host; the rest of a payment is final. Fund in small top-ups.
Resources follow your app. Each app sets minimum allocations, and GPU work needs an available GPU host. Shares are software-enforced allocations; they do not by themselves create hardware isolation. What does →
Rates round up. Per-second rates are rounded up to whole millionths of a dollar.
View the billing contractEnclave is designed so you never have to take the operator's word for anything. You should still know whose word you are not taking: Enclave Host, Inc.
The company that builds and operates Enclave. Payments to it settle on a public record, and its enclaves prove what they run before you send them a byte.
Steven is a certified application architect focused on serverless architecture, with an enterprise consulting background and a passion for decentralized systems. He builds Enclave hands-on, from the attested enclave stack and settlement contracts to the site you are reading. Based in Arizona.