Implement HATS
in Any Language.

Conformance Suite

The HATS Conformance Suite is the machine-testable proof of interoperability for HATS, the standard that records and monitors operational evidence. It is a frozen corpus of 26 canonical test vectors, each carrying its own input bundle, expected output, transcript hash, and replay-integrity classification, so any implementation in any language is conformant if — and only if — it reproduces the published outputs byte-for-byte. Unlike the Architecture (which describes the components) or the Guarantees (which define what a verdict means), the conformance suite is the executable test corpus that decides pass or fail.

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. The conformance suite makes that verification machine-testable.

• 26 canonical test vectors — covering graph verification, replay determinism, error handling, and edge cases
• Frozen format — vectors never change after publication; modifications require a new vector ID
• Cross-language parity — identical inputs produce identical outputs regardless of implementation language
• Independent verification — no H33 infrastructure required; verify with your own code against published expected outputs
• JSON-native — all vectors are portable JSON; no binary dependencies, no proprietary formats
• Deterministic failure — even rejection paths produce byte-identical error codes and severity classifications

Five Tiers of Conformance

HATS capability profiles define progressive levels of protocol support. Each tier includes all capabilities of the tiers below it. Implementations declare which profile they target.

All 26 Canonical Vectors

Every vector is a self-contained JSON file with input, expected output, and metadata. Grouped by verification domain.

How to Verify

Run the reference verifier against any HATS bundle. Three ways to get started.

Implement Your Own

The conformance suite is designed for independent reimplementation. No H33 SDK required. No proprietary runtime. Just JSON vectors and deterministic expected outputs.

Cross-Language Compatibility

Frozen Vector Policy

Published test vectors are permanent. This is a binding commitment to implementations that depend on deterministic expected outputs.

• Vectors are immutable after publication — once a vector ID is assigned and published, its input, expected output, and metadata never change
• New versions = new vector IDs — if a test case needs modification, a new vector ID is created; the original remains frozen
• Breaking changes = transcript version increment — any change to transcript derivation, field ordering, or hash computation triggers a full major version bump
• No silent updates — the conformance corpus is versioned and content-hashed; any mutation is detectable by independent verifiers
• Additive only within v1.x — new vectors may be added to the suite; existing vectors cannot be altered or removed

Why This Exists — And When Not To Reach For It

The conformance suite exists so that "HATS-compliant" is a testable fact, not a marketing claim. Because the vectors are frozen and content-hashed, two independent implementations can prove they agree without trusting each other or H33 — which is the whole point of an interoperability standard. H33 publishes it separately from the reference implementation so conformance is defined by outputs, not by anyone's code.

Use it when you are building or certifying a HATS implementation or an independent verifier and need an objective pass/fail signal.

Do not reach for it when you want to understand what the components are (that is the Architecture), what a passing verdict does and does not mean (that is Verification Guarantees), or the exact wire format (the Specification). Passing the vectors proves your implementation matches the reference outputs; it does not by itself assert anything about a specific deployed system's security posture.