confidential processing: what your journal verifies, and what we're still working on
first, our primary goal is for you to be able to run everything locally, including the model that reads your words so it can organize your journal for you. while this is possible with most mainstream computers today, not everyone has a new enough computer to be able to run our small embedded model locally. so we also offer the same model in the cloud, through a service we call confidential processing.
we take the privacy of this confidential processing very seriously.
the goal is world-class confidential processing: protection for your privacy that is fully verifiable, so you can check it yourself and take nobody’s word for it, ours included. and it still has to do its job, which is taking heavy work off your machine efficiently.
today we’re publishing a security whitepaper that shows how far along we are: confidential processing in solstone: how your journal checks the service before it sends.
confidential processing is the optional, paid service for work your own machine is too small for. your journal sends one piece of work (the text, images or audio a model has to read) to the same model you would run locally, but we run it for you on confidential hardware in Microsoft Azure. the rest of your journal stays on your device.
what we’ve built so far
your journal does the whole check itself, on your device. before it sends a credential or any content, it asks our machine for signed hardware evidence and verifies it: AMD’s signature on the processor’s report, a fresh signed statement from the machine’s virtual TPM of what it booted, and the GPU’s own evidence against NVIDIA’s roots. it reads the processor’s firmware level from the chip’s own certificate and refuses anything below a minimum.
the values your journal compares against are compiled into the open source release you installed, so we can’t change what your journal accepts without visibly shipping everyone a new release. if any check fails, your journal sends nothing and doesn’t fall back to anything else.
the encrypted session is tied to the machine too, and we’re proud of how: the machine signs a second statement over a value both ends derive from the live TLS session, so your journal knows the session it holds ends inside the machine it just verified.
the machine boots one disk image, and we removed the ways to run commands on it: no SSH, no login and no agent the cloud can send commands to. there’s no way for us to log in. the image is built from a public recipe with every input pinned by its hash, and anyone can recompute the measurements our image determines from the boot file we publish. the model runs inside this image, with no third-party AI provider in the path.
and you can check our work. each statement in the paper that the design depends on points at a line of code at a fixed commit or a published record. where one rests only on our own testing, the paper says so, and section 11 sets out the limits.
the gaps we know about
we’re not there yet. these are the gaps we know about, and we’ll keep working until we’ve closed them all.
planned for the next image, and the journal release that goes with it:
- the model server keeps a prompt cache for each journal (saved state from recent prompts, which makes repeated work faster), and nothing clears it until it is pushed out or the machine restarts. we plan to tie it to one connection and release it when that connection closes.
- the model server also has a second cache, for pictures, that isn’t separated by journal (we read this in its source). it gets the same treatment, or gets turned off.
- your journal accepts three processor families where our machines use one. it will accept the one, and check more of the configuration the processor signs. the image will also turn on the kernel’s lockdown mode explicitly.
- the firmware minimum is the level our machines reported when the image was qualified, which may not be AMD’s newest. we plan to raise it when the next image’s machines report a higher level.
later, with no date yet:
- a public append-only log (it can be added to and never rewritten), held outside our control, that your journal checks before it sends. today every key that signs our public records sits inside one boundary we control.
- evidence that ties a machine to us. today nothing in the evidence says a machine is ours, or where it is.
- anonymity from us. today no outside relay hides your network address, and our services portal sees your credential on each connection.
- AMD’s list of revoked certificates. your journal doesn’t check it today. we plan to have the service keep a current copy of AMD’s signed list, which your journal verifies each time it connects.
- padding for streamed answers. today their sizes and timing show on the network.
- post-quantum key agreement, so traffic recorded today can’t be read later by someone with a large enough quantum computer.
needs people who aren’t us: an independent rebuild of the image, and an outside security audit of the design. neither has happened yet. we plan on both after we close the known gaps.
no single piece of this kind of design proves the whole. hardware evidence shows what a machine booted. the public recipe shows what that image is built to do, which is to write nothing you send to storage and to send it nowhere else. the values compiled into your journal, and the records we sign and publish, tie the two together. together they are evidence that the machine is running the build we published. none of them watches what that software does afterwards, so “nothing you send is kept” rests on the build.
an image is also fixed at build time. this week we put a new image into service. the one before it has two security flaws, one in the kernel and one in how the model server loads media. the new image fixes both (release notes). the old one keeps serving, with both, while journals update, and a current journal may be served by either.
how it compares
several large model providers offer “zero data retention” as an agreement: a promise not to keep your prompts, with nothing for your software to check. a smaller group runs the model on confidential hardware and lets the software on your side check evidence before it sends. we’re in that group: ahead on two rows, level on five, and not there yet on the rest.

