Project H is a longitudinal behavioural inference engine with cryptographic audit properties. In plain terms: it watches something change over a long time, measures it rigorously, and can prove afterwards that the measurement was honest and unaltered. It is one of the cleaner architectures I have built, and almost every decision in it follows from a single inversion, so that is where to start.
Ross Jones, Founder, The Hopium Lab. Last modified 4 August 2026. The generalised pattern is written up as The Trustworthy Record, with the interactive architecture on that page.
The inversion: measure hard, surface nothing
Most measurement systems exist to show you a number. Project H is built to make showing a number structurally impossible, while still measuring rigorously underneath. Growth accumulates as internal weights, those weights drive a direction and a qualitative band, and then a mechanical wall strips every raw number out of every response before it leaves the server. A leaked number does not get caught in review, it fails the build.
Why go to that trouble? Because a surfaced number changes behaviour, and a system that merely promises not to show one will be asked to the moment it is convenient. Making it a wall rather than a rule is the same move as any guarantee worth having: you make the bad thing inexpressible, not forbidden.
A probabilistic core inside a deterministic shell
The system is deliberately two paradigms with a hard line between them. In front, language is messy, so the layer that turns input into signal is model-driven. Behind the line, everything that has to be reliable is pure computation over an immutable record. Nothing is allowed to cross in the wrong direction, an interpretation is never allowed to quietly become a score.
On the probabilistic side, the anti-hallucination discipline is decomposition. No mega-prompt scores forty metrics. A cheap detector finds the few dimensions present, then each gets its own narrow judge that fires only on a direct quote and is dropped below a confidence floor rather than recorded weakly. That is the whole of using an LLM as a judge without being lied to.
The shell is where the trust lives
Behind the line, state is a computation over an append-only log, never a mutable total. Replay every entry in order and live state reproduces byte-identically, which makes a correction a deterministic rebuild rather than a patch, with no correction amnesia. This is event sourcing pointed at an LLM system, and it is what makes the whole thing reproducible rather than merely consistent-looking.
Then the audit layer. Content hashes build into an RFC 6962 Merkle tree, so one 32-byte root proves the entire record and an inclusion proof shows a single entry belongs without revealing it. Change a byte and the proof breaks. It is tamper-evidence with no blockchain in sight, and the signed export uses a did:key so it verifies offline forever, with no server and no certificate authority to trust.
The part worth stealing
The engine knows no subject. It does not know what it is measuring. The entire methodology lives in a versioned, forkable pack, so changing the philosophy is a config change, not a code change, and the one thing a pack can never do is introduce a numeric or ranking surface, because a conformant engine rejects it. Fork the philosophy freely. You cannot fork away the guarantee.
That is the whole idea in one line: a rigorous measurement engine that is domain-agnostic, provable, and built so its most important promise is impossible to break. The full architecture is The Trustworthy Record.
Ross Jones, Founder, The Hopium Lab.