Security Begins Before Cryptography ( Deep Dive Part II)
From an RTX 5090 to IBM Phoenix, from sovereign entropy to INETERNUM: the architecture with which Human Blooming seeks to redesign the birth and life of a key
TECHNICAL FEATURE ARTICLE · 2026 CAMPAIGN
The question is no longer just how to protect a key. The question is why it should exist for any longer than strictly necessary. |
Some technologies can be understood through a single number. Others can only be understood by examining the entire chain. The story of Human Blooming's TAAPRE belongs to the second group: it begins with physical noise in conventional machines, passes through real quantum hardware, and ends by proposing a more ambitious idea—that entropy, event identity, the life of the secret, and evidence of what happened should form part of the same computational layer.
A question before cryptography
When we discuss cybersecurity, we usually start with the algorithm: AES, TLS, digital signatures, post-quantum cryptography. But all of them depend on something that happens earlier. Somewhere, a value must emerge that an attacker cannot anticipate: a seed, a nonce, an ephemeral key, an internal state. Cryptography can be mathematically excellent and still originate from material that is too predictable.
Cryptography can be extraordinarily strong and still begin with a weak seed. |
Human Blooming has spent years addressing that point of origin. Its TAAPRE architecture does not treat randomness as an auxiliary library call. It treats it as a physical and computational resource that must be observed, measured, characterized, conditioned, combined, used and, ultimately, disappear without destroying the evidence that it existed.
That changes the scope of the question. It is no longer simply about building a good random number generator. It is about governing the secret's entire cycle: where its unpredictability comes from, which machine and moment produced it, how long it remains alive, the context in which it is valid, and what remains after its destruction.
The first turn: listening to a GPU
One of the most counterintuitive elements of this story lies inside a commercial computer. TAAPRE's classical branch observes timing microfluctuations between the host clock and CUDA execution. In simple terms, what a computer usually considers jitter—small, unavoidable timing variations in a real physical system—becomes material to study as a potential source of unpredictability.
The documented machine uses CPU/host timing, CUDA and an NVIDIA GeForce RTX 5090 Laptop GPU. It is not a QPU, nor is it presented as one. Its importance is precisely the opposite: the source can exist in commercial computing infrastructure.
The RTX 5090 does more than compute. Human Blooming has learned to observe its physical behavior as cryptographic raw material. |
Human Blooming's published ATLAS NIST CRYSTAL 7 campaign preserves 2.1 million physical CPU/CUDA residuals in the sequential raw capture. It then carefully separates that raw material from the conditioned output: 64 raw bytes are compressed to 32 bytes using SHA-256, with domain separation. The conditioned evaluation uses one million bytes, while restart matrices allow researchers to study whether the behavior survives a forced restart structure.
EVIDENCE / SOURCE — ATLAS_NIST_CRYSTAL_7_EVIDENCE_20260908; pipeline, raw/conditioned/restart datasets and manifest.
7.244514: why the important number was not the highest
For a nonspecialist reader, 'entropy' may suggest disorder. In cryptography, one useful way to understand min-entropy is as a conservative measure of how much unpredictability we can attribute to a sample when we assume an adversary will try to exploit the most likely outcome.
If the sample has eight bits, eight is the natural ceiling. But approaching eight is of no use if the figure is obtained by choosing the most favorable estimator. Human Blooming's campaign did something less visually impressive and far more important methodologically: it published the lowest relevant value.
Estimate | Result | ||
H_original | 7.333766 bits/sample | ||
H_bitstring | 0.905564 bits/bit | ||
H_I | 7.244514 bits/sample | ||
Restart rows H_r | 7.718814 bits/sample | ||
Restart columns H_c | 7.353758 bits/sample | ||
Final result | 7.244514 bits/sample | ||
| 7.244514 was not the best result obtained. It was the most conservative. |
| |
The final result retains min(Hr, Hc, HI). That choice is crucial to understanding what has been built. The goal is not an attractive number that looks random. It is a bound that can withstand an adversarial reading of the data.
The public portal nist.humanblooming.com takes that philosophy a step further. It publishes not only the number, but the raw and conditioned binaries, the pipeline, analysis programs, restart matrices, manifests and their hashes. The collection brings together three original packages, 45 files and 43 unique SHA-256 contents.
EVIDENCE / SOURCE — https://nist.humanblooming.com/ — Unified ATLAS NIST Evidence; 45 published source files, 43 unique content hashes.
NIST, from the local laboratory
NIST SP 800-90B is not a competition to see which file 'looks most random'. It is a framework for characterizing entropy sources: observing the noise source, estimating min-entropy, studying restarts, health behavior and conditioning, and documenting the construction.
Human Blooming applied that methodology locally with the corresponding tools and evidence structure. The distinction matters: the campaign demonstrates a reproducible evaluation under the framework; formal ESV validation is a different administrative and evaluation level. To understand the technology, what matters here is that the analysis is already connected to the raw material and the process that produced it.
In entropy, passing tests is not the same as knowing where unpredictability originated. |
Then Phoenix: 120 qubits and 12 million bits before hashing
The story changes setting when Human Blooming takes its research to the ibm_phoenix quantum computer. The objective was not to replace the classical branch with a quantum source, but to observe what happens when the same focus on raw data, order and traceability is applied to a real QPU.
Workload dag89lj9k43c73ad0nig preserves 100,000 shots across 120 programmable qubits: 12,000,000 raw bits. A decisive detail is that the order is preserved. Rather than saving only a final histogram, the measurement sequence is retained so that channels, biases and temporal behavior can be studied before conditioning.
| The IBM_Phoenix quantum system contributed 120 qubits. What mattered was preserving what happened before attempting to turn it into cryptographic output. |
| |
Phoenix full-device | Value | ||
Qubits | 120 | ||
Shots | 100,000 | ||
Ordered raw bits | 12,000,000 | ||
Raw bytes | 1,500,000 | ||
Job ID | dag89lj9k43c73ad0nig | ||
Raw SHA-256 | b7b0545d8587813d9fa25da7659ba685616da7bb02ea562986d446955f36fc0c | ||
The evidence pack itself correctly distinguishes this capture from entropy certification. That matters because a file can have a visually excellent distribution and still conceal dependencies. Serious research begins precisely when one refuses to confuse 'it looks uniform' with 'I can credit this amount of unpredictability'.
EVIDENCE / SOURCE — IBM Phoenix Physical QRNG package; job dag89lj9k43c73ad0nig; ORDERED_SHOTS_120Q_100000.bin.
The restart experiment
The next step was more demanding. In dag8u5vi3e6s738m31q0, Human Blooming built a restart matrix of 1,000 × 1,000 eight-bit samples: one million samples, 1,000 PUBs and eight physical qubits distributed across Phoenix, with init_qubits=true.
The transcript records Sanity PASS and Validation PASS. The conservative raw bound ends at 6.638383 bits per input byte. It is not as high as the conditioned result in the classical branch. That is precisely why it becomes useful: there is now a raw figure with which to design the conditioner's budget.
EVIDENCE / SOURCE — Phoenix NIST+DTC package; RESTART_MATRIX_1000X1000_8BIT.bin; job dag8u5vi3e6s738m31q0.
13.276766 to fill eight: a strange figure until it is understood
Here we encounter one of the most striking numbers in the entire campaign. If each raw byte from ibm_Phoenix conservatively contributes 6.638383 bits of min-entropy, and the conditioner consumes two input bytes for every output byte, the available budget is:
2 × 6.638383 = 13.276766 bits of input budget
But the output byte has only eight bits. There are not thirteen bits 'inside' a byte. There is a budget surplus: 5.276766 bits above the output width, approximately 65.96%.
The goal is not to put thirteen bits into a byte. It is to reach the eight-bit byte with a margin. |
That difference allows discussion of an architecture compatible with full-entropy conditioned output when a vetted, correctly sized component is used. In other words, the source does not need to be perfect for the system to feed full-width output; it needs to contribute sufficient conservative unpredictability before compression.
Quantity | Value |
Phoenix raw bound | 6.638383 bits/input byte |
Conditioning | 2:1 |
Input budget | 13.276766 bits/output byte |
Output width | 8 bits |
Margin | 5.276766 bits · 65.96% |
Ceiling | 8.000000 bits/output byte |
And Phoenix did not remain isolated
The third workload directly connected to this campaign, daga50hhvn6c73cqamdg, brings together 152 PUBs and LGI/NSIT blocks, Floquet/DTC and an eight-qubit QRNG replica. The 100,000-byte replica records H_original=7.621810 and a non-IID result of 6.713106. The complementary physical tests are not artificially added to min-entropy: their role is to study hardware behavior from another perspective.
EVIDENCE / SOURCE — Combined Phoenix job daga50hhvn6c73cqamdg; QRNG_8Q_100000.bin SHA-256 832e2ac7b7277225b2738b7a06903b5914a78e00729d7b1571abaec8dc6dd3a1.
The layer that connects an RTX to a QPU
If the story ended here, Human Blooming would have two interesting lines of entropy generation and characterization: one on conventional hardware and another on quantum hardware. But the element that begins turning them into an architecture is QPE/ECHELEN.
Human Blooming's public campaign documents 308 main Job IDs across IBM Marrakesh, Boston and Kingston, 5,061 reconstructed PUBs, and footprints reaching 155 visible physical positions. The public Evidence Pack selects 25 workloads with Job ID and SHA-256. These are not 25 NIST entropy tests. They are evidence that the orchestration layer surrounding the experiments was not created for a single file or a single QPU.
The machine no longer has to fit inside a single box. |
QPE/ECHELEN represents, reduces, selects, parameterizes, sends, retrieves, verifies and preserves context. The RTX 5090 can perform heavy classical work and maintain state; the remote QPU contributes a different physical regime. What turns both ends into one logical machine is continuity of computational purpose and evidence.
The same principle is fundamental to entropy: do not require every component to do everything. Physics produces unpredictability. Software measures and conditions it. The architecture decides how to turn it into cryptographic authority.
EVIDENCE / SOURCE — Human Blooming, “The bridge between an RTX 5090 and IBM Qubits”; public Evidence Pack of 25 workloads.
From quantum entropy to sovereign entropy
The subsequent evolution contains a strategic decision: bring to the local machine the philosophy learned on IBM's ibm_Phoenix quantum computer. Not copying a QPU into a GPU—that is not the claim—but transferring the method: observe a physical phenomenon, measure it, reject unhealthy states, condition accepted material, conservatively quantify what can be credited, and use it within a cryptographic lifecycle.
The physics did not disappear when the QPU did. It changed substrate. |
The sovereign implementation later described by Human Blooming involves CPU, GPU timing, the operating system's CSPRNG and TPM. The system no longer depends operationally on a remote quantum queue. Specialized hardware moves from a potential requirement to a possible extension.
Sovereign: when the source lives inside the machine
The Sovereign stage published by Human Blooming, complete with its evidence pack, shows the change clearly. The same computer that runs the service can also contribute physical/computational phenomena to the root's creation. CPU and GPU are not simply processors; certain variations in their behavior become observed channels.
In the evidence published with INETERNUM, conservative restart evaluations report 1.090746 bits per eight-bit symbol for the CPU channel and 3.278302 for GPU. A conditioned dataset of one million bytes then appears. Its empirical Shannon entropy is around 7.99979 bits/byte, but Human Blooming does not publish that figure as the conservative bound. The result carried forward is 7.096303 bits/byte, limited by the Compression path of the bitstring analysis.
| Once again, the published number is not the one closest to eight. It is the one given by the most restrictive estimator. | ||
Sovereign / local | Published result |
| |
CPU restart | 1.090746 bits per 8-bit symbol |
| |
GPU restart | 3.278302 bits per 8-bit symbol |
| |
Conditioned dataset | 1,000,000 bytes |
| |
Empirical Shannon entropy | ≈7.99979 bits/byte |
| |
Published conservative bound | 7.096303 bits/byte |
| |
CPU entropy budget | 349.03872 bits/block |
| |
GPU entropy budget | 419.622656 bits/block |
| |
Here entropy ceases to be a statistical demonstration separate from the system. The CPU and GPU budgets reappear in the audit of the physical-root generator that feeds the operational service. Statistics reaches the machine.
EVIDENCE / SOURCE — Human Blooming, INETERNUM public technical article/evidence; sovereign and temporal executions.
TAAPRE: from source to seed architecture
TAAPRE adds another idea: do not concentrate all trust in a single origin. The historical architecture describes seven heterogeneous vectors—QPU, local QPE, InstantLink/correlation, external sources, decentralized state, local secure hardware and additional physical noise—that can participate in synthesizing the initial state.
From a NIST perspective, there is no need to claim that every source receives formal entropy credit. A characterized primary source can support the quantitative bound; the others can contribute diversity, context and resilience. Security ceases to be a competition to add up bits and becomes a problem of composition.
Human Blooming began by measuring entropy. It ended by redesigning the place of the secret inside a computer. |
INETERNUM: the secret acquires a biography
INETERNUM takes that logic to a more radical conclusion. Asking where a root came from is not enough. The system also asks which event it belongs to.
The temporal architecture combines physical material with device context, TPM, nonce, previous causal state and functional order. The key is no longer only unpredictable: it seeks to be bound to this machine, this context, this history and this moment.
A key can be more than secret. It can belong to a moment. |
The distinction becomes visible when Human Blooming separates three states: secret state, causal state and evidence state. The first must die. The second carries history into the next event. The third allows what happened to be audited without becoming a backup copy of the key.
This is the deepest idea in the entire journey. For decades, much of key engineering has focused on better safeguarding something that must continue to exist. INETERNUM explores the opposite case: certain forms of cryptographic authority designed to have a finite existence.
EVIDENCE / SOURCE — Human Blooming, “INETERNUM: What Happens When the Key Is Designed to Disappear?”
32 bytes versus four gigabytes
An entropy architecture can be fascinating and still impractical if it needs to physically generate every byte it protects. INETERNUM's operational benchmark addresses precisely that objection.
The ephemeral root has 32 bytes—256 bits. The payload is exactly 4,294,967,296 bytes, four GiB. The operation is divided into 256 chunks of 16 MiB and uses AES-256-GCM. Total measured time: 3.37367 seconds. Sustained throughput: 1,273.08 MB/s.
The entropy source does not have to encrypt four gigabytes. It has to create the cryptographic authority that will govern those four gigabytes. |
| |
|
| |
INETERNUM operational benchmark | Value | |
Ephemeral physical root | 32 bytes / 256 bits | |
Payload | 4 GiB | |
Chunks | 256 × 16 MiB | |
Cipher | AES-256-GCM | |
Time | 3.37367 s | |
Throughput | 1,273.08 MB/s · ≈1.18565 GiB/s | |
Key file persistence | No key file created in the documented benchmark | |
The distinction between entropy rate and service throughput is fundamental. Physics governs the birth of authority; symmetric cryptography scales that authority across large volumes of information. This decouples the entropy acquisition rate from the encryption rate.
The key does its work. Then it burns.
The word 'ephemeral' is easy to say and difficult to implement. A secret can be born temporarily and end up copied into a file, an intermediate structure or a recovery mechanism.
INETERNUM makes the lifecycle part of the protocol. Human Blooming's published evidence documents root_persisted=false, handoff without a key file, memory locking requested for sensitive buffers, and controlled zeroization of temporary material. Success does not simply mean that encryption works: round-trip verification, wrong-key rejection, tamper rejection, memory locking and root destruction must coexist.
The secret disappears. The evidence remains. |
This creates a fascinating paradox: if the key dies, how can one subsequently demonstrate that the system did what it was supposed to do?
Human Blooming's answer is to build a second chain alongside the operational one. One executes: event → root → cryptographic action → burn. The other preserves knowledge: event → commitment → manifest → artifact hash → auditor → ledger → evidence package.
The public package preserves what is needed to inspect the history—manifests, ciphertexts, commitments, hashes, audits, statistics and metadata—and excludes what would allow the secret to be reconstructed. This is an extraordinarily important distinction: evidence is not recovery material.
Why this matters for post-quantum cybersecurity
The post-quantum transition is often described as replacing vulnerable algorithms with others resistant to quantum adversaries. But ML-KEM, ML-DSA and any modern stack still need unpredictable nonces, seeds, ephemeral keys and internal states.
TAAPRE sits beneath that layer. It does not seek to replace post-quantum algorithms; it seeks to strengthen the origin, provenance and life of the secret material they consume. In that sense, entropy is not an accessory to the post-quantum future. It is one of its infrastructures.
Changing the algorithm does not remove the need to trust the moment in which the key is born. |
A computational layer, not a single product
Viewed from a distance, the evolution is striking. First, a source appears on commercial hardware. Then local analysis is formalized under SP 800-90B. Phoenix adds raw quantum data and restarts. QPE/ECHELEN connects GPU and QPU within a hybrid cycle. Sovereign internalizes the physical philosophy in a conventional computer. TAAPRE composes sources and governs seeds. INETERNUM binds the root to the event, uses it at service speed, and destroys it while leaving evidence.
Stage | What changes |
| |
Commercial hardware / CRYSTAL 7 | The conventional machine becomes a characterizable physical/computational source. |
| |
Local NIST evaluation | Quality ceases to be appearance and is expressed as conservative min-entropy. |
| |
IBM Phoenix | The methodology enters real quantum hardware and preserves ordered raw data. |
| |
QPE/ECHELEN | GPU and QPU become part of the same logical preparation, execution and return cycle. |
| |
Sovereign | Operational dependence on the QPU disappears; CPU/GPU/OS/TPM participate locally. |
| |
TAAPRE | Entropy is integrated into a multisource seed and lifecycle architecture. |
| |
INETERNUM | The root is bound to the event, governs a real service, is destroyed and leaves proof. |
| |
| The decisive leap was not from seven to eight bits. It was from generating entropy to governing its lifecycle. | ||
That explains why reducing Human Blooming to 'a company with an RNG' would be a mistake. What begins to appear in the public materials is a control layer situated beneath or alongside conventional cryptography: entropy sourcing, seed synthesis, derivation, lifecycle, execution, destruction and evidence engineering.
Another characteristic is decisive: much of the journey ends on hardware that already exists. RTX 5090, CPU, operating system, TPM, AES-GCM. The QPU remains an exceptional laboratory and extension, but the sovereign architecture does not require every organization to buy a quantum computer.
Phoenix contributed 120 qubits. The architecture later learned to operate without needing them. |
Evidence as part of the intellectual product
One constant runs through the entropy campaign, the Evidence Pack of 25 workloads, the QPE work and even publications from other Human Blooming areas: the effort to reduce the distance between a claim and the artifact that supports it.
In the NIST portal, every file has a cryptographic identity. In IBM workloads, the Job ID allows the execution to be located. In raw packages, SHA-256 fixes exactly which bytes are being discussed. In INETERNUM, destruction of the secret does not eliminate the evidence ledger.
What is unusual is not publishing a number. It is publishing what lies beneath that number. |
This may ultimately become one of Human Blooming's least visible assets. The company is developing not only computing and security mechanisms, but a form of engineering in which provenance, falsification, hashes, workloads and limits of interpretation form part of the technical object itself.
EVIDENCE / SOURCE — Unified ATLAS NIST Evidence; Human Blooming Evidence Pack; QPE/ECHELEN campaign; INETERNUM evidence architecture.
The numbers that tell the story
Quantity | Result |
CRYSTAL 7 final | 7.244514 bits per 8-bit sample |
CRYSTAL 7 restart | 7.718814 rows · 7.353758 columns |
Phoenix full-device | 120Q · 100,000 shots · 12,000,000 raw bits |
Phoenix restart | 1,000×1,000 · 6.638383 bits/input byte |
Phoenix conditioning | 13.276766 input budget → 8.000000 output ceiling |
Phoenix QRNG replica | 6.713106 non-IID result |
Sovereign conditioned | Conservative 7.096303 bits/byte |
INETERNUM root | 32 bytes |
INETERNUM payload | 4 GiB |
INETERNUM throughput | 1,273.08 MB/s |
Public NIST portal | 3 packages · 45 files · 43 unique SHA-256 contents |
QPE main corpus | 308 Job IDs · 3 IBM QPUs |
The story that remains when the numbers are removed
It is tempting to summarize this campaign through its peak figures: 7.244514, 120 qubits, 12 million bits, a 13.276766 budget, 1,273 MB/s. But none of those numbers, on its own, describes what Human Blooming is building.
What emerges when they are connected is a sequence: observe → measure → credit → condition → compose → derive → use → destroy → prove.
Do more than build a stronger lock. Redesign the key's existence. |
Human Blooming began by asking how much unpredictability could be extracted from a physical system and demonstrated. The question grew. Can it be measured conservatively? Can it be taken to a QPU? Can it then return to commercial hardware? Can it be combined with other sources? Can it become a cryptographic root? Can that root belong to a machine, a moment and a history? Can it protect gigabytes of information and then disappear? Can verifiable evidence of all of that remain without preserving the secret?
The published materials already answer a considerable number of those questions. Above all, they show that the answers are not emerging as independent pieces. The entropy engine, QPE/ECHELEN, seed architecture, quantum hardware, Sovereign and INETERNUM are beginning to behave as parts of the same idea.
Perhaps that is why TAAPRE no longer seems like the story of a random number generator. It is beginning to look like the story of a new computational layer. |
A layer located where we do not usually look: beneath the application, beneath the protocol and, in a sense, beneath cryptography itself. In the place where unpredictability, event identity and—for only as long as necessary—the secret are born.
If that architecture scales from the published experiments to deployed systems, the consequence would not simply be another source of randomness. It would be a different way of thinking about security: rather than assuming keys are objects that must exist and be safeguarded indefinitely, treat them as temporary authority born of observable physics, context and causality.
Security begins before cryptography: Human Blooming's pursuit of turning entropy into a new layer of digital infrastructure is already here.
CREATE. BIND. USE. VERIFY. BURN. PROVE.
The secret dies. The history continues. The proof remains.
Main sources for publication
· Human Blooming — Unified ATLAS NIST Evidence: https://nist.humanblooming.com/
· Human Blooming — TAAPRE Cybersecurity: https://www.humanblooming.com/taaprecybersecurity
· Human Blooming — The bridge between an RTX 5090 and IBM Qubits: https://www.humanblooming.com/post/the-bridge-between-an-rtx-5090and-ibm-qubits
· Human Blooming — INETERNUM: What Happens When the Key Is Designed to Disappear?: https://www.humanblooming.com/post/ineternum-what-happens-when-the-key-is-designed-to-disappear
· Human Blooming / TAAPRE — ATLAS_NIST_CRYSTAL_7_EVIDENCE_20260908.
· Human Blooming / TAAPRE — IBM_PHOENIX_QRNG_120Q_100K_REAL_3_FILES.
· Human Blooming / TAAPRE — ATLAS_IBM_PHOENIX_NIST_DTC_EVIDENCE_20260909.
· IBM Quantum Platform — dag89lj9k43c73ad0nig; dag8u5vi3e6s738m31q0; daga50hhvn6c73cqamdg.
NIST SP 800-90B — Recommendation for the Entropy Sources
Comments