Verify it yourself

Don't take our word for it. Verify the chain 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.

Download vloex-audit-sample.zip

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

Verify the sample in your browser

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

verifying…
  1. key provenance

    The log key signed the device-key registry.

    …
  2. checkpoint signatures

    The log key signed the day's Merkle root.

    …
  3. chain continuity

    Every event the checkpoint counts is in the bundle.

    …
  4. event signatures

    Each event hash verifies against its device key.

    …
  5. Merkle inclusion

    Each event re-hashes into the signed root.

    …
#eventsignatureinclusion
    Change one character

    payload_hash: the hash of the event, which the device signed.

    What this proves

    • A device key in the signed registry signed each event's hash.
    • Each event re-hashes to the leaf its day's signed root commits to.
    • Nothing was removed from inside the sealed day.

    What it does not

    • What the prompt said: the bundle carries hashes, never text.
    • Who was at the keyboard: a signature binds a key, not a person.
    • When the checkpoint was signed. Only a copy kept outside Vloex dates it.

    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

    Prove it, then break it

    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.

    1

    Unzip and verify — it should pass

    bash
    $ 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.

    2

    Change one byte — it must fail

    bash
    # 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

    Run it against your own bundle

    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.

    Version
    vloex-verify 3.1 (bundle format v2)
    URL
    https://vloex.com/verify/vloex-verify.py
    Size
    71,569 bytes
    SHA-256
    216bdc79b36873927ff00299e25da84725005ffc80d5295329b8b55a694f5404
    bash
    $ 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:

    bash
    $ curl -fsSO https://vloex.com/verify/SHA256SUMS
    $ shasum -a 256 -c --ignore-missing SHA256SUMS
    Published downloads and their SHA-256
    FileBytesSHA-256
    vloex-verify.py71,569216bdc79b36873927ff00299e25da84725005ffc80d5295329b8b55a694f5404
    vloex-audit-sample.zip93,64295c9a84bae0500e5a6e8a59987a3c7dbfe069403dd10dfe11428f19de14fbd27
    vloex-audit-sample-tampered.zip93,6422186507dd702aabce377de26c66054e9d75f1b422c5f9d945c59f92f8cf6e87a
    jwks.json266a5e71b2f43509713ee9be932480bc2b095459016ed6353122de9af793ce08350

    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

    The trust anchors live outside the bundle

    Keys are resolved from a public JWKS; roots are signed checkpoints you can archive yourself. Every bundle's trust.json says where both live.

    The public key set (JWKS)

    public JWKS — the log key set
    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.

    A signed checkpoint is ~8 lines of text

    checkpoints.txt — this bundle's signed note, verbatim

    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.

    The auditor path: two commands, keys from the public URL

    bash
    $ 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.

    Archive it yourself: the witness kit

    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.

    witness/vloex-witness.yml — ships in every bundle

    What just happened

    Why this can't be faked

    1. 1

      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.

    2. 2

      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.

    3. 3

      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.

    4. 4

      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

    Both surfaces, one signed chain

    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.

    Proof beats promises.

    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.