IT-RAT the stack/trailryx Live demo Stack Guides Console
the record · Rust

Trailryx. A record of what your agents did that nobody can quietly change, or quietly shorten.

Trailryx answers with a completeness proof when it can, and says partial with the reason named when it cannot. And its store is built to erase one person on request without breaking the trail; the shipped node does not expose that yet.

coreRust · no unsafe · 0 third-party
tests1,227 across 31 crates
ingestOTLP protobuf · JSON · a collector's file
provesrecord · time · agent · run · type
erasurecrypto-erasure, per subject
installbinaries · ghcr.io image · latest
licenceApache-2.0

Where this sits today, stated rather than implied. Trailryx reads the shared agent-event bus and seals it. It still takes plain OTLP as well, from a collector or straight over the wire, so it stays useful to somebody who has traces and no TAIPANBOX.

two questions, two kinds of answer

The auditor asks. One answer carries a proof, the other admits it cannot.

A question lands on one of the five dimensions the index can prove, and the matching records are a contiguous range: that contiguity is the mechanism, not a picture of it. The second question is about something nothing sorts by, so the rows are still right and the answer says so.

under the hood

SQL does not become a hole in the proof model.

SQL is a facade in the tree and not yet a port in the shipped node: today you read the records through read. What every answer carries, either way, is how much of it is actually proved, because an answer of unknown completeness must not read like a proved one.

SELECT * FROM records WHERE run_id = 'run-b' SELECT * FROM records WHERE severity = 'error' INSERT INTO records VALUES (...) the classifier does every predicate land on a dimension the index can prove? it knows nothing about the engine no async runtime, session or planner the part that decides whether an answer is provable must be testable without it Provability::Full an authenticated index range: these are all of them Provability::Partial(reasons) the rows are right, just not proved complete refused, and nothing is planned the gate reads it first; the engine never sees it the five it can prove anything else is honest, not proved record_id recorded_at_nanos agent_id run_id event_type
the pair that is hard to have at once

Erase one person in the library, and the trail still verifies.

Trailryx separates the two planes so neither has to give way.

Typed metadata, encrypted payload

The plane the proofs are built on holds identifiers, enums, hashes, numbers and timestamps, and nothing else. Any prose lives in the encrypted payload under the subject's own key.

The record commits to the payload it no longer has

Forgetting drops the key. The record keeps its hash, size, class and key id, so what it committed to is still checkable and the chain around it is untouched.

measured, not asserted

The number that makes the other number mean something.

A durability sweep reporting zero violations proves nothing on its own: a check that cannot fail reports zero forever. So the same harness is run against a disk that lies about its writes, and it is required to fail.

With a disk that keeps its word

As recorded, undated, in the repository's VALIDATION.md: 400,000 seeds, roughly 800 million shard ticks, about 12 million crashes injected. Zero durability violations.

With a disk that lies

The same harness, the honest-disk assumption removed (as recorded, undated, in VALIDATION.md): 17,869 of 20,000 seeds fail, each naming its own seed and digest. That is what makes the zero above worth reading.

check it yourself

The offline verifier.

trailryx-verify incident-4471.trxevid zero third-party dependencies, because an auditor reads it rather than trusting it
what it is sealing lately

The newest thing on the bus is a crew of agents.

CostCrew writes twenty-three event types about money and about its own analysts. This plane seals the two about money with everything else and refuses the other twenty-one by name, because they record a practice rather than an agent's run.

limits

What is not proven yet.

  • The console has no panel for the record plane, so what is sealed is read with the CLI rather than in a browser.
  • Erasure is a library and the demo path today: trailryx-node has no erase command and keeps no payload plane, so an operator cannot yet erase one subject through the shipped binary.
  • A pack from stack-single carries no root signature and no witness, so the verdict proves the chain was not altered, not who published it or when. Since 2026-10-19 stack-up signs each sealed root through Keyryx by default and attaches the witness's attestations, and stack-k8s has done the same since 2026-10-20. Neither witness is an outside party: stack-up's runs on the same host as the same user, and stack-k8s's runs in the same cluster, as its own user in the record plane's group. trailryx-verify does not warn about that. None of this has run live.