Related · tier-1 reading. For what a portable artifact actually is, see Portable Artifact.
API tokens in .env files. SSH keys on disk. Database passwords in config. JWT signing secrets in systemd unit files. Stripe sk_live keys handed to thirty engineers via a Slack thread. Every key in your infrastructure sits one credential dump from catastrophic compromise — and once they leak, every subsequent use is indistinguishable from legitimate traffic.
H33-Key is not secret storage. It is authority control.
Storage asks: Where is the key?
H33-Key asks: What is this key allowed to do, under what state, for how long, for whom — and can every use be independently replayed?
Available now · Node + Rust SDKs + hkey CLI
Most API key infrastructure is fundamentally broken.
Static secrets sitting in config files holding state secrets. Manual rotations — what century are we in? Global authority scopes with no replayability if something goes wrong. No proof of misuse. No cryptographic continuity across rotations. That model does not survive AI-scale systems or post-quantum threat environments — and quite frankly, it sucks without AI or quantum threats.
When the inevitable leak happens, the existing playbook is: rotate everything by hand on a Saturday, hope nothing was used, and accept that the audit trail is a centralized narrative you cannot independently verify.
So we fixed it. Because we can.
Every primitive is independently verifiable, post-quantum attested, and composable with the others. None of them require trusting H33’s narrative about what happened.
Q-Key authority issue + H33-74 receipt + negative-proof check + replay-corpus commit — all under half a millisecond. Light enough to wrap every Stripe call, every JWT sign, every database write.
Stripe’s API server requires sk_live_… in plaintext. Twilio requires plaintext. Google OAuth requires plaintext. They don’t speak Q-Key. Anyone claiming to FHE-wrap a Stripe charging key is selling theater — the decryption point still has to happen at call time.
So we drew a hard, honest line through the credential surface:
The honesty is the differentiator. Vendors that overclaim get caught at audit time. H33-Key tells you which credentials are mathematically protected and which are operationally protected — and why the distinction matters.
Every other key-management vendor asks you to trust their dashboard. H33-Key publishes the conformance specification — your auditor, your insurer, your regulator, or a competing implementation can build their own verifier and reconstruct any authority decision from the 74-byte receipts alone.
This is what “replay-grade attestation” actually means: not a log file H33 promises is real, but a cryptographic corpus that any independently competent party can verify without us.
No big bang. No enforcement before you understand what it would deny. No leaving an audit gap when you start.
observe mode. Every authority issue, attest, verify, and deny decision is logged with its full 74-byte receipt — but no upstream call is ever blocked. After a week, you have a complete shadow record of what would have been denied, rotated, scoped, or flagged. Tune the policy. No risk to production.enforce. Authority objects now block out-of-scope uses cryptographically. The receipt corpus is the same one you built in observe mode — no audit discontinuity. Roll forward and back as needed; per-tenant, per-route, per-computation granularity means no all-or-nothing flag.Node + Rust SDKs ship at GA. Python and Go follow. The hkey CLI is the same surface from your terminal — issue, attest, verify, observe, revoke, replay.
import { HKey } from '@h33/key'; const hkey = new HKey({ apiKey: process.env.H33_KEY }); // 1. Issue a time-bound, scope-bound, computation-bound authority object const auth = await hkey.issue({ computation: 'stripe.charge', scope: { tenant: 'h33', amount_max_usd: 5000 }, ttl: '15m', }); // 2. Use it. Every use emits a 74-byte H33-74 receipt. const { result, receipt } = await hkey.attest(auth, async (key) => { return stripe.charges.create({ amount: 4200, source: 'tok_...' }, key); }); // 3. Independent verifier — anyone can replay. const ok = await hkey.verify(receipt); console.log(receipt.bytes.length, ok); // 74, true
use h33_key::{HKey, IssueRequest, Scope, Duration}; let hkey = HKey::from_env()?; // Issue a time-bound, scope-bound authority object let auth = hkey.issue(IssueRequest { computation: "stripe.charge", scope: Scope::new().tenant("h33").amount_max_usd(5000), ttl: Duration::minutes(15), }).await?; // Use it. Every use emits a 74-byte H33-74 receipt. let (result, receipt) = hkey.attest(&auth, |key| async move { stripe::charges::create(&key, 4200, "tok_...").await }).await?; // Independent verifier — anyone can replay. assert!(hkey.verify(&receipt).await?);
$ hkey issue --computation stripe.charge \ --scope tenant=h33,amount_max_usd=5000 \ --ttl 15m auth_01h_x9p2qm8c7v3kfn5tg6d2yr8bw0... $ hkey attest auth_01h_x9p2qm... -- stripe charges create --amount 4200 receipt: 0xab12cf... (74 bytes) verified: ok $ hkey verify 0xab12cf... ok — issued 2026-05-25T03:14:00Z, used 2026-05-25T03:14:02Z, scope=stripe.charge[tenant=h33], anomalies=0 $ hkey observe --window 1h --tenant h33 would-have-denied: 3 (2 wrong-tenant, 1 expired authority) attested-ok: 1,847 anomalies-flagged: 0
npm install to your first attested authority.No infrastructure to deploy. No agents to install. Start in observe mode — no enforcement until you flip the switch.
Every secrets manager on the market decrypts the key before handing it to you. H33-Key doesn’t.
TEE proxy — your infrastructure never touches plaintext. Your app sends an encrypted key + request. Gateway decrypts inside a Trusted Execution Environment, forwards the API call to the third-party service, zeroes the plaintext, and returns the response. At no point does your infrastructure — or ours — see the key in the clear.
Both sides integrate the H33 SDK. BFV fully homomorphic encryption compares the key without decrypting it — not even inside a TEE. The plaintext key never exists anywhere during verification. This is the endgame: zero-exposure at the mathematical level.
Key-FHE requires both parties to integrate the H33 SDK. We position it honestly as the future — the highest-security option for organizations willing to coordinate with their partners.
Rotation is table stakes. Revocation proofs are not. Every authority that retires leaves a cryptographic gravestone — provable death, with a window of negative-proof coverage on either side. Receipts persist across rotations.
Every layer of H33-Key is designed to protect key material against both classical and quantum threats.
Post-quantum key encryption for every infrastructure pattern.
Volume-tiered pricing — standardized across the H33 platform.
See pricing →| H33-Key | AWS KMS | HashiCorp Vault Transit | Azure Key Vault | |
|---|---|---|---|---|
| Post-quantum encryption | Kyber-1024 (NIST) | — | — | — |
| Latency | < 0.5ms | 5–15ms | 2–8ms | 10–25ms |
| Migration required | None — transparent layer | Full integration | Complex setup | SDK integration |
| Vendor lock-in | None | AWS-only | — | Azure-only |
| Threshold decryption (k-of-n) | Key-3 | — | — | — |
| Dilithium-signed provenance | Key-3 | — | — | — |
| Zero-exposure infrastructure | Key-Gateway (TEE proxy) | — | — | — |
| FHE key verification | Key-FHE | — | — | — |
All units fungible — same balance as H33-Auth, H33-Vault, H33-Share, H33-Shield, and H33-Health.
sk_live_… that can do anything, your service holds an authority object that can only do exactly the operations it was issued for, only within its declared scope, only inside its TTL window. Misuse is cryptographically detectable, not just policy-flagged.74 bytes total, anchored across three independent post-quantum signature families (ML-DSA-65, FALCON-512, SPHINCS+-SHA2-128f). The receipt cryptographically commits to which authority was used, for which computation, against which counterparty, at which timestamp. Independent verifiers (yours, your auditor's, your insurer's) can reconstruct the action from the receipt alone, without trusting H33's narrative about what happened.observe mode for any time window. It shadows every authority decision — issue, attest, verify, deny — and produces a report of what would have been denied, rotated, scoped, or flagged. You see the consequences of a policy before paying for them. Adoption path: observe (no enforcement) → enforce (deny outside scope) → replay (independent reconstruction of any past action).JWT_SECRET v1 inside its valid window remains independently verifiable forever, even after v2, v3, v4 replace it. Rotation generates a continuity proof linking the old authority to the new, so the audit trail does not break across rotations. This is what cryptographic continuity means: rotations do not destroy verifiability, they extend it.observe mode. Every authority issue, attest, verify, and deny is logged with a receipt, but no decision is enforced upstream. After a week or two, review the would-have-denied report and tighten scopes. Then flip to enforce mode. The same receipt corpus is valid in both modes — the only thing that changes is whether the deny decision blocks the call or only flags it.hkey.issue() creates a new time-bound, scope-bound authority object; hkey.attest() wraps a call so every use emits a 74-byte receipt; hkey.verify() runs the independent verifier against a receipt; hkey.observe() shadow-runs policy without enforcing. Language SDKs ship for Node.js and Rust day one (Python second). The hkey CLI is the same surface from the terminal — issue, attest, verify, observe, revoke, replay. Designed so an SRE can run any operation by hand and a service can run the same operation programmatically.hkey CLI, and start in observe mode immediately. Pricing tiers run from Key-0 (basic authority issue plus attested audit log) through Key-FHE (homomorphic verification with both-sides SDK integration). Volume-tiered pricing standardized at the H33 pricing page.The Manifesto
Most API key infrastructure is fundamentally broken.
We literally have static secrets sitting in config files holding state secrets.
Manual rotations? What century are we in?
Global authority scopes? No replayability if something goes wrong?
No proof of misuse? No cryptographic continuity?
That model does not survive AI-scale systems or post-quantum threat environments — and quite frankly sucks terribly without AI or quantum threats.
So we fixed it. Because we can.
The future is not “better secret storage.”
The way it should be: verifiable authority infrastructure where every sensitive action can be independently reconstructed, attested, replayed, and audited without trusting a centralized narrative about what happened.
That’s what we built with Q-Key, H33-74, Agent Zero, and our replayable governance infrastructure.
This is grouped under our H33-Key product — available now.
Free tier includes 1,000 attested operations. No credit card. Observe mode available immediately — no enforcement until you flip the switch.