in our column, next and planned both mean not built yet: next is planned for the next image, planned has no date. we can only speak to our own plans, so the other columns show what each service has published today. not found means we did not find it in what the service has published. it does not mean no. n/a means there is no check for the row to apply to.
- each of the five ties the session to a key named in the evidence.
- ours signs a second statement over a value both ends derive from the live TLS session. Meta makes one report per connection, which includes a random value from the TLS handshake. Apple, Tinfoil and Privatemode name a key in the evidence and stop there.
- your journal verifies the GPU’s evidence against NVIDIA’s roots on your device. Meta, Tinfoil and Privatemode verify the GPU inside the machine, and their clients rely on the processor’s evidence for that. Apple’s own-silicon nodes have no separate GPU evidence. for its Google Cloud nodes, which use NVIDIA GPUs, the device or an Apple node acting for it checks the GPU’s evidence.
- Apple’s device checks proofs that arrive with the evidence against a log state it downloads daily. Meta’s client carries what it needs. Tinfoil’s client fetches the measurements to accept on each connection, and Privatemode’s fetches a manifest.
- Meta’s client also carries AMD’s revocation lists.
- each of the other four has stated exceptions. Apple keeps a fixed diagnostics service reachable only from the node’s own management controller. Meta has an attested diagnostics service. Tinfoil has a debug mode that fails attestation. for Privatemode we found the platform’s rule against starting extra processes in a container, and no statement about the machine image itself.
- ours: the recipe, the hash of every input and the measurements are public, and our own two builds matched. nobody outside sol pbc has rebuilt it. Apple publishes binaries and source for a subset of components. Meta says it will release its artifacts to eligible researchers.
- ours is kept apart per journal by a label our services portal supplies. Apple: no state shared across requests, and per-owner caches are encrypted under keys the device supplies. Meta: persistent cache off. Tinfoil and Privatemode: keyed with a secret the client holds.
- Apple’s device sends only to software that appears in a public append-only log. Meta’s client checks against a signed log kept by an outside party, which Meta calls a simple log, not a Merkle-tree ledger. Tinfoil’s client verifies a Sigstore signature; we did not find that it checks the log entry. our records are signed, with no such log.
- Apple’s log records each machine’s identity and the device checks it. Privatemode’s client enforces a list of machines. Meta publishes its host identities, and we did not find a step where its client checks them.
- Apple and Meta use an outside relay, with unlinkable tokens (Apple) or anonymous credentials (Meta). Meta says some requests can go direct, which can show a network address.
- Meta has a public review by Trail of Bits, and one by NCC Group of a service built on it. Privatemode’s reports are available on request. Apple publishes an auditor’s report on its hardware certificate ceremonies only. Tinfoil has a SOC 2 report.
this is our reading of each service’s own documentation and the public audit reports, read on 18 november 2026. most are listed in the paper’s appendix e. we did not test any of them. the last column is a “zero data retention” agreement, granted on request and with stated exceptions.
tell us where it’s weak
if you work on confidential computing and think something in it is wrong or missing, write to security@solpbc.org. as each gap closes, the paper’s changelog will record it, with the image or journal release that carries the fix.
sol pbc is a public benefit corporation. the promises about your data live in article 8 of our filed articles of incorporation, not in a policy we could quietly change: it can’t be amended without jer’s personal signature, and after him the language can only get stronger, never weaker. what that means.
