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 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.
Download the canonical test vectors. Run the reference verifier. Build your own implementation. The protocol is the proof.