HATS is an open governance and replay protocol for independently verifiable operational evidence. Any system. Any verifier. Deterministic outputs. Forever.
HATS-PROFILE-PQ-SHA3-256-v1
HATS is the open governance-and-replay standard that records and monitors independently verifiable operational evidence over time. This Standards hub is the entry point to the HATS family: the Architecture (its components), the Specification (its exact wire format), the Conformance Suite (its pass/fail test vectors), the Verification Guarantees (what a passing verdict does and does not mean), and the .h33bundle portable evidence format. Unlike a product page, these are the normative technical documents; every attestation they describe anchors to the H33-74 post-quantum primitive.
HATS is a publicly available technical conformance standard for continuous AI trustworthiness; certification under HATS provides independently verifiable evidence that a system satisfies the standard's defined controls.
HATS treats governance not as documentation but as a deterministic system with defined inputs, reproducible outputs, and machine-testable conformance.
| Layer | Function | Property |
|---|---|---|
| Governance Graph | Structured representation of policies, controls, and authority bindings | deterministic |
| Replay Engine | Reconstructs verification state from governance graph and evidence bundle | reproducible |
| Rejection Semantics | Stable error codes, severity classification, requirement references | frozen |
| Transcript Binding | Canonical encoding and hash derivation for all verification artifacts | immutable |
| PQ Attestation | Post-quantum signatures over governance state and verification outputs | quantum-resistant |
Governance reconstruction does not require trust in the original signing authority. The verification bundle is the evidence. The replayer is the judge.
HATS conformance is a test result, not a marketing claim. Canonical vectors define byte-identical expected outputs for every verification path.
$ hats-verify conformance --vectors ./hats-v1.0.0/ --profile PQ-SHA3-256
PASS 26/26 canonical vectors
PASS transcript derivation
PASS rejection semantics (all 26 error codes)
PASS replay integrity classification
PASS domain separator consistency
Profile: HATS-PROFILE-PQ-SHA3-256-v1
Result: CONFORMANT
| Implementation | Language | Vectors | Status |
|---|---|---|---|
| H33 Reference | Rust | 26/26 | Conformant |
| Your implementation | — | — | Register |
The HATS standard is defined across six documents. Each addresses a distinct verification concern.
Non-conformant governance does not silently degrade. It fails with stable error codes, severity classification, requirement traceability, and replay integrity grading.
{
"error": "HATS_ERR_POLICY_EXPIRED",
"severity": "critical",
"requirement": "REQ-1.3",
"replay_integrity": "deterministic",
"rejection_class": "policy_violation",
"deterministic": true
}
HATS is defined by its specification and canonical vectors, not by any single codebase. Third-party implementations can validate protocol equivalence without trusting H33 infrastructure.
Contact standard@h33.ai to register your implementation for conformance certification.
The H33 reference implementation is pure Rust. The cryptographic hot path does not depend on JavaScript or browser runtimes. Proving, verification, transcript construction, field arithmetic, and challenge derivation execute without any scripting layer.
Portable JSON test vectors allow independent verifiers in Go, TypeScript, Python, Java, or Rust to reproduce identical outputs. The verification path is fully deterministic and backed by canonical conformance vectors for third-party reimplementation.
HATS exists because operational trust is usually asserted, not proven. By defining governance as deterministic, replayable, post-quantum-signed evidence with a frozen verification surface, HATS lets any independent party reach the same verdict without trusting the operator. That is the whole point of publishing it as an open standard with canonical vectors rather than a proprietary product feature.
Use it when operational evidence must be independently verifiable and replayable by someone who does not trust the producer — continuous control verification, claim evidence, or regulated governance records.
Do not read HATS as a legal compliance certification or a guarantee about a system's correctness, availability, privacy, or completeness — those boundaries are stated precisely on the Verification Guarantees page. For the product framing see HATS; this hub links the normative technical documents.
An open governance-and-replay standard for independently verifiable operational evidence. It records and monitors evidence over time with deterministic replay, frozen verification semantics, and post-quantum signed attestations, so any party can build a conformant verifier without trusting H33 infrastructure.
The Architecture (components), the Specification (wire format), the Conformance Suite (test vectors), the Verification Guarantees (what a verdict means), and the .h33bundle portable evidence format. Every attestation anchors to the H33-74 primitive.
When operational evidence must be independently verifiable and replayable by a party who does not trust the operator — continuous control verification, claim evidence, or regulated governance records. It is a technical standard, not a legal compliance certification.
HATS attests the integrity of the record, not the correctness of the decision, availability of the system, privacy of the data, completeness of what was recorded, or compliance with any regulation. Those boundaries are stated precisely on the Verification Guarantees page.
Yes. HATS is defined by its specification and canonical test vectors, not by any single codebase. Independent verifiers in Go, TypeScript, Python, Java, or Rust can reproduce identical outputs, and conformance is decided by reproducing the frozen vectors byte-for-byte.
Download the canonical test vectors. Run the reference verifier. Build your own implementation. The protocol is the proof.