Typed receipt contracts, external operational services, product and composite
systems, and filing gated work are separated so nothing is counted twice and no total drifts. Anchors are
permanent: a partner page can link straight to /canon/#sigr-chain and land on that card.
Typed receipt contract, 55 entries
What it provesAFiR-S3 agentic receipt. Attests that a segment_id, a caller declared lifecycle stage, and a caller held storage-reference digest were recorded and signed at recorded_at.
What it does not proveIt does not attest that the referenced tool scope, action, or reward attribution actually executed as declared; that determination remains with whatever system originated the underlying agent trajectory.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['afir.s3']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeafir.s3
Mint route/mint/afir-s3
Open verify route/verify/afir-s3 no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedcanon_anchor_fixed is pinned to True
Example requestPOST https://thehiveryiq.com/v1/mint/afir-s3
curl -sS -X POST https://thehiveryiq.com/v1/mint/afir-s3 -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"segment_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>", "lifecycle_stage": "<see schema>"}'
{
"segment_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>",
"lifecycle_stage": "<see schema>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.565 msmint p50
4.893 msmint p95
1.788 msverify p50
2.15 msverify p95
200iterations
991artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesagent tool scopeaction before executioncontext mutationreward attributionagent memory edit
Buyer fit illustrations, not customersFireworksOpenRouterCiscoPostmanSnowflake
What it provesAFiR-Stream receipt. Attests that a stream_session_id and a caller held audio segment digest were recorded and signed at recorded_at, using Ed25519 today.
What it does not proveIt does not attest that post quantum signing covers this stream; pq_enabled is fixed to false because this deployment signs with Ed25519, not a post quantum algorithm, and that must never be caller overridable.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['afir.stream']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeafir.stream
Mint route/mint/afir-stream
Open verify route/verify/afir-stream no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedpq_enabled is pinned to Falsealgorithm_in_use is pinned to Ed25519
Example requestPOST https://thehiveryiq.com/v1/mint/afir-stream
curl -sS -X POST https://thehiveryiq.com/v1/mint/afir-stream -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"stream_session_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"}'
{
"stream_session_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.447 msmint p50
2.873 msmint p95
1.815 msverify p50
3.226 msverify p95
200iterations
991artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesvoice receiptstreaming session anchorcall centerHIPAA voicereal time audio
Buyer fit illustrations, not customersCartesiaFish AudioCerebrasCisco
What it provesThis receipt attests that the recorded contribution set in signed_body, applied in the stated order when assembly_policy.order_matters is true, recomputes to the committed Merkle root or equivalent commitment and to final_output_sha256, and, when assembly_policy.expected_contributors is present, that the contribution set contains exactly that set of contributors with no omission, duplication, or unexpected contributor.
What it does not proveIt does not attest that any individual contribution is correct, that any named provider or model actually performed the work claimed, or that the final output is fit for any purpose.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['assembly.receipt']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeassembly.receipt
Mint route/mint/assembly
Open verify route/verify/assembly no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/proof-instruments.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/assembly
curl -sS -X POST https://thehiveryiq.com/v1/verify/assembly -H 'content-type: application/json' -d @canon/examples/assembly-receipt-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.567 msmint p50
5.13 msmint p95
1.825 msverify p50
2.18 msverify p95
200iterations
2315artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesmulti provider inferencemodel mixturecontext assemblyretrieval assemblyrouter transparency
Buyer fit illustrations, not customersOpenRouterFireworksCerebrasSnowflake
What it provesThis receipt attests that this delegation link's scope, constraints, validity window, and depth do not exceed what its named parent link grants, and that its own issuer signed it inside its own validity window.
What it does not proveIt does not attest that any action later taken under this authority was itself proper. Chain verification checks revocation only against revocation_snapshot.revoked_delegation_ids as recorded on the links actually supplied in the chain; it does not attest that those snapshots are current at the time a chain is checked, and it cannot see a revocation issued after the snapshot's checked_at or a revocation recorded only in a registry the caller did not supply as part of the chain.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['authority.delegation']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeauthority.delegation
Mint route/mint/delegation-link
Open verify route/verify/delegation-link no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/proof-instruments.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/delegation-link
curl -sS -X POST https://thehiveryiq.com/v1/verify/delegation-link -H 'content-type: application/json' -d @canon/examples/delegated-authority-v1.example.child.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.451 msmint p50
2.741 msmint p95
3.87 msverify p50
4.422 msverify p95
200iterations
1585artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesagent authorizationscoped delegationspend limittool permissionchain of authorityERC-1271erc1271Circle Gatewaysmart walletsmart contract authorizationunified USDC balance
Buyer fit illustrations, not customersCircleCiscoSnowflakeChimeRobinhood
What it provesBonded Performance Attestation binds a performance budget declared before the measurement window to a distribution measured inside that window and to a signed response binding for the measured response set or observation manifest. It is evidence suitable for a parametric threshold.
What it does not proveIt does not create or confirm insurance coverage, does not establish that any claim is payable, and does not attest that the output was correct.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['perf.attestation']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeperf.attestation
Mint route/mint/bpa/attestation
Open verify route/verify/perf-attestation no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/typed-receipts.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/bpa/attestation
curl -sS -X POST https://thehiveryiq.com/v1/verify/perf-attestation -H 'content-type: application/json' -d @canon/examples/perf-attestation-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
6.355 msmint p50
9.134 msmint p95
1.931 msverify p50
2.3 msverify p95
200iterations
1684artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesSLA measurementlatency proofperformance bondregression gatedeployment verification
Buyer fit illustrations, not customersHarnessCerebrasFireworksCiscoCloudflareAIUC
What it provesThis receipt records a performance budget declared before its measurement window opens.
What it does not proveIt does not assert that the budget was met, does not create or confirm insurance coverage, and does not attest that any output was correct.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['perf.budget']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeperf.budget
Mint route/mint/bpa/budget
Open verify route/verify/perf-budget no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/typed-receipts.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/bpa/budget
curl -sS -X POST https://thehiveryiq.com/v1/verify/perf-budget -H 'content-type: application/json' -d @canon/examples/perf-budget-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.432 msmint p50
2.803 msmint p95
1.849 msverify p50
3.714 msverify p95
200iterations
1020artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use caseslatency budgetSLA declarationcapacity commitmentinference performanceCI performance gate
Buyer fit illustrations, not customersHarnessCerebrasFireworksCiscoCloudflare
What it provesThis receipt attests that a named sequence of receipts forms a digest continuous chain from one origin receipt to one terminus receipt with no unreceipted gap between them, that each step's declared input digest equals the prior step's declared output digest, that the recorded times do not run backwards, and that the continuity finding was recomputed by this service rather than supplied by the caller. Digest continuity is not causation.
What it does not proveThis receipt does not attest that the origin caused the terminus, that the terminus caused the claimed effect, that the claimed effect occurred at all, or that any harm was suffered by anyone, and this service never receives the description of the claimed effect. It does not attest that the chain presented is the only chain, that no parallel or intervening cause existed outside it, or that the steps chosen are the ones a court, regulator, or investigator would consider relevant. It establishes no legal liability and is not an expert opinion on causation.
Implementation state, from registry data
Implemented, unit tested, smoke tested and documented in this repository, but the manifest does not report it as deployed. Never describe it as live.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['causal.path']: deployed false, production_ready_for_canon false, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typecausal.path
Mint route/mint/causal/path
Open verify route/verify/causal-path no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/causal-path.test.mjs
Example requestPOST http://localhost:3000/mint/causal/path
curl -sS -X POST http://localhost:3000/verify/causal-path -H 'content-type: application/json' -d '{"receipt": <a receipt of this type>}'
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, none shown
No benchmark is shown for this entry because none was measured against a verified deployment.
Use casesdigest continuous receipt pathincident evidence linkagereceipt sequence review
Buyer fit illustrations, not customersRisk teamsInvestigatorsEnterprise AI teams
What it provesDisclosure-Free Replay typed facade receipt. Attests that a replay_id, a source_receipt_ref, and a disclosed field allowlist were recorded and signed at recorded_at, and that fields_outside_allowlist_leaked recomputes exactly from a caller supplied leaked_field_count.
What it does not proveIt does not itself inspect the replayed payload; a caller must independently diff the replayed fields against disclosed_field_allowlist and report the count truthfully, this receipt only records and signs that count.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['replay.disclosurefree']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typereplay.disclosurefree
Mint route/mint/replay-disclosurefree
Open verify route/verify/replay-disclosurefree no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedfields_outside_allowlist_leaked is pinned to boolean
Example requestPOST https://thehiveryiq.com/v1/mint/replay-disclosurefree
curl -sS -X POST https://thehiveryiq.com/v1/mint/replay-disclosurefree -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"replay_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>", "source_receipt_ref": "<see schema>", "disclosed_field_allowlist": "<see schema>", "leaked_field_count": "<see schema>"}'
{
"replay_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>",
"source_receipt_ref": "<see schema>",
"disclosed_field_allowlist": "<see schema>",
"leaked_field_count": "<see schema>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.442 msmint p50
2.763 msmint p95
1.754 msverify p50
3.372 msverify p95
200iterations
1227artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesreplay without exposurefield allowlistPHI protectionprivileged content auditregulator replay
Buyer fit illustrations, not customersCiscoSnowflakeChimeAIUC
What it provesDiurnal Bond receipt. Attests that a regime_id and a caller held evidence digest were recorded and signed at recorded_at, and that the crypto envelope itself is live.
What it does not proveIt does not attest that any on-call or paging system actually escalated an attestation threshold; oncall_paging_integration is fixed to pending_design_partner because no such integration exists in this repository.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['usap.diurnal']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeusap.diurnal
Mint route/mint/usap-diurnal
Open verify route/verify/usap-diurnal no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedcrypto_core_status is pinned to liveoncall_paging_integration is pinned to pending_design_partner
Example requestPOST https://thehiveryiq.com/v1/mint/usap-diurnal
curl -sS -X POST https://thehiveryiq.com/v1/mint/usap-diurnal -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"regime_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"}'
{
"regime_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.48 msmint p50
4.972 msmint p95
1.808 msverify p50
2.164 msverify p95
200iterations
1025artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesafter hours escalationthin oversight windowon call proofweekend risk
Buyer fit illustrations, not customersCiscoHarnessChimeKalshi
What it provesThis receipt attests that the closure named in signed_body closes the named authorization under the stated idempotency_key with the stated status, opened_at, and closed_at.
What it does not proveIt does not attest that the evidence digests it names are themselves accurate, and it does not attest that the underlying effect was fit for any purpose.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['effect.closure']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeeffect.closure
Mint route/mint/effect-closure
Open verify route/verify/effect-closure no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/proof-instruments.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/effect-closure
curl -sS -X POST https://thehiveryiq.com/v1/verify/effect-closure -H 'content-type: application/json' -d @canon/examples/effect-closure-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.414 msmint p50
2.762 msmint p95
1.766 msverify p50
3.472 msverify p95
200iterations
1154artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesaction completionpayment settlementtool call closurerobot task closureagentic commerceCircle GatewayGateway attestationcrosschain USDCERC-1271erc1271unified USDC balance
Buyer fit illustrations, not customersCircleFanDuelKalshiRobot.comKodiak RoboticsCisco
What it provesEgress Bond receipt. Attests that an egress_manifest_id and a caller held evidence digest were recorded and signed at recorded_at, and that the crypto envelope itself is live.
What it does not proveIt does not attest that any semantic classifier or egress gateway actually measured or bounded the declared volume or semantic class; semantic_classifier_integration is fixed to not_proven because no such classifier or gateway exists in this repository.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['usap.egress']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeusap.egress
Mint route/mint/usap-egress
Open verify route/verify/usap-egress no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedcrypto_core_status is pinned to livesemantic_classifier_integration is pinned to not_proven
Example requestPOST https://thehiveryiq.com/v1/mint/usap-egress
curl -sS -X POST https://thehiveryiq.com/v1/mint/usap-egress -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"egress_manifest_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"}'
{
"egress_manifest_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.387 msmint p50
2.787 msmint p95
1.804 msverify p50
2.254 msverify p95
200iterations
1084artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesdata loss preventionegress budgetsemantic class controlPII boundarywarehouse export
Buyer fit illustrations, not customersCiscoSnowflakeCloudflareAIUC
What it provesThis receipt attests that a named evaluation administration arrangement was recorded alongside one specific evaluation attestation, that the test set digest was committed at or before the point the subject was told what the test set contained and at or before the evaluation window opened, and that the independence class was recomputed by this service from the declared relationship and separation of duties rather than supplied by the caller. The declared relationship, the declared separation of duties, and the identity of the administrator are recorded as asserted and are not independently verified here.
What it does not proveThis receipt does not contain, restate, or attest to any evaluation score or result. It does not attest that the test set was appropriate, that its items were representative, that the subject did not obtain the items by another route, that the evaluation method was adequate, or that the administrator was competent. It is not an accreditation, a certification, or an audit opinion, and no standards body, regulator, or insurer currently recognises it as one.
Implementation state, from registry data
Implemented, unit tested, smoke tested and documented in this repository, but the manifest does not report it as deployed. Never describe it as live.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['eval.administration']: deployed false, production_ready_for_canon false, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeeval.administration
Mint route/mint/eval/administration
Open verify route/verify/eval-administration no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/eval-administration.test.mjs
Example requestPOST http://localhost:3000/mint/eval/administration
curl -sS -X POST http://localhost:3000/verify/eval-administration -H 'content-type: application/json' -d '{"receipt": <a receipt of this type>}'
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, none shown
No benchmark is shown for this entry because none was measured against a verified deployment.
Use casesevaluation administration recordseparation of duties recordevaluation receipt linkage
Buyer fit illustrations, not customersAI service providersEnterprise evaluation teams
What it provesThis receipt attests to the integrity of the evaluation record in signed_body.
What it does not proveIt does not attest that the evaluated system is correct, that the evaluation method is adequate, or that any certificate or accreditation is valid. A contamination_check status of passed records that the declared check ran and returned clean, and is not proof that the dataset is free of contamination.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['eval.attestation']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeeval.attestation
Mint route/mint/evar
Open verify route/verify/evar no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/typed-receipts.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/evar
curl -sS -X POST https://thehiveryiq.com/v1/verify/evar -H 'content-type: application/json' -d @canon/examples/evar-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.492 msmint p50
2.815 msmint p95
1.852 msverify p50
2.67 msverify p95
200iterations
1691artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesmodel evaluationbenchmark integrityeval reportingcontamination checkmodel release gate
Buyer fit illustrations, not customersCerebrasFireworksOpenRouterSnowflakeAIUCMercorSurgemicro1
What it provesForensic Rail receipt. Attests that a credential_id and a caller held evidence digest were recorded and signed at recorded_at, and that the crypto envelope itself is live.
What it does not proveIt does not attest that any ISAC style consortium actually issued the credential, or that a deterministic inference stack actually produced the analysis; isac_consortium_integration and deterministic_inference_stack are fixed to not_proven because no such consortium or stack exists in this repository.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['usap.forensic']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeusap.forensic
Mint route/mint/usap-forensic
Open verify route/verify/usap-forensic no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedcrypto_core_status is pinned to liveisac_consortium_integration is pinned to not_provendeterministic_inference_stack is pinned to not_proven
Example requestPOST https://thehiveryiq.com/v1/mint/usap-forensic
curl -sS -X POST https://thehiveryiq.com/v1/mint/usap-forensic -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"credential_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"}'
{
"credential_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.441 msmint p50
2.785 msmint p95
1.796 msverify p50
3.288 msverify p95
200iterations
1164artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesincident responseconsortium accessreplay under credentialsecurity investigation
Buyer fit illustrations, not customersCiscoCloudflareAIUCSnowflake
What it provesThis receipt attests that pre_commitment was fixed at committed_at, before or at first_content_at, and that chain.final_chain_sha256 and chain.emitted_unit_count, when present, were computed by the signer at mint time from the caller's ordered per-unit digest evidence, folded onto pre_commitment.chain_init_sha256 under the declared algorithm, never accepted as caller-declared values, sealed at termination.sealed_at under the declared termination.kind.
What it does not proveIt does not read, judge, or attest to the quality of the streamed content, it does not require a trusted execution environment, and it cannot be produced after the fact against content that already existed, because the pre_commitment necessarily predates the content it covers. This receipt alone does not let an independent verifier replay the fold, because the per-unit evidence is never stored in it; a party later given the same ordered per-unit digest list by the producer's own records can independently recompute the fold against chain.evidence_sha256 and chain.final_chain_sha256, and a truncated, extended, edited, or reordered unit list will not reproduce either value. A run with a pre_commitment and no terminal attestation is not silent by design; the absence itself indicates the stream never reached a sealed ending.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['stream.attestation']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typestream.attestation
Mint route/mint/stream-attestation
Open verify route/verify/stream-attestation no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/proof-instruments-2.test.mjs test/deployment.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/stream-attestation
curl -sS -X POST https://thehiveryiq.com/v1/verify/stream-attestation -H 'content-type: application/json' -d @canon/examples/stream-attestation-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.617 msmint p50
5.182 msmint p95
1.839 msverify p50
2.111 msverify p95
200iterations
2496artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesstreaming inferencetoken stream proofvoice streamlive transcriptionreal time inference
Buyer fit illustrations, not customersCerebrasFireworksCartesiaFish AudioCisco
What it provesHiveBound Envelope typed facade receipt. Attests that a binding_id, a bound_entity_ref, and a caller held binding-policy evidence digest were recorded and signed at recorded_at, and that binding_conformant recomputes exactly from a caller supplied policy_digest_match flag.
What it does not proveIt does not itself re-implement HiveBound pre-commitment envelope validation; the original hivebound envelope schema and its own POST /verify route remain the authority for that shape, this typed contract is a canonical-registry facade over the same binding concept for the unified typed-receipts API.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['hivebound.envelope']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Source disagreement on recordcanon-46-independent-review.md finding 1.2 reports that GET /schema/hivebound.envelope is intercepted by a legacy handler and returns the older HiveBound pre commitment envelope schema instead of this contract's schema. Read the schema from the published .well-known URL, not from that route, until the collision is resolved.
Canonical typehivebound.envelope
Mint route/mint/hivebound-envelope
Open verify route/verify/hivebound-envelope no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedbinding_conformant is pinned to boolean
Example requestPOST https://thehiveryiq.com/v1/mint/hivebound-envelope
curl -sS -X POST https://thehiveryiq.com/v1/mint/hivebound-envelope -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"binding_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>", "bound_entity_ref": "<see schema>", "policy_digest_match": "<see schema>"}'
{
"binding_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>",
"bound_entity_ref": "<see schema>",
"policy_digest_match": "<see schema>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.374 msmint p50
2.751 msmint p95
1.722 msverify p50
3.004 msverify p95
200iterations
1241artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesinput pre commitmentdeclared intentbonded capitalsigned envelope before inferenceERC-1271erc1271Circle Gatewaysmart walletcrosschain USDCunified USDC balance
Buyer fit illustrations, not customersFireworksOpenRouterCircleCisco
What it provesHiveSeal Quantum Physically Unclonable Function receipt. Attests that a puf_challenge_id and a caller held challenge-response digest were recorded and signed at recorded_at.
What it does not proveIt does not attest that any physical hardware root of trust exists; qrng_source_kind and puf_source_kind are fixed to simulated because this deployment holds no physical PUF or quantum random number generator, and that must never silently become hardware.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['hiveseal.qpuf']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typehiveseal.qpuf
Mint route/mint/hiveseal-qpuf
Open verify route/verify/hiveseal-qpuf no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedqrng_source_kind is pinned to simulatedpuf_source_kind is pinned to simulated
Example requestPOST https://thehiveryiq.com/v1/mint/hiveseal-qpuf
curl -sS -X POST https://thehiveryiq.com/v1/mint/hiveseal-qpuf -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"puf_challenge_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"}'
{
"puf_challenge_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.42 msmint p50
2.799 msmint p95
1.756 msverify p50
3.293 msverify p95
200iterations
1070artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use caseshardware root of trustdevice signingPUFQRNGoffline signing device
Buyer fit illustrations, not customersCiscoKodiak RoboticsRobot.comICE
What it provesHowler receipt. Attests that a probe_id and a caller held evidence digest were recorded and signed at recorded_at, and that the crypto envelope itself is live.
What it does not proveIt does not attest that a sparse autoencoder probe was actually wired into a live reasoning loop, or that any drift, capability, or contamination signal was actually detected; sae_wired_to_live_reasoning_loop is fixed to false because no design partner run exists yet.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['usap.howler']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeusap.howler
Mint route/mint/usap-howler
Open verify route/verify/usap-howler no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedcrypto_core_status is pinned to livesae_wired_to_live_reasoning_loop is pinned to False
Example requestPOST https://thehiveryiq.com/v1/mint/usap-howler
curl -sS -X POST https://thehiveryiq.com/v1/mint/usap-howler -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"probe_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"}'
{
"probe_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.38 msmint p50
4.824 msmint p95
1.726 msverify p50
2.05 msverify p95
200iterations
1057artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesdrift probecapability probecontamination signalsparse autoencoder
Buyer fit illustrations, not customersAIUCCerebrasFireworksCisco
What it provesHive Verifiable Voting System receipt. Attests that a ballot_id, an election_ref, and a caller held vote-commitment digest were recorded and signed at recorded_at.
What it does not proveIt does not attest that any operational voting or election-verification system exists; system_operational is fixed to false because no such system is built or deployed, and no election authority endorsement is claimed.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['voting.verifiable']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typevoting.verifiable
Mint route/mint/voting-verifiable
Open verify route/verify/voting-verifiable no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedsystem_operational is pinned to False
Example requestPOST https://thehiveryiq.com/v1/mint/voting-verifiable
curl -sS -X POST https://thehiveryiq.com/v1/mint/voting-verifiable -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"ballot_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>", "election_ref": "<see schema>"}'
{
"ballot_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>",
"election_ref": "<see schema>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.47 msmint p50
4.116 msmint p95
1.847 msverify p50
2.156 msverify p95
200iterations
1017artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use caseselection auditballot workflowverifiable tallypublic trust audit
Buyer fit illustrations, not customersICE
Partner and use case pagesnone yet
What it provesThis receipt attests that the four named pre-conditions in signed_body were evaluated and combined exactly as recorded, that precond_root recomputes from those four leaves, that outcome was computed from the leaves rather than supplied by the caller, and that the clearance was read at or before expires_at.
What it does not proveIt does not attest that any pre-condition's underlying evidence digest is itself accurate, does not assert that the cleared inference is lawful, and does not attest that any inference which follows actually ran as cleared. A separate Hive receipt for the executed inference is required to check whether the executed model matched request_ref.model_ref.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['imprimatur.clearance']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeimprimatur.clearance
Mint route/mint/imprimatur-clearance
Open verify route/verify/imprimatur-clearance no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/sigr-imprimatur.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/imprimatur-clearance
curl -sS -X POST https://thehiveryiq.com/v1/verify/imprimatur-clearance -H 'content-type: application/json' -d @canon/examples/imprimatur-clearance-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.497 msmint p50
3.363 msmint p95
1.87 msverify p50
2.163 msverify p95
200iterations
2052artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casespre action clearancefour gate checkrelease gatepublication clearanceERC-1271erc1271Circle Gatewaysmart contract authorizationpolicy decision
Buyer fit illustrations, not customersAIUCCiscoICESnowflakeCircle
What it provesInkFrame Non-Mutation typed facade receipt. Attests that a frame_id, a pre-state digest, and a post-state digest were recorded and signed at recorded_at, and that mutated recomputes exactly as false only when the two digests are equal; any digest mismatch fails this receipt rather than being silently accepted. This is a thin unified-API facade over the InkFrame verb family hosted externally under Hive Receipt;
What it does not proveit does not independently reach or depend on that external host, and mutated_externally_confirmed stays false because no cross-check against the external InkFrame service occurred.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['inkframe.nonmutation']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeinkframe.nonmutation
Mint route/mint/inkframe-nonmutation
Open verify route/verify/inkframe-nonmutation no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedmutated is pinned to booleanmutated_externally_confirmed is pinned to False
Example requestPOST https://thehiveryiq.com/v1/mint/inkframe-nonmutation
curl -sS -X POST https://thehiveryiq.com/v1/mint/inkframe-nonmutation -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"frame_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>", "pre_state_sha256": "<64 hex chars, sha256 of your evidence>", "post_state_sha256": "<64 hex chars, sha256 of your evidence>"}'
{
"frame_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>",
"pre_state_sha256": "<64 hex chars, sha256 of your evidence>",
"post_state_sha256": "<64 hex chars, sha256 of your evidence>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.4 msmint p50
2.705 msmint p95
1.814 msverify p50
2.146 msverify p95
200iterations
1398artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesnon mutation proofcontent addressed envelopetamper evidencebyte level integrity
Buyer fit illustrations, not customersCircleCiscoPostmanSnowflake
What it provesThis receipt attests only that a named detecting system, running a digest pinned software build and a digest pinned rule version, committed the digest of a detection artifact at an instant supplied by a named external time anchor with a declared drift bound, at a stated position in a named append only hash chained sequence, with no human approval in its mint path. It bounds the latest instant at which that system can later be said to have first held the committed artifact, and
What it does not proveit does not establish the earliest such instant. It does not attest that the detection was correct, that the committed artifact described a real condition, or that any condition existed at all, and it does not decide whether any response was reasonable, timely, adequate, or complete. It does not decide whether any materiality, significance, or de minimis assessment was right, it makes no such assessment, and it does not determine that any reporting obligation applies, that any deadline was met or missed, or that any rule, regulation, contract, or duty was complied with or breached. It does not identify any affected system, person, account, or asset, it does not disclose the content of the committed artifact, it does not authorise, require, or excuse any notification, escalation, disclosure, remediation, or enforcement action, and it fixes the timeline to which those judgments are applied and nothing more.
Implementation state, from registry data
Implemented, unit tested, smoke tested and documented in this repository, but the manifest does not report it as deployed. Never describe it as live.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['knowledge.timestamp']: deployed false, production_ready_for_canon false, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeknowledge.timestamp
Mint route/mint/knowledge/timestamp
Open verify route/verify/knowledge-timestamp no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/knowledge-timestamp.test.mjs
Example requestPOST http://localhost:3000/mint/knowledge/timestamp
curl -sS -X POST http://localhost:3000/verify/knowledge-timestamp -H 'content-type: application/json' -d '{"receipt": <a receipt of this type>}'
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, none shown
No benchmark is shown for this entry because none was measured against a verified deployment.
Use casesbounded latest instant of machine knowledgeautonomous detection recorddisclosure clock evidence
Buyer fit illustrations, not customersSecurity teamsRegulated issuersIncident response teams
What it provesThis receipt attests that two named records, each observed at a named cursor and at a named instant, and each committed by a distinct registered attestor key to a keyed digest computed over the same declared list of fields, produced the comparison outcome that this service recomputed from those two committed digests and those two instants against the declared window tolerance.
What it does not proveIt does not disclose any position, balance, holder identity, or account identifier. It does not attest that either committed digest is a correct digest of the record it names, because confirming that requires read access which this receipt does not confer. It does not decide which record is correct when the two records diverge, assigns no fault to either operator, does not decide whether the underlying settlement, transfer, or register update was proper, and does not effect or reverse any settlement. A window_exceeded outcome records only that the two observations were too far apart for the comparison to be decisive.
Implementation state, from registry data
Implemented, unit tested, smoke tested and documented in this repository, but the manifest does not report it as deployed. Never describe it as live.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['ledger.parity']: deployed false, production_ready_for_canon false, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeledger.parity
Mint route/mint/ledger/parity
Open verify route/verify/ledger-parity no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/ledger-parity.test.mjs
Example requestPOST http://localhost:3000/mint/ledger/parity
curl -sS -X POST http://localhost:3000/verify/ledger-parity -H 'content-type: application/json' -d '{"receipt": <a receipt of this type>}'
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, none shown
No benchmark is shown for this entry because none was measured against a verified deployment.
Use casestwo record parity without disclosing eithersettlement break evidenceindependent break attestation
Buyer fit illustrations, not customersExchangesTransfer agentsCustodiansBanks
What it provesThis receipt attests that the supplied set of mandate conformance receipts all reference the same delegated authority, all fall inside the stated window, share one currency, contain no duplicate, and that their cumulative total and count were recomputed by this service in integer minor units and compared against the stated cumulative constraint.
What it does not proveThis service cannot know whether the supplied set is complete. A transaction that was never presented here does not appear in these totals, so a within cumulative outcome is a statement about the receipts supplied and not a statement about everything the mandate holder spent. It performs no currency conversion, is not a payment authorisation, shifts no liability under any card network rule, and does not limit any right a consumer holds under Regulation E, Regulation Z, or any equivalent rule.
Implementation state, from registry data
Implemented, unit tested, smoke tested and documented in this repository, but the manifest does not report it as deployed. Never describe it as live.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['mandate.aggregate']: deployed false, production_ready_for_canon false, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typemandate.aggregate
Mint route/mint/mandate/aggregate
Open verify route/verify/mandate-aggregate no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/mandate-aggregate.test.mjs
Example requestPOST http://localhost:3000/mint/mandate/aggregate
curl -sS -X POST http://localhost:3000/verify/mandate-aggregate -H 'content-type: application/json' -d '{"receipt": <a receipt of this type>}'
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, none shown
No benchmark is shown for this entry because none was measured against a verified deployment.
Use casescumulative mandate recordsupplied receipt totaldelegated authority aggregation
Buyer fit illustrations, not customersBanksCard issuersAgentic commerce platforms
What it provesThis receipt attests that the named transaction's amount, currency, timing and scope were compared against the constraints of one specific delegated authority receipt that was signed before the transaction was authorised, and that the outcome was recomputed by this service from that comparison rather than supplied by the caller.
What it does not proveIt does not attest that the cardholder granted the delegation, that the declared agent identity is genuine, that the transaction was authorised or settled by any network, that goods or services were delivered, or that the displayed terms digest corresponds to anything a person actually read. It is not a payment authorisation and carries no cardholder credential. No card network, issuer, or regulator currently recognises this receipt as authentication data, as compelling evidence, or as a liability shift, and it does not create one. It does not deny, resolve, adjudicate or affect any dispute, and it does not limit any right a consumer holds under Regulation E, Regulation Z, or any equivalent rule. This receipt evaluates one transaction against a per transaction constraint and does not evaluate cumulative spend, transaction velocity, or any aggregate limit across multiple transactions under the same mandate, so a series of individually conforming transactions may still exceed a spending intent this receipt cannot see. It evaluates the delegated authority receipt as supplied and inherits that receipt's revocation limitation, so it does not attest that the mandate was still unrevoked at the moment the transaction was authorised.
Implementation state, from registry data
Implemented, unit tested, smoke tested and documented in this repository, but the manifest does not report it as deployed. Never describe it as live.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['mandate.conformance']: deployed false, production_ready_for_canon false, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typemandate.conformance
Mint route/mint/mandate/conformance
Open verify route/verify/mandate-conformance no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/parametric-and-mandate.test.mjs
Example requestPOST http://localhost:3000/mint/mandate/conformance
curl -sS -X POST http://localhost:3000/verify/mandate-conformance -H 'content-type: application/json' -d '{"receipt": <a receipt of this type>}'
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, none shown
No benchmark is shown for this entry because none was measured against a verified deployment.
Use casesagent mandate checktransaction constraint comparisondelegated payment evidenceauthority timing verification
Buyer fit illustrations, not customersBanksCard issuersAgentic commerce platforms
What it provesThis receipt attests that assertion and observation, when both present, are each bound to response_sha256, that comparison_state correctly reflects whether assertion.value_sha256 equals observation.value_sha256 or that no observation was bound, and that assertion.basis is always relayed while observation.basis, when present, is always observed.
What it does not proveIt does not attest that the asserted value is true, does not attest that the observed value is true, does not merge or reconcile the two values into one figure, and does not identify the cause of a divergence when one is present. It requires no access to the provider's execution environment, no access to the observer's collection environment, and no trusted execution environment.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['divergence.record']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typedivergence.record
Mint route/mint/divergence-record
Open verify route/verify/divergence-record no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/proof-instruments-2.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/divergence-record
curl -sS -X POST https://thehiveryiq.com/v1/verify/divergence-record -H 'content-type: application/json' -d @canon/examples/divergence-record-v1.example.agreement.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.417 msmint p50
2.744 msmint p95
1.893 msverify p50
3.306 msverify p95
200iterations
1649artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesmulti source disagreementoracle divergencedata feed integritysettlement datamodel disagreementCircle Gatewayrequested and materialized chaincrosschain USDCERC-1271erc1271
Buyer fit illustrations, not customersKalshiPolymarketFanDuelDraftKingsICESnowflakeCerebrasCircle
What it provesOriginProof, Human-Origin Attestation, receipt. Attests that an asset_id and a caller held production-conditions evidence digest were recorded and signed at recorded_at.
What it does not proveIt attests only the conditions of production (credential clearance, session integrity, declared tool or model use scope) that the caller declared, never that the output itself was provably human. This receipt is distinct from media.origin, which attests media content origin and rights evidence, not human production conditions; they must never be merged or aliased.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['origin.proof']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeorigin.proof
Mint route/mint/origin-proof
Open verify route/verify/origin-proof no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedmatches_media_origin_family is pinned to Falsehuman_output_provable is pinned to False
Example requestPOST https://thehiveryiq.com/v1/mint/origin-proof
curl -sS -X POST https://thehiveryiq.com/v1/mint/origin-proof -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"asset_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>", "origin_claim_type": "<see schema>"}'
{
"asset_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>",
"origin_claim_type": "<see schema>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.468 msmint p50
2.993 msmint p95
1.792 msverify p50
2.105 msverify p95
200iterations
1212artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use caseshuman origin attestationexpert work provenancedataset labellingannotation integrityhuman in the loop
Buyer fit illustrations, not customersMercormicro1SurgeHandshakeDeccan
What it provesThis receipt attests that a named parametric condition was evaluated against one specific Bonded Performance Attestation, that the policy terms digest was committed at or before the governing budget was declared and the budget was declared at or before its measurement window opened, and that trigger_state was recomputed by this service from the referenced attestation rather than supplied by the caller.
What it does not proveIt does not create, confirm, price, underwrite, or interpret any insurance policy, and this service never receives the policy terms. It does not establish that any claim is payable, does not effect or authorise any payment, and does not attest that the measured outputs were correct or that any loss occurred. The measuring party is recorded as declared and is not verified here. Whether this trigger state entitles any party to payment is determined solely by the parties' own contract.
Implementation state, from registry data
Implemented, unit tested, smoke tested and documented in this repository, but the manifest does not report it as deployed. Never describe it as live.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['parametric.trigger']: deployed false, production_ready_for_canon false, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeparametric.trigger
Mint route/mint/parametric/trigger
Open verify route/verify/parametric-trigger no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/parametric-and-mandate.test.mjs
Example requestPOST http://localhost:3000/mint/parametric/trigger
curl -sS -X POST http://localhost:3000/verify/parametric-trigger -H 'content-type: application/json' -d '{"receipt": <a receipt of this type>}'
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, none shown
No benchmark is shown for this entry because none was measured against a verified deployment.
Use casesparametric conditionthreshold precommitmentperformance policy evidenceindependent trigger verification
Buyer fit illustrations, not customersInsurersAI service providersEnterprise risk teams
What it provesProvenance-Bonded Sandbox receipt. Attests that a sandbox_id and a caller held evidence digest were recorded and signed at recorded_at, and that the crypto envelope itself is live.
What it does not proveIt does not attest that any kernel or eBPF hook actually enforced the declared sandbox boundary, or that runtime drift was actually detected; ebpf_integration_status is fixed to not_proven because no such integration exists in this repository.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['usap.pbs']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeusap.pbs
Mint route/mint/usap-pbs
Open verify route/verify/usap-pbs no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedcrypto_core_status is pinned to liveebpf_integration_status is pinned to not_proven
Example requestPOST https://thehiveryiq.com/v1/mint/usap-pbs
curl -sS -X POST https://thehiveryiq.com/v1/mint/usap-pbs -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"sandbox_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"}'
{
"sandbox_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.452 msmint p50
4.55 msmint p95
1.787 msverify p50
2.102 msverify p95
200iterations
1049artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casessandbox integrityruntime driftagent containmenttrading sandboxenvironment root
Buyer fit illustrations, not customersKalshiFanDuelDraftKingsPolymarketFanaticsRobinhoodCiscoAIUC
What it provesPerimeter Bond receipt. Attests that a perimeter_id and a caller held evidence digest were recorded and signed at recorded_at, and that the crypto envelope itself is live.
What it does not proveIt does not attest that any eBPF stack actually enforced the declared perimeter, or that an outbound attempt was actually intercepted; ebpf_stack_integration is fixed to pending_design_partner because no such integration exists in this repository.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['usap.perimeter']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeusap.perimeter
Mint route/mint/usap-perimeter
Open verify route/verify/usap-perimeter no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedcrypto_core_status is pinned to liveebpf_stack_integration is pinned to pending_design_partner
Example requestPOST https://thehiveryiq.com/v1/mint/usap-perimeter
curl -sS -X POST https://thehiveryiq.com/v1/mint/usap-perimeter -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"perimeter_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"}'
{
"perimeter_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.455 msmint p50
4.931 msmint p95
1.787 msverify p50
2.158 msverify p95
200iterations
1071artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesoutbound network controlreach controlegress allowlistagent network policyrobot teleop boundary
Buyer fit illustrations, not customersCiscoCloudflareCircleKodiak RoboticsSnowflake
What it provesThis receipt attests that concentration counts and share ratios were recomputed by this service over a set of opaque commitments supplied for one book as of a stated time, that no group smaller than five members was reported, and that this service received no insured identity, no dependency name, and no policy term.
What it does not proveIt does not attest that the commitments are correct, that they were computed honestly, that the book is complete, or that any member is insured at all. Because the commitments are opaque to this service by design, this service cannot detect a member that was omitted, duplicated, or mis committed. It does not measure, price, or opine on risk, does not constitute an actuarial analysis, a capital adequacy assessment, or a reinsurance recommendation, and it does not attest that a concentration reported here would produce a correlated loss.
Implementation state, from registry data
Implemented, unit tested, smoke tested and documented in this repository, but the manifest does not report it as deployed. Never describe it as live.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['portfolio.exposure']: deployed false, production_ready_for_canon false, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeportfolio.exposure
Mint route/mint/portfolio/exposure
Open verify route/verify/portfolio-exposure no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/portfolio-exposure.test.mjs
Example requestPOST http://localhost:3000/mint/portfolio/exposure
curl -sS -X POST http://localhost:3000/verify/portfolio-exposure -H 'content-type: application/json' -d '{"receipt": <a receipt of this type>}'
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, none shown
No benchmark is shown for this entry because none was measured against a verified deployment.
Use casesopaque commitment concentrationprivacy preserving dependency reportingportfolio concentration record
Buyer fit illustrations, not customersInsurersRisk teamsReinsurance teams
What it provesPhysiological Provenance Receipt for wearable sensor data. Attests that a record_id, a metric_type, and a caller held metric-value digest were recorded and signed at recorded_at.
What it does not proveIt does not attest that any wearable device was actually attested at the hardware level; device_attestation_status is fixed to not_proven because no device attestation integration exists in this repository.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['ppr.wearable']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeppr.wearable
Mint route/mint/ppr-wearable
Open verify route/verify/ppr-wearable no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computeddevice_attestation_status is pinned to not_proven
Example requestPOST https://thehiveryiq.com/v1/mint/ppr-wearable
curl -sS -X POST https://thehiveryiq.com/v1/mint/ppr-wearable -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"record_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>", "metric_type": "<see schema>"}'
{
"record_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>",
"metric_type": "<see schema>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.44 msmint p50
2.983 msmint p95
1.814 msverify p50
2.105 msverify p95
200iterations
1021artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use caseswearable telemetrysensor provenancephysiological signalhealth datarobot sensor stream
Buyer fit illustrations, not customersRobot.comKodiak RoboticsCiscoFanatics
What it provesProof Pre-Fill receipt. Attests that a prefill_id, a template_ref, and a caller held prefilled-fields digest were recorded and signed at recorded_at, and that template_conformance recomputes exactly from a caller supplied template_digest_match flag.
What it does not proveIt does not attest that the template itself is fit for purpose, or that the prefilled values are factually correct.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['proof.prefill']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeproof.prefill
Mint route/mint/proof-prefill
Open verify route/verify/proof-prefill no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedtemplate_conformance is pinned to boolean
Example requestPOST https://thehiveryiq.com/v1/mint/proof-prefill
curl -sS -X POST https://thehiveryiq.com/v1/mint/proof-prefill -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"prefill_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>", "template_ref": "<see schema>", "template_digest_match": "<see schema>"}'
{
"prefill_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>",
"template_ref": "<see schema>",
"template_digest_match": "<see schema>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.404 msmint p50
2.679 msmint p95
1.761 msverify p50
3.078 msverify p95
200iterations
1020artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casespre effect receiptfingerprint bindingform pre fillbefore the act proof
Buyer fit illustrations, not customersCircleChimeCiscoPostman
What it provesThis receipt attests that the recorded transition sequence in signed_body is exactly what the predeclared transition table would produce from the named admissible input receipts, applied in the stated order, and that each input's issuer_key_id and admitted_role were declared in issuer_registry at the time this run was minted. Schema level and portable proof verification check the digest bindings only. Full verification additionally requires the caller to supply the actual input receipt envelopes and cryptographically verifies each one through the trust resolver before accepting it.
What it does not proveThis receipt does not attest that the transition table encodes correct business logic, that an input receipt not supplied for full verification is itself valid, or that any downstream effect named by effect_gate actually occurred. It also does not attest that issuer_registry is the complete or current set of issuers trusted outside this run, only the set this run declares itself bound to.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['proof.transition']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeproof.transition
Mint route/mint/proof-transition
Open verify route/verify/proof-transition no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/proof-instruments.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/proof-transition
curl -sS -X POST https://thehiveryiq.com/v1/verify/proof-transition -H 'content-type: application/json' -d '{"receipt": <a receipt of this type>}'
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.714 msmint p50
3.47 msmint p95
1.922 msverify p50
2.218 msverify p95
200iterations
2666artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesstate machine auditworkflow provenancepipeline stage proofdeployment pipelinerobot task sequenceCircle GatewayGateway attestationcrosschain USDCERC-1271erc1271
Buyer fit illustrations, not customersHarnessCiscoSnowflakeKodiak RoboticsRobot.comCircle
What it provesThis receipt attests that the exporting signer named in key_id asserts the workflow_id, table_sha256, registry_sha256, final_state, effect_gate_sha256, input_count, and input_commitment bound here for the run named by run_id, exported from the full proof.transition container named by source_receipt_id and source_payload_sha256. Portable verification authenticates this signed assertion and its internal bindings only.
What it does not proveIt does not independently replay the omitted constituent inputs, does not verify the source container's own signature, and does not attest that the source container itself still exists or still verifies. A verifier who needs that replay must obtain and verify the full proof.transition container separately.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['proof.transition.portable']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeproof.transition.portable
Mint routeno mint route
Open verify route/verify/proof-transition-portable no auth
Auth requirementNo mint route exists for this type; it is produced as an export. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/proof-instruments.test.mjs
Example requestPOST https://thehiveryiq.com/v1/verify/proof-transition-portable
curl -sS -X POST https://thehiveryiq.com/v1/verify/proof-transition-portable -H 'content-type: application/json' -d @canon/examples/proof-transition-portable-v1.example.json
{
"receipt": "<contents of /canon/examples/proof-transition-portable-v1.example.json>"
}
This type has no mint route. It is produced as an export by another route and only verified here, so there is nothing to authenticate against.
Benchmark, measured
0.615 msmint p50
0.747 msmint p95
1.784 msverify p50
2.074 msverify p95
200iterations
1777artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesoffline audit exportregulator handoffevidence portabilitythird party reviewCircle GatewayGateway attestationcrosschain USDCERC-1271erc1271
Buyer fit illustrations, not customersICEKalshiSnowflakeCiscoCircle
What it provesRefusal Ledger receipt. Attests that a refusal_event_id and a caller held evidence digest were recorded and signed at recorded_at, and that the crypto envelope itself is live.
What it does not proveIt does not attest that any policy engine actually authorized the mutation, or that a zk envelope bond circuit checked it; policy_engine_status and zk_envelope_bond_status are fixed to not_proven because no such engine or circuit exists in this repository.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['usap.refusal']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeusap.refusal
Mint route/mint/usap-refusal
Open verify route/verify/usap-refusal no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedcrypto_core_status is pinned to livepolicy_engine_status is pinned to not_provenzk_envelope_bond_status is pinned to not_proven
Example requestPOST https://thehiveryiq.com/v1/mint/usap-refusal
curl -sS -X POST https://thehiveryiq.com/v1/mint/usap-refusal -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"refusal_event_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"}'
{
"refusal_event_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.427 msmint p50
3.73 msmint p95
1.767 msverify p50
2.097 msverify p95
200iterations
1113artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesrefusal policypolicy change controlguardrail auditsafety policy mutation
Buyer fit illustrations, not customersAIUCCiscoSnowflakeFireworks
What it provesThis receipt attests that route_policy.policy_sha256 recomputes canonically from route_policy.policy, that route_policy.declared_at
What it does not provedoes not follow decision_window.opens_at, and that selected_route_id is exactly what route_policy.selection_rule and route_policy.policy would produce from the candidates array as scored against evidence_sha256 for each candidate, inside decision_window. It does not attest that the policy is well designed, that any candidate score reflects real world quality, or that the evidence snapshot behind evidence_sha256 was collected honestly.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['routing.receipt']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typerouting.receipt
Mint route/mint/routing
Open verify route/verify/routing no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/proof-instruments.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/routing
curl -sS -X POST https://thehiveryiq.com/v1/verify/routing -H 'content-type: application/json' -d @canon/examples/routing-receipt-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.491 msmint p50
4.294 msmint p95
1.805 msverify p50
2.098 msverify p95
200iterations
1704artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesmodel routingprovider selectionfallback pathcost routingpolicy routed inference
Buyer fit illustrations, not customersOpenRouterFireworksCerebrasCloudflare
What it provesSigned Royalty-Provenance Receipt. Attests that a work_id, a rights_holder_ref, and a caller held royalty-event digest were recorded and signed at recorded_at, and that rights_chain_verified recomputes exactly from a caller supplied delegation_receipt_supplied flag.
What it does not proveIt does not itself verify a rights chain cryptographically; a caller wanting a cryptographically checked chain must separately supply and verify an authority.delegation receipt, this contract only records whether one was supplied.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['royalty.provenance']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeroyalty.provenance
Mint route/mint/royalty-provenance
Open verify route/verify/royalty-provenance no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedrights_chain_verified is pinned to boolean
Example requestPOST https://thehiveryiq.com/v1/mint/royalty-provenance
curl -sS -X POST https://thehiveryiq.com/v1/mint/royalty-provenance -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"work_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>", "rights_holder_ref": "<see schema>", "delegation_receipt_supplied": "<see schema>"}'
{
"work_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>",
"rights_holder_ref": "<see schema>",
"delegation_receipt_supplied": "<see schema>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.579 msmint p50
5.155 msmint p95
1.892 msverify p50
2.139 msverify p95
200iterations
1170artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesroyalty splitrights chaincontent licensingcreator payoutmedia provenance
Buyer fit illustrations, not customersFanaticsFish AudioCartesiaCircle
What it provesS2S, Silicon-to-Signature, receipt. Attests that an inference_id and a caller held GPU-session evidence digest were recorded and signed at recorded_at.
What it does not proveIt does not attest that a real NVIDIA GPU hardware attestation (for example nvtrust) chain was actually checked; gpu_hardware_attestation_status is fixed to not_proven because no such hardware attestation integration exists in this repository. S2S is Silicon-to-Signature, not a speech or voice primitive, and is a distinct canonical type from afir.stream.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['s2s.signature']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical types2s.signature
Mint route/mint/s2s-signature
Open verify route/verify/s2s-signature no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedcrypto_core_status is pinned to livegpu_hardware_attestation_status is pinned to not_proven
Example requestPOST https://thehiveryiq.com/v1/mint/s2s-signature
curl -sS -X POST https://thehiveryiq.com/v1/mint/s2s-signature -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"inference_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"}'
{
"inference_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.395 msmint p50
2.773 msmint p95
1.8 msverify p50
2.161 msverify p95
200iterations
1155artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesGPU attestationsilicon to signaturehardware bound inferencecompute provenancerobot compute
Buyer fit illustrations, not customersCerebrasFireworksCiscoKodiak Robotics
What it provesThis receipt attests that a named screening engine, at a named ruleset version bound by a ruleset digest, evaluated a keyed commitment to a counterparty identifier against one named primary reference list at a named version bound by a digest over that version's contents, together with any named supplemental lists at their own named versions and digests, at a screening instant placed against a declared external time reference with a declared drift bound, and recorded the stated verdict under a recomputed signing authority requirement together with a declared validity period measured from that screening instant.
What it does not proveIt does not attest that the reference list itself is complete, accurate, current as published, or free of omission, and it does not attest that the publisher of that list acted correctly. It does not decide whether the counterparty is in fact a sanctioned, restricted or prohibited party, a false negative produced by an honest screening against a correctly bound list version remains a false negative that this receipt does not detect, does not correct and does not disclose, and no gate here detects an engine that reports a clear verdict where its own matching computation produced a match. It does not assess whether the screening program as a whole is adequate, whether the ruleset thresholds are appropriately calibrated, whether the set of lists screened is the correct set for any obligation, or whether the declared validity period is short enough for any purpose. It does not identify the counterparty, does not disclose any list record, does not disclose any match score, and does not confirm that the commitment key or the window salt has remained under the custody of any particular party. It does not authorize, block, freeze, reverse or settle any transaction, does not admit or reject any counterparty, does not constitute a report or notification to any authority, does not constitute legal, regulatory or compliance advice, and whether any obligation is satisfied by the screening it records is determined solely by the applicable law and by the parties' own arrangements.
Implementation state, from registry data
Implemented, unit tested, smoke tested and documented in this repository, but the manifest does not report it as deployed. Never describe it as live.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['screening.attestation']: deployed false, production_ready_for_canon false, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typescreening.attestation
Mint route/mint/screening/attestation
Open verify route/verify/screening-attestation no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/screening-attestation.test.mjs
Example requestPOST http://localhost:3000/mint/screening/attestation
curl -sS -X POST http://localhost:3000/verify/screening-attestation -H 'content-type: application/json' -d '{"receipt": <a receipt of this type>}'
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, none shown
No benchmark is shown for this entry because none was measured against a verified deployment.
Use casessanctions screening record bound to a list versioncountersigned verdictreliance freshness evidence
Buyer fit illustrations, not customersBanksCard networksPayment processorsExchanges
What it provesThis receipt attests that the recorded events fold to sequence_root in exactly the recorded order, that when a lower bound is present the named public block hash was folded into that root so the root cannot have been constructed before that block existed, that when an upper bound is present the RFC 3161 token's message imprint equals sequence_root so an authority outside Hive held that root at the stated time, and that anchor_state and bracket recompute from the bounds actually present.
What it does not proveIt does not attest that any event is true, that any event set is complete, or that the producing system's own observed times are honest. It does not itself validate the timestamp authority's certificate chain; the complete token is carried in the receipt so an independent verifier can check that chain against the authority's published root.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['sequence.attestation']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typesequence.attestation
Mint route/mint/sequence-attestation
Open verify route/verify/sequence-attestation no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/sequence-attestation.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/sequence-attestation
curl -sS -X POST https://thehiveryiq.com/v1/verify/sequence-attestation -H 'content-type: application/json' -d '{"receipt": <a receipt of this type>}'
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.61 msmint p50
3.231 msmint p95
1.863 msverify p50
4.256 msverify p95
200iterations
1965artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesincident notification timelinedetection to disclosure intervalregulatory reporting deadlineevent ordering disputeoutage timeline reconstructionaudit trail time bracketing
Buyer fit illustrations, not customersIntercontinental ExchangeNasdaqDTCCFINRA member firmsclearing housesmarket operators
What it provesHive Settlement Feed receipt. Attests that a settlement_id, a feed_source_ref, and a caller held settlement-amount digest were recorded and signed at recorded_at.
What it does not proveIt does not attest that this is a settlement-specific surface distinct from a generic signer call; distinct_from_generic_signer is fixed to false pending an explicit product decision, and no regulated market endorsement or accuracy claim is made.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['settlement.feed']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typesettlement.feed
Mint route/mint/settlement-feed
Open verify route/verify/settlement-feed no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computeddistinct_from_generic_signer is pinned to False
Example requestPOST https://thehiveryiq.com/v1/mint/settlement-feed
curl -sS -X POST https://thehiveryiq.com/v1/mint/settlement-feed -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"settlement_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>", "feed_source_ref": "<see schema>"}'
{
"settlement_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>",
"feed_source_ref": "<see schema>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.421 msmint p50
3.104 msmint p95
1.743 msverify p50
1.955 msverify p95
200iterations
1057artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesmarket settlement dataprediction marketsports data integrityoracle signingregulated exchangeCircle Gatewaycrosschain USDCGateway attestationERC-1271
Buyer fit illustrations, not customersKalshiFanDuelDraftKingsPolymarketICEFanaticsCircle
What it provesThis receipt attests that total_micro_usd recomputes exactly from the recorded input_tokens, output_tokens, price_input_micro_usd_per_1k, and price_output_micro_usd_per_1k.
What it does not proveIt does not attest that the token counts are accurate, that the unit prices reflect any published or contractual price list, or that the underlying inference request actually ran.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['sigr.bill']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typesigr.bill
Mint route/mint/sigr-bill
Open verify route/verify/sigr-bill no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/sigr-family.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/sigr-bill
curl -sS -X POST https://thehiveryiq.com/v1/verify/sigr-bill -H 'content-type: application/json' -d @canon/examples/sigr-bill-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.443 msmint p50
2.805 msmint p95
1.805 msverify p50
3.329 msverify p95
200iterations
987artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casestoken billinginference costusage meteringchargebackcost reconciliation
Buyer fit illustrations, not customersFireworksOpenRouterCerebrasCircleSnowflake
What it provesThis receipt attests that breached and penalty_micro_usd recompute exactly from the recorded bond terms and the recorded measurement.
What it does not proveIt does not attest that the measurement was collected honestly, that the bond terms are commercially reasonable, or that any penalty is legally owed.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['sigr.bond']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typesigr.bond
Mint route/mint/sigr-bond
Open verify route/verify/sigr-bond no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/sigr-family.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/sigr-bond
curl -sS -X POST https://thehiveryiq.com/v1/verify/sigr-bond -H 'content-type: application/json' -d @canon/examples/sigr-bond-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.435 msmint p50
2.873 msmint p95
1.815 msverify p50
3.201 msverify p95
200iterations
1006artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesSLA bondpenalty computationuptime guaranteebreach evidence
Buyer fit illustrations, not customersHarnessFireworksCerebrasCloudflareCisco
What it provesThis receipt attests that prefix_sha256 and token_span were sealed at sealed_at for the named model_id, and, when parent_ref is present, that this entry extends the exact prior sealed entry it names.
What it does not proveIt does not attest that the cached content is correct, was computed deterministically, or was actually reused by any later inference.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['sigr.cachesign']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typesigr.cachesign
Mint route/mint/sigr-cachesign
Open verify route/verify/sigr-cachesign no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/sigr-family.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/sigr-cachesign
curl -sS -X POST https://thehiveryiq.com/v1/verify/sigr-cachesign -H 'content-type: application/json' -d @canon/examples/sigr-cachesign-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.378 msmint p50
2.814 msmint p95
1.791 msverify p50
2.129 msverify p95
200iterations
962artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesKV cache integrityprefix reusecache poisoning defenceinference serving
Buyer fit illustrations, not customersFireworksCerebrasOpenRouterCloudflare
What it provesThis receipt attests that the steps array recorded in signed_body, hashed in order, recomputes to chain_root, and that the sequence was sealed at sealed_at with no step dropped, reordered, or altered afterward.
What it does not proveIt does not attest that any step's content is accurate, that a tool_call step actually executed against the named tool, or that the agent's final answer is correct or fit for any purpose.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['sigr.chain']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typesigr.chain
Mint route/mint/sigr-chain
Open verify route/verify/sigr-chain no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/sigr-imprimatur.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/sigr-chain
curl -sS -X POST https://thehiveryiq.com/v1/verify/sigr-chain -H 'content-type: application/json' -d @canon/examples/sigr-chain-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.463 msmint p50
2.715 msmint p95
1.814 msverify p50
2.224 msverify p95
200iterations
1507artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesagent run auditstep sealed runmulti step agenttool chain proofinference guarantee
Buyer fit illustrations, not customersFireworksCerebrasOpenRouterCiscoSnowflakeAIUC
What it provesThis receipt attests that winner_seq and agreement_bp recompute exactly from the recorded members array under the declared method.
What it does not proveIt does not attest that any member output is correct, that the scoring method is well designed, or that the panel membership recorded here is complete.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['sigr.consensus']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typesigr.consensus
Mint route/mint/sigr-consensus
Open verify route/verify/sigr-consensus no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/sigr-family.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/sigr-consensus
curl -sS -X POST https://thehiveryiq.com/v1/verify/sigr-consensus -H 'content-type: application/json' -d @canon/examples/sigr-consensus-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.443 msmint p50
2.869 msmint p95
1.773 msverify p50
3.187 msverify p95
200iterations
1251artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesmodel paneljury of modelsagreement scoringanswer selection
Buyer fit illustrations, not customersOpenRouterFireworksCerebrasKalshiSnowflake
What it provesThis receipt attests that claims_root and grounded_count recompute exactly from the recorded claims array, and that a claim with support_sha256 null carries support_strength_bp of 0. It proves that each claim carries the recorded support reference and strength.
What it does not proveIt does not prove that any claim is factually true, that the named support passage actually supports the claim it is attached to, or that the grounding method itself is sound.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['sigr.gca']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typesigr.gca
Mint route/mint/sigr-gca
Open verify route/verify/sigr-gca no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/sigr-family.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/sigr-gca
curl -sS -X POST https://thehiveryiq.com/v1/verify/sigr-gca -H 'content-type: application/json' -d @canon/examples/sigr-gca-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.443 msmint p50
5.094 msmint p95
1.846 msverify p50
2.235 msverify p95
200iterations
1480artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesgrounding attestationcitation checkretrieval groundinghallucination control
Buyer fit illustrations, not customersSnowflakeFireworksCerebrasAIUCCisco
What it provesThis receipt attests that triggered recomputes exactly from the five named boolean signals and trigger_bp. It asserts provenance_anomaly_pattern_observed only.
What it does not proveIt does not assert that anything is factually wrong, does not assert malicious intent, and does not assert that the underlying content is false or true.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['sigr.gitm']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typesigr.gitm
Mint route/mint/sigr-gitm
Open verify route/verify/sigr-gitm no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/sigr-family.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/sigr-gitm
curl -sS -X POST https://thehiveryiq.com/v1/verify/sigr-gitm -H 'content-type: application/json' -d @canon/examples/sigr-gitm-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.404 msmint p50
4.056 msmint p95
1.773 msverify p50
2.227 msverify p95
200iterations
1031artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesanomaly flagcross signal detectiondrift signalabuse detection
Buyer fit illustrations, not customersCiscoCloudflareSnowflakeChimeRobinhood
What it provesThis receipt attests that manifest_sha256 recomputes exactly from the recorded model_id, weights_sha3, config_hash, and endpoint, at issued_at.
What it does not proveIt does not attest that the named endpoint is currently serving these weights, that the weights are free of vulnerabilities or backdoors, or that config_hash describes a safe or correct configuration.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['sigr.manifest']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typesigr.manifest
Mint route/mint/sigr-manifest
Open verify route/verify/sigr-manifest no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/sigr-family.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/sigr-manifest
curl -sS -X POST https://thehiveryiq.com/v1/verify/sigr-manifest -H 'content-type: application/json' -d @canon/examples/sigr-manifest-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.387 msmint p50
2.763 msmint p95
1.832 msverify p50
3.193 msverify p95
200iterations
1164artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesmodel manifestserving weights identityTEE free attestationsupply chain of models
Buyer fit illustrations, not customersFireworksCerebrasOpenRouterSnowflake
What it provesThis receipt attests that lineage_root recomputes exactly from the recorded steps array, and that identity_flicker recomputes exactly from steps and expected_model. It asserts served_model_identity_and_lineage only.
What it does not proveIt does not assert that any step's outputs are correct, safe, or fit for any purpose, and does not assert that weights_sha3 or config_hash describe a vulnerability free model.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['sigr.mir']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typesigr.mir
Mint route/mint/sigr-mir
Open verify route/verify/sigr-mir no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/sigr-family.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/sigr-mir
curl -sS -X POST https://thehiveryiq.com/v1/verify/sigr-mir -H 'content-type: application/json' -d @canon/examples/sigr-mir-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.447 msmint p50
2.746 msmint p95
1.789 msverify p50
3.13 msverify p95
200iterations
1546artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesmodel identityfine tune lineagerelineagecheckpoint provenancemodel registry
Buyer fit illustrations, not customersFireworksCerebrasOpenRouterSnowflakeMercor
What it provesSovereign AI Receipt Registry receipt. Attests that a registry_entry_id, a jurisdiction_ref, and a caller held registered-receipts digest were recorded and signed at recorded_at.
What it does not proveIt does not attest to any actual jurisdictional or governmental authority relationship; jurisdictional_authority_confirmed is fixed to false because no such relationship is confirmed in this repository.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['receipt.registry.sovereign']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typereceipt.registry.sovereign
Mint route/mint/receipt-registry-sovereign
Open verify route/verify/receipt-registry-sovereign no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedjurisdictional_authority_confirmed is pinned to False
Example requestPOST https://thehiveryiq.com/v1/mint/receipt-registry-sovereign
curl -sS -X POST https://thehiveryiq.com/v1/mint/receipt-registry-sovereign -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"registry_entry_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>", "jurisdiction_ref": "<see schema>"}'
{
"registry_entry_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>",
"jurisdiction_ref": "<see schema>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.441 msmint p50
5.241 msmint p95
1.661 msverify p50
1.887 msverify p95
200iterations
1074artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesnational registrysovereign key custodygovernment AI oversightcountry scale signing
Buyer fit illustrations, not customersICECiscoSnowflake
What it provesThis receipt attests that anchored_regions and its required_proof_level values were bound at declared_at, before the request identified by request_digest was transmitted, and that regions_sha256 recomputes canonically from anchored_regions.
What it does not proveIt does not attest that the request content is good, true, or complete, it does not alter or transmit the request, it does not attest that any downstream response met the required proof level, and it does not require the receiving party's cooperation to exist. The party bearing the consequence of the request retains full control of the request; this receipt only fixes, in advance, the evidentiary bar that response will later be measured against.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['proof.demand']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typeproof.demand
Mint route/mint/proof-demand
Open verify route/verify/proof-demand no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/proof-instruments-2.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/proof-demand
curl -sS -X POST https://thehiveryiq.com/v1/verify/proof-demand -H 'content-type: application/json' -d @canon/examples/proof-demand-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.488 msmint p50
2.818 msmint p95
1.948 msverify p50
3.716 msverify p95
200iterations
1880artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesproof level bindingpre submission gateprompt region policyconsequence routingERC-1271erc1271Circle Gatewaysigned intent digestsmart wallet
Buyer fit illustrations, not customersCerebrasFireworksOpenRouterCiscoCircle
What it provesStructural Lateration receipt. Attests that a structure_id, a caller declared lateration_method, and an input digest set were recorded and signed at recorded_at, and that method_reproducible recomputes exactly from a caller supplied recomputed_digest_match flag.
What it does not proveIt does not itself independently re-run the lateration computation; a caller wanting independent recomputation must supply the same input_digest_set to their own implementation and compare.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json honesty_receipts['structural.lateration']: deployed true, production_ready_for_canon true, unit_tested true, adversarially_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typestructural.lateration
Mint route/mint/structural-lateration
Open verify route/verify/structural-lateration no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open. Every verdict field is service computed and pinned by schema const, so a caller cannot request a stronger verdict.
Sourcehive-verifier-api/src/typed/honesty-contracts-registry.js and hive-verifier-api/src/typed/honesty-contract.js
Testshive-verifier-api/test/honesty-contracts.test.mjs hive-verifier-api/test/honesty-evidence-registry.test.mjs
Verdict ceiling, service computedmethod_reproducible is pinned to boolean
Example requestPOST https://thehiveryiq.com/v1/mint/structural-lateration
curl -sS -X POST https://thehiveryiq.com/v1/mint/structural-lateration -H 'content-type: application/json' -H "authorization: Bearer $HIVE_TYPED_MINT_TOKEN" -d '{"structure_id": "your-subject-id", "evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>", "lateration_method": "<see schema>", "recomputed_digest_match": "<see schema>"}'
{
"structure_id": "your-subject-id",
"evidence_digest_sha256": "<64 hex chars, sha256 of your evidence>",
"lateration_method": "<see schema>",
"recomputed_digest_match": "<see schema>"
}
Mint fails closed with 401 when the token is missing or wrong and 503 when the signer is not configured.
Benchmark, measured
2.417 msmint p50
4.706 msmint p95
1.724 msverify p50
2.027 msverify p95
200iterations
1135artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casesreproducible computationavoided cost meteringresidual costrecompute check
Buyer fit illustrations, not customersHarnessSnowflakeFireworksCircle
What it provesThis receipt attests that the named replacement corrects the receipts named in supersedes as of effective_at, for the reason and scope stated in signed_body.
What it does not proveIt does not attest that the replacement content is itself correct, and it does not alter the superseded receipts, which remain independently verifiable exactly as originally signed.
Implementation state, from registry data
PRODUCTION_MANIFEST.json reports deployed true and production_ready_for_canon true for this type, from a live probe of the production URL.
hive-verifier-api/PRODUCTION_MANIFEST.json receipts['supersession.receipt']: deployed true, production_ready_for_canon true, unit_tested true, smoke_tested true, generated_at 2026-08-07T12:33:38.681Z from a live check of https://thehiveryiq.com/v1.
Canonical typesupersession.receipt
Mint route/mint/supersession
Open verify route/verify/supersession no auth
Auth requirementMint requires Authorization: Bearer HIVE_TYPED_MINT_TOKEN and fails closed. Verify is open and unauthenticated.
Sourcehive-verifier-api/src/typed/ plus hive-verifier-api/server.js
Teststest/proof-instruments.test.mjs
Example requestPOST https://thehiveryiq.com/v1/mint/supersession
curl -sS -X POST https://thehiveryiq.com/v1/verify/supersession -H 'content-type: application/json' -d @canon/examples/supersession-receipt-v1.example.json
The open verify route needs no credentials, so this is the fastest honest check. Mint fails closed with 401 when the token is missing or wrong.
Benchmark, measured
2.464 msmint p50
2.901 msmint p95
1.763 msverify p50
3.136 msverify p95
200iterations
1301artifact bytes
Local harness measurement on one machine and one Node version. It is a reproducible measurement of this code, not a production latency guarantee. Source hive-verifier-api/benchmarks/results-latest.json at commit b453d2263658, 2026-08-07T12:35:39.693Z.
Use casescorrection recordrestatementretractiondata correctionsettlement correction
Buyer fit illustrations, not customersKalshiPolymarketICESnowflake
External operational service, 16 entries
What it provesDecomposes a model request into signed routable sub tasks, executes fragments concurrently and returns a verifiable commitment over the fragment set, signed with ML-DSA-65.
What it does not proveIt does not prove any provider executed a fragment faithfully beyond what the returned commitment covers, it has no test files in its own repository, and only one of its four Modal app names was confirmed reachable.
Implementation state, from registry data
A host outside this codebase answered a non mutating probe in a recorded audit session. Operational for that host only, not for this repository.
canon-repository-live-service-audit.md section 5: GET https://srotzin--afir-cern-afir-api.modal.run/health returned 200 reporting afir-1.2.13 with ML-DSA-65. Section 4 note 4 records that four Modal app names exist in one private repository and only afir-cern was confirmed live.
Canonical typeafir.route
Schema URLnone published
Mint routeno mint route
Open verify routeGET https://srotzin--afir-cern-afir-api.modal.run/health no auth
Auth requirementHealth read is open. Routing operations are gated by the Modal deployment, not by this repository.
Sourceafir/modal_app.py and afir/afir_fm.py are committed in this repository; the deployed app also has a private srotzin/afir repository.
Example requestGET https://srotzin--afir-cern-afir-api.modal.run/health
{
"method": "GET",
"url": "https://srotzin--afir-cern-afir-api.modal.run/health",
"auth": "none",
"body": null,
"note": "Version string should read afir-1.2.13 or later. Confirm before citing AFIR as live."
}
Version string should read afir-1.2.13 or later. Confirm before citing AFIR as live.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesfragmented inferenceprivate inference routingsub task signingconcurrent fragmentspost quantum routing
Buyer fit illustrations, not customersFireworksCerebrasOpenRouterCisco
What it provesThat a prompt was compressed before it reached a model, by how much, and that the resulting call and its response were signed with ML-DSA-65 under a key the caller can check. It wraps an ordinary model call in a certified envelope, so a party who was not present can confirm what was actually sent, what came back, and that neither was edited afterwards.
What it does not proveIt does not prove the model's answer is correct, and it does not prove compression preserved meaning. Compression is measured on tokens, not on semantics, and a caller who needs semantic equivalence must establish that separately. The baseline leg of GET /v1/amplify/bench depends on an upstream provider call which returned HTTP 402 on the 2026-08-06 probe, so on that probe the token reduction figure is real and the paired response side comparison was not exercised. The backend is not vendored into this repository, so no repository level implementation state can be shown for it here.
Implementation state, from registry data
A host outside this codebase answered a non mutating probe in a recorded audit session. Operational for that host only, not for this repository.
Live probe of https://receipts.thehiveryiq.com on 2026-08-06. GET /v1/amplify/selftest returned 200. GET /openapi.json lists nine amplify paths: /v1/amplify/bench, /call, /corpus/append, /corpus/retrieve, /corpus/stats, /selftest, /sign, /verify, /wrap-receipt. GET /v1/amplify/bench returned a real measured run reporting prompt_tokens 41 before compression and 23 after, cert_alg ML-DSA-65 with a signature prefix present. GET /v1/amplify/corpus/stats returned total_rows 44 across 19 tenants at embed_dim 256.
Canonical typeamplify.certified_call
Schema URLnone published
Mint routePOST https://receipts.thehiveryiq.com/v1/amplify/sign
Open verify routePOST https://receipts.thehiveryiq.com/v1/amplify/verify no auth
Auth requirementGET /v1/amplify/selftest, /bench and /corpus/stats are open reads. Signing, calling and corpus append are gated by the service's own policy, not by this repository.
Source
Example requestGET https://receipts.thehiveryiq.com/v1/amplify/selftest
{
"method": "GET",
"url": "https://receipts.thehiveryiq.com/v1/amplify/selftest"
}
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesprompt compression accountingcertified model callinference cost reduction evidencesigned request and response pair
Buyer fit illustrations, not customersIntercontinental ExchangeHarnessSnowflakeCerebras
What it provesLabels requests at origin and countersigns them at arrival by comparing the approved action tuple against the delivered action tuple. Deterministic classification with a seven response routing table.
What it does not proveThere is no public mint route by design, so no one outside the deployment can produce a Carnac countersignature. The reference core repository is private and unreadable from outside.
Implementation state, from registry data
A host outside this codebase answered a non mutating probe in a recorded audit session. Operational for that host only, not for this repository.
canon-source-of-truth-reconciliation.md section 4.4 records Carnac hosted live inside Hive Receipt as a proof demand and routing subsystem with deterministic classification and ML-DSA-65 sibling signatures; canon-repository-live-service-audit.md section 1 confirms the reference core repository carnac-core-private exists with no public endpoint by design.
Canonical typegateway.countersignature
Schema URLnone published
Mint routeno mint route
Open verify routeGET https://inkframe.thehiveryiq.com/health no auth
Auth requirementNo public mint route by design. Gateway operations are internal to the deployment.
SourcePrivate repository srotzin/carnac-core-private, plus the committed reference harness under carnac-gateway-core/ in this repository.
Example requestGET https://inkframe.thehiveryiq.com/health
{
"method": "GET",
"url": "https://inkframe.thehiveryiq.com/health",
"auth": "none",
"body": null,
"note": "Carnac is hosted inside Hive Receipt. There is deliberately no public countersignature mint route."
}
Carnac is hosted inside Hive Receipt. There is deliberately no public countersignature mint route.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesarrival countersignaturegateway checkapproved versus deliveredprompt labellingconsequence routing
Buyer fit illustrations, not customersCircleCiscoPostmanCloudflare
What it provesSigns and verifies a contiguous hash chain of an entity's history against a live public key endpoint. A separate Lean 4 formal proof layer exists for the underlying claims.
What it does not proveThe runtime host was not re probed in either current audit pass, and the formal proof repository is not an operational endpoint. Formal proofs do not demonstrate that the deployed service behaves as proved.
Implementation state, from registry data
A live claim rests on an earlier audit and no current pass reached the host. Re probe before depending on it.
canon-source-of-truth-reconciliation.md section 4.5 records GET /v1/audit/pubkey live at hivetrust.hiveagentiq.com from a prior audit. canon-repository-live-service-audit.md sections 1 and 3.9 found no runtime service repository under this name; hive-trust-spec is a Lean 4 formal proof repository whose Lean Build CI passes, not an endpoint.
Canonical typeaudit.hashhistory
Schema URLnone published
Mint routeno mint route
Open verify routeGET https://hivetrust.hiveagentiq.com/v1/audit/pubkey no auth
Auth requirementPublic key read is open per the prior audit. Re probe before relying on it.
SourceFormal layer: public repository srotzin/hive-trust-spec (Lean 4). No runtime service repository identified.
Example requestGET https://hivetrust.hiveagentiq.com/v1/audit/pubkey
{
"method": "GET",
"url": "https://hivetrust.hiveagentiq.com/v1/audit/pubkey",
"auth": "none",
"body": null,
"note": "Not re probed in the current audit passes. Treat as claimed, not verified."
}
Not re probed in the current audit passes. Treat as claimed, not verified.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use caseshash chainhistory anchorappend only auditbyte for byte checksettlement anchor
Buyer fit illustrations, not customersKalshiICESnowflakeCircle
What it provesRegistry and manifest service with layers 1 to 4 active. It also carries its own zone based Imprimatur pre attestation gate, which is functionally distinct from the SiGR family imprimatur.clearance type.
What it does not proveIt has no working committed test infrastructure at the live commit, so no test evidence backs the deployed behaviour. Its Imprimatur gate is a third distinct meaning of that name and must not be conflated with the SiGR type or the concept page.
Implementation state, from registry data
A host outside this codebase answered a non mutating probe in a recorded audit session. Operational for that host only, not for this repository.
canon-repository-live-service-audit.md sections 3.5 and 5: GET https://passport.thehiveryiq.com/health and /v1/registry/manifest returned 200 with layers 1 to 4 active and layer 5 honestly reserved. Section 6 records that the repository's own npm test fails immediately because the declared tests directory does not exist.
Canonical typenone. this entry issues no receipt type
Schema URLnone published
Mint routeno mint route
Open verify routeGET https://passport.thehiveryiq.com/v1/registry/manifest no auth
Auth requirementHealth and manifest reads are open. Registry writes are gated by the service.
SourcePrivate repository srotzin/hive-passport. Not vendored into this repository.
Example requestGET https://passport.thehiveryiq.com/v1/registry/manifest
{
"method": "GET",
"url": "https://passport.thehiveryiq.com/v1/registry/manifest",
"auth": "none",
"body": null,
"note": "Layer 5 reports reserved. Do not read reserved as active."
}
Layer 5 reports reserved. Do not read reserved as active.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesissuer registrykey manifestzone clearancepassport layerstrust registry
Buyer fit illustrations, not customersCiscoCircleICESnowflake
What it provesPayment receipt and x402 settlement service for Spectral signed Base USDC receipts, on chain verification and MCP accessible receipt operations. It also hosts the live InkFrame verbs and the Carnac routing subsystem.
What it does not proveIt does not prove any customer volume, and it is a distinct host from the typed receipts API. Payment settlement is not a correctness claim about the work being paid for.
Implementation state, from registry data
A host outside this codebase answered a non mutating probe in a recorded audit session. Operational for that host only, not for this repository.
canon-repository-live-service-audit.md sections 3.3 and 5: GET https://inkframe.thehiveryiq.com/health returned 200, the live primitives smoke run was 9/9, hive-receipt.onrender.com serves the identical service, and the public srotzin/hive-receipt repository's own test run was 165 tests, 0 failed.
Canonical typereceipt.settlement
Schema URLnone published
Mint routePOST https://inkframe.thehiveryiq.com/v1/receipt/emit
Open verify routeGET https://inkframe.thehiveryiq.com/health no auth
Auth requirementHealth is open. Emission returns a real x402 payment_required challenge; x402 is the only payment rail.
SourcePublic repository srotzin/hive-receipt. Not vendored into this repository.
Example requestGET https://inkframe.thehiveryiq.com/v1/primitives/smoke
{
"method": "GET",
"url": "https://inkframe.thehiveryiq.com/v1/primitives/smoke",
"auth": "none",
"body": null,
"note": "The live primitives smoke route reports its own pass count. It was 9/9 at the audited session."
}
The live primitives smoke route reports its own pass count. It was 9/9 at the audited session.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesx402Base USDCstablecoin settlementagent paymentwallet intentactivation keyagentic commerce
Buyer fit illustrations, not customersCircleChimeRobinhoodFanDuelKalshi
What it provesContent addressed substrate for pre effect receipts: frame, prefill, cue edge, replay and countersign verbs over RFC 8785 JCS with SHA-256 and Ed25519 or ML-DSA-65.
What it does not proveIt is hosted inside Hive Receipt, not the typed receipts API, so its verbs must never be described as part of that API. Its source repository is private.
Implementation state, from registry data
A host outside this codebase answered a non mutating probe in a recorded audit session. Operational for that host only, not for this repository.
canon-repository-live-service-audit.md sections 3.3 and 3.9: the /v1/inkframe/* verbs are served live by hive-receipt at inkframe.thehiveryiq.com and the inkframe-core repository's own custom test runner passed 26/26 this session.
Canonical typeinkframe.v1
Schema URLnone published
Mint routePOST https://inkframe.thehiveryiq.com/v1/inkframe/frame
Open verify routeGET https://inkframe.thehiveryiq.com/health no auth
Auth requirementHealth and smoke reads are open. Frame writing is gated by the external service.
SourcePrivate repository srotzin/inkframe-core. Not vendored into this repository.
Example requestGET https://inkframe.thehiveryiq.com/health
{
"method": "GET",
"url": "https://inkframe.thehiveryiq.com/health",
"auth": "none",
"body": null,
"note": "InkFrame verbs live under /v1/inkframe/* on this host, not on the typed receipt service at thehiveryiq.com/v1."
}
InkFrame verbs live under /v1/inkframe/* on this host, not on the typed receipt service at thehiveryiq.com/v1.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casespre effect receiptcontent addressed framecue edgecountersignreplay
Buyer fit illustrations, not customersCirclePostmanCisco
What it provesA set of MCP relay services that forward tool calls to the real signer and passport hosts. All seven hosted health endpoints answered 200 in this probe, and their local test and smoke suites pass, including live upstream round trips.
What it does not proveA 200 on a health route proves the relay process is up and reachable at that host, not that every MCP tool call it forwards succeeds end to end, and not that any upstream primitive it calls is itself authenticated and production accepting. Probe the specific tool call you depend on before relying on it.
Implementation state, from registry data
A host outside this codebase answered a non mutating probe in a recorded audit session. Operational for that host only, not for this repository.
Re-probed live on 2026-08-04T21:07:00Z: GET returned 200 at https://hive-mcp-sigr.onrender.com/health, https://hive-mcp-spire.onrender.com/health, https://hive-mcp-imprimatur.onrender.com/health, https://hive-mcp-passport.onrender.com/health, https://hive-mcp-vault.onrender.com/health, https://hive-mcp-swap.onrender.com/health and https://hive-mcp-receipts.onrender.com/health, all seven of the current hive-mcp-* hosted relays. This supersedes the prior canon-repository-live-service-audit.md finding that five of six were unreachable. Local test and smoke runs for the relay repositories continue to pass, for example hive-mcp-sigr 20/20 and hive-mcp-spire 47/47.
Canonical typenone. this entry issues no receipt type
Schema URLnone published
Mint routeno mint route
Open verify routeGET https://hive-mcp-<name>.onrender.com/health for name in sigr, spire, imprimatur, passport, vault, swap, receipts no auth
Auth requirementHealth reads are open on all seven relays. Tool calls follow the MCP transport of each relay.
SourcePublic repositories srotzin/hive-mcp-sigr, hive-mcp-spire, hive-mcp-imprimatur, hive-mcp-passport, hive-mcp-vault, hive-mcp-swap, hive-mcp-receipts.
Example requestGET https://hive-mcp-sigr.onrender.com/health
{
"method": "GET",
"url": "https://hive-mcp-sigr.onrender.com/health",
"auth": "none",
"body": null,
"note": "All seven relays answered 200 on this probe. Re-probe the specific relay you depend on before a production integration, since this is a point in time health check, not a standing guarantee."
}
All seven relays answered 200 on this probe. Re-probe the specific relay you depend on before a production integration, since this is a point in time health check, not a standing guarantee.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesMCP servertool relayagent integrationmodel context protocol
Buyer fit illustrations, not customersPostmanCiscoSnowflakeFireworks
What it provesSigns media origin and rights evidence across human, AI, hybrid, unknown, insufficient evidence and disputed states, layered around C2PA. It records the origin evidence that was supplied.
What it does not proveIt does not decide truth from pixels, does not prove content is human made, and has no canonical schema file in this repository yet. It is a different primitive from origin.proof, which attests human production conditions.
Implementation state, from registry data
A host outside this codebase answered a non mutating probe in a recorded audit session. Operational for that host only, not for this repository.
canon-source-of-truth-reconciliation.md section 4.2: R1 layer live per the receipts.thehiveryiq.com status probe, with issue and verify routes present. No dedicated JSON Schema file is committed in this repository, which is an open authoring gap.
Canonical typemedia.origin
Schema URLnone published
Mint routePOST https://receipts.thehiveryiq.com/v1/receipt/emit
Open verify routePOST https://receipts.thehiveryiq.com/v1/receipt/verify no auth
Auth requirementEmission is gated by the external service and returns a real x402 payment_required challenge. Verification is open.
SourceExternal service. Source lives in the private srotzin/hivemorph repository.
Example requestGET https://receipts.thehiveryiq.com/status
{
"method": "GET",
"url": "https://receipts.thehiveryiq.com/status",
"auth": "none",
"body": null,
"note": "Confirm the R1 layer reports live before relying on the emit and verify routes. No canonical schema file exists in this repository for this type yet."
}
Confirm the R1 layer reports live before relying on the emit and verify routes. No canonical schema file exists in this repository for this type yet.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesmedia provenanceC2PAdeepfake disputerights evidencecontent authenticityaudio origin
Buyer fit illustrations, not customersFanaticsFish AudioCartesiaCircle
What it provesCommercial action layer above R3Pv. Packages receipt emission, grouping, signed proof vectors, healing state and evidence export for recoverability aware flows. Layers R3 and R4 are live.
What it does not proveIt does not prove any customer deployment, and its backend source is not vendored into this repository. Fleet scale bulk operation is a wrapper concept, not a separately verified endpoint.
Implementation state, from registry data
A host outside this codebase answered a non mutating probe in a recorded audit session. Operational for that host only, not for this repository.
canon-source-of-truth-reconciliation.md section 4.2: R3 delegation envelopes and R4 tool firewall layers confirmed live on receipts.thehiveryiq.com during that session's status probe.
Canonical typeflow.protection
Schema URLnone published
Mint routeno mint route
Open verify routeGET https://receipts.thehiveryiq.com/status no auth
Auth requirementStatus read is open. Flow operations are gated by the external service.
SourceExternal service. Source lives in the private srotzin/hivemorph repository.
Example requestGET https://receipts.thehiveryiq.com/status
{
"method": "GET",
"url": "https://receipts.thehiveryiq.com/status",
"auth": "none",
"body": null,
"note": "Read the layer table and confirm R3 and R4 report live before making any claim."
}
Read the layer table and confirm R3 and R4 report live before making any claim.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casestool firewalldelegation envelopehealing stateevidence exporthigh risk workflowCircle Gatewaycrosschain USDCerc1271ERC-1271
Buyer fit illustrations, not customersCircleCiscoChimeRobot.com
What it provesReduces a group of signed receipts into a signed machine readable decision vector: proof state, recoverability, policy position, economic exposure and permitted next actions. Layers R1 to R9 are live.
What it does not proveIt does not prove the underlying business decision was correct, and layers R10 to R12 are roadmap and must never be presented as live. The backend source is not vendored into this repository, so this page cannot show a repository level implementation state for it.
Implementation state, from registry data
A host outside this codebase answered a non mutating probe in a recorded audit session. Operational for that host only, not for this repository.
canon-repository-live-service-audit.md section 5: GET https://receipts.thehiveryiq.com/status returned 200 with a commit SHA matching the cloned hivemorph HEAD; canon-source-of-truth-reconciliation.md section 4.2 confirms layers R1 to R9 live and R10 to R12 roadmap.
Canonical typereceipt.reduction
Schema URLnone published
Mint routeno mint route
Open verify routeGET https://receipts.thehiveryiq.com/status no auth
Auth requirementStatus read is open. Receipt emission through this host is gated by its own service policy, not by this repository.
SourceExternal service. Source lives in the private srotzin/hivemorph repository, not in this repository.
Example requestGET https://receipts.thehiveryiq.com/status
{
"method": "GET",
"url": "https://receipts.thehiveryiq.com/status",
"auth": "none",
"body": null,
"note": "Non mutating status read. Layer states R1 to R9 live and R10 to R12 roadmap are reported by the service itself."
}
Non mutating status read. Layer states R1 to R9 live and R10 to R12 roadmap are reported by the service itself.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesreceipt reductionrecoverabilityrisk vectorportfolio of receiptsincident recoveryrobot fleet recoveryCircle Gatewaycrosschain USDCerc1271ERC-1271
Buyer fit illustrations, not customersCircleKalshiCiscoRobot.comAIUCChime
What it provesFixed six hop outbound chain of custody discrimination receipt: six independent checks screen an outbound action before it leaves the boundary.
What it does not proveIts live status was not re probed in either current audit pass and no source repository was identified for the runtime service.
Implementation state, from registry data
A live claim rests on an earlier audit and no current pass reached the host. Re probe before depending on it.
canon-source-of-truth-reconciliation.md section 4.5 carries the same not re probed caveat as SMSH. No probe of this host appears in canon-repository-live-service-audit.md section 5.
Canonical typediscrimination.sixhop
Schema URLnone published
Mint routeno mint route
Open verify routeno open verify route
Auth requirementUnknown until re probed. Do not quote an auth model for this service.
SourceExternal service. No source repository identified in the repository audit.
Example requestGET /canon/shod/
{
"method": "GET",
"url": "/canon/shod/",
"auth": "none",
"body": null,
"note": "Read the site page. Re probe the host before treating SHOD as an operational dependency."
}
Read the site page. Re probe the host before treating SHOD as an operational dependency.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesoutbound screeningpayment pre checkchain of custodysix hop checksanctions screening
Buyer fit illustrations, not customersCircleChimeRobinhoodCisco
What it provesSeals a message state hash for later independent verification. The verifier library is real, public and tested.
What it does not proveThere is no standalone hosted service for it; the library is consumed as a dependency. Its hosted claim was not re probed in either current audit pass.
Implementation state, from registry data
A live claim rests on an earlier audit and no current pass reached the host. Re probe before depending on it.
canon-source-of-truth-reconciliation.md section 4.5 marks SMSH live claimed but explicitly not re probed, with independently_reprobed_this_session false. canon-repository-live-service-audit.md section 3.9 confirms the smsh-stamp-verifier library repository passed 69/69 vitest tests with 92.4 percent statement coverage and has no standalone host.
Canonical typemessage.sealedstate
Schema URLnone published
Mint routeno mint route
Open verify routeno open verify route
Auth requirementLibrary use requires no auth. No hosted route was verified in the current passes.
SourcePublic repositories srotzin/smsh-stamp-verifier and srotzin/prov-absence.
Example requestGET /smsh/
{
"method": "GET",
"url": "/smsh/",
"auth": "none",
"body": null,
"note": "Library first primitive. Read the site page, then use the public smsh-stamp-verifier library rather than assuming a hosted route."
}
Library first primitive. Read the site page, then use the public smsh-stamp-verifier library rather than assuming a hosted route.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesmessage sealingnon membership proofsorted Merklestate hashabsence proof
Buyer fit illustrations, not customersCiscoCircleSnowflake
What it provesOffline reference implementation of a Schnorr and Merkle zero knowledge proof scheme. Anyone can verify a sample proof locally with no network and no key material.
What it does not proveThere is no hosted verify route for it. It is a reference implementation, not a production service, and no benchmark of a hosted deployment exists.
Implementation state, from registry data
Runnable code with no hosted route. Verifiable locally, not a service.
canon-source-of-truth-reconciliation.md section 4.5: canon/spectralzk/spectralzk_v1.py is a 404 line runnable offline reference implementation with a committed schema at .well-known/schemas/spectralzk-v1.json.
Canonical typezk.spectral
Mint routepython3 canon/spectralzk/spectralzk_v1.py prove
Open verify routepython3 canon/spectralzk/spectralzk_v1.py verify sample-proof.json no auth
Auth requirementNone. It runs locally and offline.
Sourcecanon/spectralzk/spectralzk_v1.py in this repository.
Example requestCLI python3 canon/spectralzk/spectralzk_v1.py verify canon/spectralzk/sample-proof.json
{
"method": "CLI",
"url": "python3 canon/spectralzk/spectralzk_v1.py verify canon/spectralzk/sample-proof.json",
"auth": "none",
"body": null,
"note": "Offline verification. No hosted route exists and none should be implied."
}
Offline verification. No hosted route exists and none should be implied.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use caseszero knowledge proofoffline verificationSchnorrMerkleprivacy preserving check
Buyer fit illustrations, not customersCircleCiscoICESnowflake
What it provesThe shared ML-DSA-65 signing and verification core. It is a signing engine, not a receipt type.
What it does not proveIt is not itself a receipt contract and must never be counted as one. POST /v1/imprimatur/gate returned 404 on this host, so an Imprimatur clearance backend is not live here. Which host is canonical for which capability, this one or the typed receipt service at thehiveryiq.com/v1, is still not documented on the site.
Implementation state, from registry data
A host outside this codebase answered a non mutating probe in a recorded audit session. Operational for that host only, not for this repository.
canon-repository-live-service-audit.md sections 3.1 and 5: GET https://signer.thehiveryiq.com/ and /pubkey returned 200 with an ML-DSA-65 key matching hive-typed-signer.onrender.com byte for byte; the public source repository srotzin/hive-typed-signer exists and its own test run was 9 files, 0 failed.
Canonical typenone. this entry issues no receipt type
Schema URLnone published
Mint routeno mint route
Open verify routeGET https://signer.thehiveryiq.com/pubkey no auth
Auth requirementPublic key and health reads are open. Signing operations are gated by the service.
SourcePublic repository srotzin/hive-typed-signer. Not vendored into this repository.
Example requestGET https://signer.thehiveryiq.com/pubkey
{
"method": "GET",
"url": "https://signer.thehiveryiq.com/pubkey",
"auth": "none",
"body": null,
"note": "The returned ML-DSA-65 key should match hive-typed-signer.onrender.com exactly. A mismatch means one of the two hosts drifted."
}
The returned ML-DSA-65 key should match hive-typed-signer.onrender.com exactly. A mismatch means one of the two hosts drifted.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesML-DSA-65 signingpost quantum signaturekey rotationsigner coreQPuF info
Buyer fit illustrations, not customersCerebrasFireworksCiscoCircle
What it provesSelective disclosure and compliance certificate layer over receipts, with priced verification routes, so a holder, a regulator and a counterparty each read their own slice of one signed record.
What it does not proveIts live status rests on a prior audit only. No probe of hivetrust.hiveagentiq.com appears in the two current audit passes, so it must not be presented as freshly verified.
Implementation state, from registry data
A live claim rests on an earlier audit and no current pass reached the host. Re probe before depending on it.
canon-source-of-truth-reconciliation.md section 4.5 records a live priced API at hivetrust.hiveagentiq.com with per call USDC pricing, based on a prior audit. That host was not independently re probed in the reconciliation session or in canon-repository-live-service-audit.md section 5.
Canonical typeviewkey.disclosure
Schema URLnone published
Mint routePOST https://hivetrust.hiveagentiq.com/v1/viewkey/issue-certificate
Open verify routePOST https://hivetrust.hiveagentiq.com/v1/viewkey/verify-compliance no auth
Auth requirementPriced per call in USDC per the prior audit. Re probe before quoting a price or a route.
SourceExternal service. No source repository was identified in the repository audit.
Example requestGET https://hivetrust.hiveagentiq.com/
{
"method": "GET",
"url": "https://hivetrust.hiveagentiq.com/",
"auth": "none",
"body": null,
"note": "Re probe this host before making any live claim. The two current audit passes did not reach it."
}
Re probe this host before making any live claim. The two current audit passes did not reach it.
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesselective disclosurecompliance certificateregulator viewbill of materialsaudit trail
Buyer fit illustrations, not customersCiscoSnowflakeCircleICEChime
Product or composite system, 9 entries
What it provesNothing on its own. It aggregates other services' views.
What it does not proveIt has no API of its own, and the verifier repository it points engineers toward is a stub, not a working verifier.
Implementation state, from registry data
A wrapper over other entries. No route, no schema, no receipt type.
canon-source-of-truth-reconciliation.md section 4.6 found no console specific API. canon-repository-live-service-audit.md section 3.7 found that the public HAHS verifier repository it references, srotzin/hive-verifier, is an explicit placeholder stub with a declared test script but zero test files.
Canonical typenone. this entry issues no receipt type
Schema URLnone published
Mint routeno mint route
Open verify routeno open verify route
Auth requirementNot applicable.
SourcePages under app/ in this repository. Referenced repository srotzin/hive-verifier is a placeholder stub.
Example requestwithheld. nothing about this entry is disclosed publicly
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesdashboardconsoleaggregation view
Buyer fit illustrations, not customersCiscoSnowflake
Partner and use case pagesnone yet
What it provesNothing on its own. It presents ledger style views over other primitives' receipts.
What it does not proveIt issues no receipt type and has no endpoint of its own.
Implementation state, from registry data
A wrapper over other entries. No route, no schema, no receipt type.
canon-source-of-truth-reconciliation.md section 4.6: the page now exists on disk, resolving a prior broken link, but it remains a composite ledger surface rather than a receipt issuing primitive.
Canonical typenone. this entry issues no receipt type
Schema URLnone published
Mint routeno mint route
Open verify routeno open verify route
Auth requirementNot applicable.
SourcePages under hive-ledger/ in this repository.
Example requestwithheld. nothing about this entry is disclosed publicly
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesledger viewreceipt accountingeconomic evidence
Buyer fit illustrations, not customersCircleChimeSnowflake
What it provesNothing on its own. It is a proposed segment level check on top of a valid parent Media Origin Receipt.
What it does not proveNo code, schema or endpoint exists. If ever built it would be a child object of media.origin, never a new top level type.
Implementation state, from registry data
A proposed extension of another entry. No code, schema or endpoint.
canon-source-of-truth-reconciliation.md section 4.2: a segment level extension of Media Origin Receipt with no distinct code, schema or endpoint found.
Canonical typenone. this entry issues no receipt type
Schema URLnone published
Mint routeno mint route
Open verify routeno open verify route
Auth requirementNot applicable.
SourceNo implementation found.
Example requestwithheld. nothing about this entry is disclosed publicly
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesexcerpt integritysplice detectionsegment provenanceclip verification
Buyer fit illustrations, not customersFanaticsFish Audio
What it provesNothing on its own. It converts other primitives' proof state into risk and underwriting signals.
What it does not proveIt is not a receipt type, has no endpoint, and no underwriting relationship or insurance outcome is proven anywhere.
Implementation state, from registry data
A wrapper over other entries. No route, no schema, no receipt type.
canon-source-of-truth-reconciliation.md section 4.6: positioned as proof state evidence for underwriting, consuming other primitives' receipts, not a new receipt type.
Canonical typenone. this entry issues no receipt type
Schema URLnone published
Mint routeno mint route
Open verify routeno open verify route
Auth requirementNot applicable.
SourcePages under proof-credit/ in this repository.
Example requestwithheld. nothing about this entry is disclosed publicly
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesunderwriting signalrisk scoringinsurance evidenceeconomic exposure
Buyer fit illustrations, not customersAIUCChimeCircle
What it provesNothing beyond Protected Flow. It is an organizational wrapper for many flows.
What it does not proveNo bulk or fleet endpoint was confirmed, so it is not a separate primitive and must not be counted as one.
Implementation state, from registry data
A wrapper over other entries. No route, no schema, no receipt type.
canon-source-of-truth-reconciliation.md sections 4.2 and 4.6: an enterprise container organizing many Protected Flows, with no independent bulk endpoint confirmed. It collapses into Protected Flow.
Canonical typenone. this entry issues no receipt type
Schema URLnone published
Mint routeno mint route
Open verify routeno open verify route
Auth requirementNot applicable. Inherits Protected Flow's model.
SourcePages under protected-flow-fleets/ in this repository.
Example requestwithheld. nothing about this entry is disclosed publicly
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesfleet managementbusiness unit groupingmany flowsenterprise rollout
Buyer fit illustrations, not customersCiscoCircleRobot.com
What it provesNothing on its own. It applies existing primitives to robotics and machine autonomy.
What it does not proveThere is no machines specific endpoint, schema or receipt type. Robot deployments are not proven anywhere in this repository.
Implementation state, from registry data
A wrapper over other entries. No route, no schema, no receipt type.
canon-source-of-truth-reconciliation.md section 4.6: composes R3Pv and Protected Flow for the robotics and robot as a service vertical, with no distinct /v1/machines/* API surface confirmed.
Canonical typenone. this entry issues no receipt type
Schema URLnone published
Mint routeno mint route
Open verify routeno open verify route
Auth requirementNot applicable. Use the underlying primitives' auth model.
SourcePages under machines/ and robotics/ in this repository.
Example requestwithheld. nothing about this entry is disclosed publicly
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesrobotroboticsautonomous machineteleoperationrobot as a servicefleet autonomyindustrial automation
Buyer fit illustrations, not customersKodiak RoboticsRobot.comCisco
What it provesNothing. It draws an agent moving across model, provider, tool, verification and payment stops.
What it does not proveIt issues no receipts, has no repository and has no route. Exclude it from every primitive count.
Implementation state, from registry data
A drawing of other primitives' receipts. Issues nothing.
canon-source-of-truth-reconciliation.md section 4.4 records it self describing as a visualization product, not a receipt issuing primitive. canon-repository-live-service-audit.md section 1 found no repository under SmartAgent or SmartMorphAgent and no live route.
Canonical typenone. this entry issues no receipt type
Schema URLnone published
Mint routeno mint route
Open verify routeno open verify route
Auth requirementNot applicable.
SourceNo repository found under SmartAgent or SmartMorphAgent.
Example requestwithheld. nothing about this entry is disclosed publicly
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesvisualizationagent route mapexplainer
Partner and use case pagesnone yet
What it provesNothing. They define units of measure used when describing receipt volumes and workloads.
What it does not proveThey are definitional pages only and must be excluded permanently from any primitive count, even though they live under /canon/.
Implementation state, from registry data
Definitional content. Not a primitive.
canon-source-of-truth-reconciliation.md section 4.5: direct reads confirm these four pages are unit of measure glossary content, for example standard data units, not receipt issuing primitives.
Canonical typenone. this entry issues no receipt type
Schema URLnone published
Mint routeno mint route
Open verify routeno open verify route
Auth requirementNot applicable.
SourcePages under canon/sdu/, canon/sgu/, canon/spu/ and canon/svu/ in this repository.
Example requestwithheld. nothing about this entry is disclosed publicly
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesunits of measureglossarypricing unitscapacity planning
Partner and use case pagesnone yet
What it provesNothing on its own. It is an umbrella suite name over seven sub brands.
What it does not proveIt is not a receipt type, has no independent endpoint, and must never be counted in a primitive total. Each sub leg would need its own mint and verify pair to count.
Implementation state, from registry data
A wrapper over other entries. No route, no schema, no receipt type.
canon-source-of-truth-reconciliation.md section 4.6: seven sub brands have pages on disk, MEMBRANE, PROOF and QUORUM self gate as private until they ship, and no independent backend endpoint was confirmed for ATTEST, DELTA, ECHO or VERIFY. canon-repository-live-service-audit.md section 1 found only a pre registration methodology repository, xcalibur-evaluation, not an implementation.
Canonical typenone. this entry issues no receipt type
Schema URLnone published
Mint routeno mint route
Open verify routeno open verify route
Auth requirementNot applicable. There is no endpoint.
SourcePages under xcalibur/ in this repository. Methodology repository srotzin/xcalibur-evaluation.
Example requestwithheld. nothing about this entry is disclosed publicly
Benchmark, none shown
No benchmark is shown because none was measured against a verified deployment of this entry in a recorded session.
Use casesevaluation suiteproduct suiteumbrella brand
Buyer fit illustrations, not customersAIUCSnowflakeCerebras
Related canon entriesevar
Filing gated private work, 1 entry
What it provesNothing is disclosed here. Public disclosure of this work is gated on a provisional filing that is not confirmed.
What it does not proveIt proves nothing publicly and must not be presented as a public capability, a schema, a route or a benchmark until the filing posture changes.
Implementation state, from registry data
Deliberately undisclosed until a provisional filing is confirmed. Listed by name only.
hive-verifier-api/src/typed/honesty-contracts-registry.js lists this type in INTERNAL_ONLY_CONTRACTS, not in HONESTY_CONTRACTS, so the service generates no public route for it and no schema file is published for it.
Source disagreement on recordcanon-46-independent-review.md finding 1.1 required this contract to stay off every public surface until a provisional filing is confirmed. It is listed here as a named placeholder with no schema URL, no routes, no example request and no benchmark, so the count cannot silently drift, and nothing about its shape is disclosed.
Canonical typeafir.ocr.docproof
Schema URLnone published
Mint routeno mint route
Open verify routeno open verify route
Auth requirementNot applicable. There is no public route.
SourcePrivate. Not published.
Example requestwithheld. nothing about this entry is disclosed publicly
Benchmark, none shown
Benchmark numbers for filing gated work are withheld deliberately.
Use casesdocument extraction provenanceOCR receiptprivate reduction to practice
Related canon entriesafir
Partner and use case pagesnone yet