Verify it yourself
Download a real, signed Vloex audit bundle and re-derive the chain offline with the verifier we ship inside it. Keys are resolved from a public JWKS; roots are signed checkpoints you can archive yourself. Signed events from both surfaces — the coding-agent gateway and the browser extension — form one Merkle chain an auditor can rebuild without an account and without trusting us. Change a single byte and the proof breaks.
Real export · 12 signed events across the coding-agent gateway AND the browser extension · single-file verifier, nothing to install
Or verify it here, in your browser ↓Try it here
Five checks run on this page. Nothing is uploaded. Then change one character and see which check fails, and at which event.
vloex-audit-sample · 12 events · 2026-06-24
SAMPLE DATA · THROWAWAY KEYS WITH PUBLIC SEEDS
key provenance
The log key signed the device-key registry.
checkpoint signatures
The log key signed the day's Merkle root.
chain continuity
Every event the checkpoint counts is in the bundle.
event signatures
Each event hash verifies against its device key.
Merkle inclusion
Each event re-hashes into the signed root.
What this proves
What it does not
The keys are throwaway and their seeds are public, so anyone can re-sign this sample. It shows the checks work; it proves nothing about a real deployment. The key set here comes from this site, the same place as the bundle. For a real bundle, fetch the JWKS its trust.json names and run the CLI.
Run it yourself
The verifier is one auditable Python file that uses only the standard library (python3, 3.9 or later — the one macOS ships works). Read it before you run it if you like — it's in the zip as vloex-verify.py.
$ unzip vloex-audit-sample.zip -d vloex-sample $ cd vloex-sample $ python3 vloex-verify.py . --jwks jwks.json $ echo $? 0
That output is the real report from the committed bundle, not marketing copy: the checkpoint's Ed25519 signature verifies against the key set, the device-key manifest (keys.jws) verifies against the log key, all 12 per-event device signatures verify offline, and every leaf walks its Merkle proof to the signed root. Exit 0 means full independent verification.
# flip one hex digit of the payload_hash on line 9 of events.jsonl, then: $ python3 vloex-verify.py . --jwks jwks.json FAIL(device_sig): event d4f70c53-b3f1-4192-8d9a-68cd2a7f70f3 v2 device signature does not verify (mismatch) [event 9 of 12, events.jsonl line 9] FAIL(leaf): leaf re-derivation MISMATCH for event d4f70c53-b3f1-4192-8d9a-68cd2a7f70f3 — payload_hash / key_id / signature bytes were altered [event 9 of 12, events.jsonl line 9] RESULT: FAIL — event signatures, Merkle inclusion (2 of 5 checks; tags: device_sig, leaf) FIRST FAILURE: event 9 of 12 (events.jsonl line 9, event_id d4f70c53-b3f1-4192-8d9a-68cd2a7f70f3) — Merkle inclusion, event signatures $ echo $? 1
Three different links in the chain, three distinct failure modes: alter a payload_hash in events.jsonl → FAIL(leaf); change one character inside keys.jws → FAIL(manifest_sig); edit a root line in checkpoints.txt → FAIL(checkpoint_sig); delete an event, or relabel one out of the proof → FAIL(omission). The verifier names the broken link and the first failing event, and exits non-zero. Or skip the editing: vloex-audit-sample-tampered.zip is this bundle with that one byte already flipped.
Download the verifier
Every export carries vloex-verify.py, and you can also download it on its own, check its hash, and point it at a bundle you exported yourself.
$ curl -fsSO https://vloex.com/verify/vloex-verify.py $ shasum -a 256 vloex-verify.py 216bdc79b36873927ff00299e25da84725005ffc80d5295329b8b55a694f5404 vloex-verify.py # it must match the SHA-256 above, character for character $ python3 vloex-verify.py --version vloex-verify 3.1 $ python3 vloex-verify.py your-bundle.zip --jwks <jwks_url from the bundle's trust.json>
On Linux, sha256sum vloex-verify.py prints the same hash. To check every download on this page at once, fetch the checksum list into the folder that holds them:
$ curl -fsSO https://vloex.com/verify/SHA256SUMS $ shasum -a 256 -c --ignore-missing SHA256SUMS
| File | Bytes | SHA-256 |
|---|---|---|
| vloex-verify.py | 71,569 | 216bdc79b36873927ff00299e25da84725005ffc80d5295329b8b55a694f5404 |
| vloex-audit-sample.zip | 93,642 | 95c9a84bae0500e5a6e8a59987a3c7dbfe069403dd10dfe11428f19de14fbd27 |
| vloex-audit-sample-tampered.zip | 93,642 | 2186507dd702aabce377de26c66054e9d75f1b422c5f9d945c59f92f8cf6e87a |
| jwks.json | 266 | a5e71b2f43509713ee9be932480bc2b095459016ed6353122de9af793ce08350 |
What a matching hash proves, and what it does not. It proves the file on your disk is the file this site serves, byte for byte: nothing changed it on the way or after. It does not prove who wrote it. The hash and the file come from the same place, so anyone able to change one could change the other. Provenance that does not depend on this site, such as signed release attestations, is not published yet. Until it is, the strongest check is the one this page keeps suggesting: the verifier is one readable file, so read it. A bundle exported by a deployment running this release carries a byte-identical copy, so its hash will match the one above.
Trust anchors
Keys are resolved from a public JWKS; roots are signed checkpoints you can archive yourself. Every bundle's trust.json says where both live.
https://vloex.com/verify/jwks.json
The deployment's log key signs every checkpoint and the device-key manifest. Once published, a key is never removed from the JWKS, so old checkpoints keep verifying forever. This demo bundle is signed with throwaway sample keys derived from public seeds — it proves the checks work, not anything about a real deployment — so its key set ships in-bundle (jwks.json) — a customer bundle's trust.json points at the live public URL instead.
Origin, day + sequence, the Merkle root, the previous root (prev chains days together), the leaf count, and a keys line that pins the exact device-key manifest — then an Ed25519 signature over the verbatim body. Anyone holding a copy of this note can later prove the history it commits to was never rewritten.
$ curl -fsS https://vloex.com/verify/jwks.json -o jwks.json $ python vloex-verify.py vloex-audit-sample.zip --jwks https://vloex.com/verify/jwks.json
On a customer bundle, the verifying key material comes from the public JWKS URL in its trust.json — not from the bundle, not from a dashboard session. Add --checkpoint-cross-check to byte-compare the bundle's checkpoints against the live public log.
Honest limit: a log-key signature proves a checkpoint came from this deployment — it does not prove history was never re-signed. What prevents rewrite is checkpoint copies outside Vloex's reach: your S3 Object-Lock bucket, any archived copy of the public checkpoint URL, and this witness kit — a ~20-line GitHub Action you commit to your own repository. Daily, it fetches your public checkpoint, verifies the note signature against the pinned JWKS, and commits it. One honestly-archived checkpoint transitively pins all prior history and the key registry.
What just happened
Each event becomes a signed leaf hash.
The device signs the event's payload hash with a private key that never leaves it. The bundle ships the hash, the key id, and the signature — not the prompt text. The verifier checks the device signature against the signed key manifest and re-hashes those fields into the exact leaf the backend recorded.
Leaves fold into one Merkle root.
Every leaf for the day is combined pairwise (RFC 6962) into a single root. The bundle includes each event's sibling path, so the verifier walks any leaf up to the root on its own.
The root is published as a signed checkpoint.
The deployment's log key signs a plain-text checkpoint note over the root, the previous root, and a hash pinning the device-key registry. The verifying keys resolve from a public JWKS — the backend holds only public device keys, so it cannot forge a device signature.
Copies you keep make it rewrite-proof.
A log-key signature proves origin, not that history was never re-signed. Rewrite protection comes from checkpoint copies outside Vloex's reach — your Object-Lock bucket, an archived public URL, a witness repo. One archived checkpoint pins everything before it.
What's in the bundle
Gateway — in the signed chain
9 events
Coding-agent gateway events — Claude Code and Cursor calling MCP tools, some blocked at the choke point. Signed per-event at the proxy with Ed25519, folded into the Merkle root.
Browser — in the signed chain
3 events
Browser AI sessions (ChatGPT, Claude.ai, Gemini). Signed in the Chrome MV3 service worker with ECDSA-P256 — the same canonicalize contract as the gateway — and verified + anchored into the same Merkle root.
What we do NOT claim. Not “every event, everywhere, is signed.” Device-signing is live on the coding-agent gateway. The browser extension in the stores does not sign yet (this sample’s browser events come from a development build), and the backend verifies + anchors signed events from either the same way — but shadow-AI / OAuth-discovery events from workspace connectors are captured and governed without device signatures, and an unenrolled or WebCrypto-less browser degrades gracefully to unsigned. The verifier transparently skips any such row (there are none in this sample). Events the backend captures itself, with no device involved (the Anthropic Compliance API connector), are SERVER-ATTESTED: signed by the deployment’s own attestation key and sealed in the same root, and the verifier counts them separately — that proves the record is unchanged since it was sealed, not what any device did, and the key belongs to the party being audited. Events recorded before signature v2 are labeled v1 legacy: signature-verified at ingest, but NOT independently verifiable offline — the verifier says so instead of pretending. And the bundle ships only hashes of each event, never the prompt or response text — contents are encrypted at rest, so the chain proves integrity over the hash, not the text; binding a hash to the original text is only possible for a party holding the original content (e.g. your SIEM export). No SOC 2 claim here; this page is about one thing: math you can re-run yourself.
This is the record your auditor gets to keep — verifiable without us in the room. See how the gateway blocks a leak before it happens.