confidential processing: what your journal verifies, and what we're still working on

2026-11-18 · jer & extro · 10 min read

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.

the cover page of the whitepaper: confidential processing in solstone, how your journal checks the service before it sends. version 2.0, state as of 18 november 2026.

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:

later, with no date yet:

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.

a colour-coded grid comparing solstone with Apple Private Cloud Compute, Meta Private Processing, Tinfoil, Privatemode and a contract-only promise. rows where solstone says yes: client checks hardware evidence, session tied to the checked machine, second proof over the live session, client checks the GPU's evidence itself, nothing fetched during the check, client enforces a firmware minimum, no remote login in the image. open reproducible build: partial. prompt cache bounded or client-keyed: next. rows where solstone says planned: client enforces a public log, evidence tied to operator's machines, hides who is asking, independent audit published. the notes below give the specifics.

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.

  1. each of the five ties the session to a key named in the evidence.
  2. 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.
  3. 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.
  4. 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.
  5. Meta’s client also carries AMD’s revocation lists.
  6. 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.
  7. 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.
  8. 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.
  9. 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.
  10. 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.
  11. 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.
  12. 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.