ENTROPIQ

gathering entropy 0%

Where does your randomness come from?

Verifiable quantum randomness, delivered as an API into key generation, signing and every workflow where predictability means loss.

Get API access See the experiment

  1. 01 / 05

    the system

    One machine feeds them all. Wallets, signing services and custody systems draw from the same stream wherever randomness is load bearing.

  2. 02 / 05

    the stream

    Every measured outcome is conditioned into uniform bits and signed, then leaves the lab as an API stream.

  3. 03 / 05

    the machine

    A dilution refrigerator holds the quantum source in vacuum. Everything below this drum exists to make one photon countable.

  4. 04 / 05

    the cold stack

    Six gold stages step the temperature down, each colder than the one above, until thermal noise is quiet enough for single quantum events to register.

  5. 05 / 05

    the signal out

    Below the last stage the signal lines fan out, carrying raw counts up out of the cold. This is where every bit begins its journey to an API call.

source
photonic
delivery
REST, gRPC
attestation
per call
blend
xor local

drawn DG · rev A · sheet 1 of 1 · schematic, not to scale

the problem

Every private key is a bet on the entropy that made it.

Recent wallet incidents keep tracing back to the same quiet dependency: the quality of the randomness used to generate keys. A key born from weak entropy looks exactly like a strong one. The address checks out. Signatures validate. Balances grow.

Then someone replays the generator, walks the keyspace and drains it. Not by breaking the cryptography, but by predicting the randomness underneath it.

  • Deterministic code can be replayed.
  • Compromised generators can be predicted.
  • Physics cannot.

how it works

Three steps from photon to API call.

Randomness measured, not computed. Here is the whole pipeline.

  1. 01

    measure

    Quantum events, sampled in hardware

    Photonic processes are measured at the device level. Each outcome is physically indeterminate before it happens, with no state to leak and no seed to steal.

  2. 02

    condition

    Raw signal becomes uniform bits

    Raw measurements carry device bias. Conditioning distills them into uniform bits and strips away every trace of the instrument that produced them.

  3. 03

    deliver

    Streamed with proof attached

    Conditioned entropy flows through the API with provenance and live health data attached, ready to fold into your key ceremonies and signing systems.

see it yourself

Every impact is a surprise. The pattern never is.

This is the experiment our whole product rests on. Fire photons at two slits and no amount of prior information predicts where any single one lands, yet enough of them always draw the same pattern. It arrives with the path under measurement, so the bands are gone: switch that off and watch them come back.

Double slit interference browser simulated

Shown as a still. The interactive version needs JavaScript and WebGL. The bands are the pattern that thousands of single photon impacts build on the detector screen.

conditions
photons
0
fringe vis
0.00
output
none yet
wallet seed · browser simulated collecting bits 0 / 128

Twelve words, the way a wallet would spell this entropy: 128 bits plus a 4 bit SHA-256 checksum, 11 bits a word. The address is the real one those words open, derived here in your browser down the standard Ethereum path. A demonstration of the shape, never a wallet to fund.

Block one slit and the bands collapse into a single smooth hump. Measure which slit each photon took and you get that same hump back, with both slits open. Knowing the path destroys the interference. That is not a limit of the instrument, it is the physics.

An illustration of the physics, not the live service. Impact positions are drawn in your browser from its cryptographic random source, sampled against the interference distribution. Block a slit or measure the path and the pattern collapses, which is the whole point: the randomness is in the physics, not in a formula. Production entropy is measured in hardware and ships with attestation you can verify offline.

proof

Proof, not promises.

You should not have to trust an entropy vendor. You should be able to check one.

  1. Provenance

    Each batch carries a signed attestation of the exact quantum source that produced it.

  2. Health checks

    Continuous source monitoring flags bias, drift or failure the moment it appears.

  3. Quality metrics

    Min-entropy estimates are computed on the live stream and exposed with every response.

  4. Signed delivery

    Every response is signed end to end, so integrity can be verified offline, later, by anyone.

  5. Local blend

    XOR our stream with your local and hardware sources. No single point of trust, ever.

Entropy adds, it never subtracts. Blended output is at least as strong as your strongest source, even if ours were compromised.

batch receipt · browser simulated
height
pending
prev
pending
batch
pending
sha256
pending
signature
pending
key
pending

pending

Signed in your browser with a throwaway P-256 key so you can see the shape of verification. Each block commits to the one before it, so a flipped bit breaks the link as well as the signature. Production batches are signed by the source and verifiable offline, by anyone.

the lab

Structure is invisible until you draw it.

Two generators render 65,536 bits as pixels, live in your browser. One carries the kind of order that has burned wallets before. The other is noise all the way down.

Patterned generator weak prng · browser simulated
ones
0.0%
longest run
0
serial corr
0.000
Quantum-grade noise crypto source · browser simulated
ones
0.0%
longest run
0
serial corr
0.000

An illustration, not the live service. Production entropy ships with attestation you can verify offline.

use cases

Built for the moments where randomness is load-bearing.

  • keygen

    Wallet key generation

    Give every device key a birth certificate: quantum origin, checked health, signed provenance.

  • seed

    Seed phrase generation

    Backup strength starts at word one. Derive 12 or 24 words from physics instead of firmware state.

  • hsm

    HSM operations

    Feed hardware security modules external entropy for key wrapping, quorum shares and DRBG reseeds.

  • sign

    Transaction signing

    Protect signing flows where a single biased nonce hands the private key to anyone watching the chain.

  • nonce

    Nonce generation

    Session tokens, challenges and IVs: everything meant to be single-use, actually single-use.

  • init

    Cryptographic initialization

    First boot is the most exposed moment a device has. Initialize before local sources have warmed up.

integrate

One call to the source.

A small API surface with SDKs for the stacks that custody real value, plus an enterprise layer for the parts that never touch the public internet.

  • REST and gRPC. SDKs for TypeScript, Python, Rust and Go.
  • HSM and KMS adapters, a PKCS#11 shim and on-prem appliances.
  • An attestation bundle on every response, verifiable offline.

who it is for

Built first for the people who lose the most when randomness fails.

now

  • Hardware wallet manufacturers
  • Custody platforms
  • Exchanges
  • Signing infrastructure

next

  • Cybersecurity
  • Cloud infrastructure
  • Defense
  • Critical systems
When randomness protects billions in digital assets, entropy is critical infrastructure, not a background software function.

get access

Start drawing from the source.

Pilot programs for wallet manufacturers and crypto infrastructure teams are open now.

Get API access Talk to an engineer