⊗ QUBE-QX-2 · Post-Quantum · NIST PQC Compliant

Quantum-Proof Encryption
as an API. Ship in minutes.

ML-KEM-1024 key encapsulation + dual AES/ChaCha20 cipher + SLH-DSA signatures + BLAKE3 integrity + IBM Quantum true random entropy. One endpoint. Every algorithm.

Get API Key → View Code
ML-KEM-1024 SLH-DSA-SHAKE-256f BLAKE3-256 AES-256-GCM ChaCha20-Poly1305 HKDF-SHA3-512 IBM Quantum QRNG

⊗ 7-Stage Pipeline

Every packet runs the full QUBE stack

No cherry-picking. Every encrypt call traverses all seven stages — quantum entropy to post-quantum signature — in under 80 ms.

QUBE packet · live preview
⊗ qube::titan |ψ⟩↦⟨φ| session::generating... { @version TITAN-QUBE-QX-2.0 @epoch_ms ... @entropy_src ibm_quantum:ibm_kingston // ── Stage 1: Quantum Entropy entropy 0x4a7f3c... // ── Stage 2: ML-KEM-1024 kem_algo ML-KEM-1024 kem_ct_b64 Fg7hQZ... // ── Stage 3: HKDF-SHA3-512 kdf_algo HKDF-SHA3-512 kdf_info TITAN-QUBE-QX-2.0/session-keys // ── Stage 4: Dual Cipher cipher_outer AES-256-GCM cipher_inner ChaCha20-Poly1305 iv_a_b64 nK9x2P... nonce_b_b64 rJ4mT8... ciphertext_b64 hG3kWs9... // ── Stage 5: BLAKE3-256 Integrity integrity_algo BLAKE3-256 integrity_hash a3f7c2... // ── Stage 6: SLH-DSA Signature sig_algo SLH-DSA-SHAKE-256f sig_b64 X9pLqR... sig_pk_b64 mZ4kW7... // ── Stage 7: TITAN Seal seal_ts 2026-05-14T... seal_version TITAN-QUBE-QX-2.0 ⊘ qube::seal |ℋ⟩ }
1
Quantum Entropy Harvest
True random seed from IBM Kingston (156-qubit Heron r2). CSPRNG mix for determinism during fallback.
IBM Quantum QRNG · OpenQASM 3.0
2
KEM Encapsulation
ML-KEM-1024 encapsulates a shared secret with the recipient's public key. Quantum-safe key exchange.
ML-KEM-1024 · NIST FIPS 203
3
Key Derivation
HKDF over SHA3-512 expands the shared secret into two independent 256-bit cipher keys.
HKDF-SHA3-512 · 2× 256-bit output
4
Dual Cipher Encryption
Inner ChaCha20-Poly1305 encrypted by outer AES-256-GCM. Breaking one cipher leaves the other intact.
AES-256-GCM ⊗ ChaCha20-Poly1305
5
BLAKE3 Integrity
256-bit integrity hash over all packet fields. Any tampering is detectable before decryption.
BLAKE3-256 · authenticated
6
Post-Quantum Signature
SLH-DSA-SHAKE-256f signs the integrity hash. Hash-based signature — secure against quantum Grover.
SLH-DSA-SHAKE-256f · NIST FIPS 205
7
QUBE Packet Seal
All fields wrapped in a structured QUBE envelope with quantum math notation. Parseable by any client.
QUBE-QX-2.0 · ⊗ |ψ⟩ ↦ ⟨φ| ⊘ |ℋ⟩

⊗ Built for Builders

Everything a secure app needs

⚛
NIST PQC Compliant
ML-KEM-1024 and SLH-DSA-SHAKE-256f are the finalized NIST post-quantum standards. Future-proof today.
FIPS 203 / FIPS 205
🔀
Hybrid Classical + PQC
AES-256-GCM and ChaCha20 run alongside quantum algorithms. Best of both worlds — no migration needed.
Defense in Depth
🎲
IBM Quantum Entropy
Real quantum randomness from ibm_kingston (156-qubit Heron r2). Mixed with CSPRNG for guaranteed availability.
QRNG · OpenQASM 3.0
🔑
Keypair Generation
One endpoint generates fresh ML-KEM-1024 + SLH-DSA keypairs. Rotate keys with a single API call.
POST /api/titan/keygen
⚡
Serverless Edge Speed
Deployed on Netlify Functions with esbuild bundling. Sub-100 ms cold start. Global edge distribution.
Netlify · CDN Edge
🧬
QUBE Packet Format
Structured, human-readable output using quantum notation. Every field labeled, every algorithm declared. Auditable forever.
⊗ |ψ⟩ ↦ ⟨φ| ⊘ |ℋ⟩

⊗ Pricing

Choose your tier

All tiers include the full QUBE-QX-2 pipeline. Upgrade or downgrade any time.

⊗ SPARK
$9/mo
100 calls per month
  • Full QUBE-QX-2 pipeline
  • ML-KEM-1024 + SLH-DSA
  • BLAKE3 integrity
  • CSPRNG entropy
  • JSON + QUBE packet output
  • Email API key delivery
Get Spark Key →
⊗ CORE
$29/mo
1,000 calls per month
  • Everything in Spark
  • IBM Quantum QRNG entropy
  • Keypair rotation endpoint
  • Usage dashboard
  • Priority support
  • Monthly usage reports
Get Core Key →
⊗ FORGE
$99/mo
10,000 calls per month
  • Everything in Core
  • Priority IBM Quantum queue
  • Multiple API keys
  • Webhook delivery of packets
  • Custom QUBE extensions
  • SLA 99.9% uptime
Get Forge Key →
⊗ SOVEREIGN
$499/mo
Unlimited calls
  • Everything in Forge
  • Dedicated IBM Q allocation
  • On-prem deployment option
  • Custom algorithm extensions
  • White-glove onboarding
  • Direct engineering access
Go Sovereign →

⊗ REVENUE DISTRIBUTION · Every Transaction

40% Mother AI Operations 30% Warren 20% Reinvestment 10% Donation

⊗ Quickstart

Three calls to quantum-proof encryption

// 1. Generate a keypair (store securely) const keysRes = await fetch('https://aeonmi.netlify.app/api/titan/keygen', { method: 'POST', headers: { 'X-Titan-Key': 'titan_sk_your_api_key', 'Content-Type': 'application/json' } }); const { kem, sig } = await keysRes.json(); // 2. Encrypt a payload const encRes = await fetch('https://aeonmi.netlify.app/api/titan/encrypt', { method: 'POST', headers: { 'X-Titan-Key': 'titan_sk_your_api_key', 'Content-Type': 'application/json' }, body: JSON.stringify({ payload: '{"message":"hello quantum world"}', kemPublicKey: kem.publicKey }) }); const { qube_packet } = await encRes.json(); // ⊗ qube::titan |ψ⟩↦⟨φ| ... // 3. Decrypt const decRes = await fetch('https://aeonmi.netlify.app/api/titan/decrypt', { method: 'POST', headers: { 'X-Titan-Key': 'titan_sk_your_api_key', 'Content-Type': 'application/json' }, body: JSON.stringify({ qube_packet, kemPrivateKey: kem.privateKey }) }); const { plaintext } = await decRes.json(); // plaintext === '{"message":"hello quantum world"}'
import requests, json BASE = "https://aeonmi.netlify.app/api/titan" HDRS = {"X-Titan-Key": "titan_sk_your_api_key", "Content-Type": "application/json"} # 1. Keypair keys = requests.post(f"{BASE}/keygen", headers=HDRS).json() kem, sig = keys["kem"], keys["sig"] # 2. Encrypt enc = requests.post(f"{BASE}/encrypt", headers=HDRS, json={ "payload": json.dumps({"secret": "quantum data"}), "kemPublicKey": kem["publicKey"] }).json() packet = enc["qube_packet"] # ⊗ qube::titan ... # 3. Decrypt dec = requests.post(f"{BASE}/decrypt", headers=HDRS, json={ "qube_packet": packet, "kemPrivateKey": kem["privateKey"] }).json() print(dec["plaintext"]) # {"secret": "quantum data"}
# 1. Generate keypair curl -X POST https://aeonmi.netlify.app/api/titan/keygen \ -H "X-Titan-Key: titan_sk_your_api_key" \ -H "Content-Type: application/json" # 2. Encrypt curl -X POST https://aeonmi.netlify.app/api/titan/encrypt \ -H "X-Titan-Key: titan_sk_your_api_key" \ -H "Content-Type: application/json" \ -d '{"payload":"hello world","kemPublicKey":"<base64>"}' # 3. Health check (no auth required) curl https://aeonmi.netlify.app/api/titan/status # → {"status":"online","engine":"TITAN-QUBE-QX-2.0","version":"2.0.0"}

⊗ FAQ

Common questions

Is this actually quantum-safe against future quantum computers? ▼
Yes. ML-KEM-1024 and SLH-DSA-SHAKE-256f are NIST's finalized post-quantum cryptography standards (FIPS 203 and FIPS 205). They are specifically designed to resist attacks from large-scale quantum computers running Shor's algorithm. The classical AES/ChaCha20 layer adds defense-in-depth.
What happens if IBM Quantum is unavailable? ▼
The TITAN engine automatically falls back to CSPRNG entropy when IBM Q is unreachable or times out. Core tier and above mix both sources (hybrid mode). All other pipeline stages — KEM, dual cipher, BLAKE3, SLH-DSA — run identically regardless of entropy source. You'll see entropy_src: "csprng_fallback" in the packet.
What format is the encrypted output? ▼
Every output is a QUBE packet — a structured text envelope starting with ⊗ qube::titan |ψ⟩↦⟨φ| and ending with ⊘ qube::seal |ℋ⟩. It's human-readable, machine-parseable, and contains every algorithm declaration needed for future decryption — no out-of-band metadata required.
Can I manage my own keys or does the API hold them? ▼
You manage your own keypairs. The /keygen endpoint generates a fresh ML-KEM-1024 + SLH-DSA keypair and returns it to you in one call — nothing is stored server-side. You keep the private key. The API only receives your public key at encrypt time.
Where is my API key stored? ▼
Only a SHA-256 hash of your API key is stored in the database. The raw key is shown once at purchase — we cannot recover it. Store it in your secrets manager (Doppler, 1Password, Netlify env vars, etc.).
Can I upgrade or cancel any time? ▼
Yes. Upgrades take effect immediately; downgrades apply at the end of your billing period. Cancellation stops future charges and revokes the API key at period end. No long-term contracts.

Start encrypting in 60 seconds

Get your API key, run your first /keygen call, and ship post-quantum security today.

Choose a Plan →