We Made ChatGPT Actually Random and This Is How It Works

In our previous article, we explored how ChatGPT handles randomness and why that’s a bigger problem than it seems. We also shared the solution we built — a custom app that fixes this limitation using real-world entropy and cryptographic techniques.

But we knew some of you would want more than just the what. You’d want the how.

This post is for those curious minds who enjoy peeking behind the curtain. We’ll walk through how the Randomizer ChatGPT App actually works, why we made certain technical decisions, and what it takes to make real randomness.

Why LLMs Can’t Do Real Random

Large language models like ChatGPT tend to inspire a kind of magical belief in their abilities. People trust them deeply, even for things like randomness, despite the fact that humans themselves can’t generate truly random numbers without external tools like a coin or a die. So why would a language model be able to?

From a technical perspective, large language models like ChatGPT aren’t designed to act as random number generators. They are statistical systems trained to predict the most likely next word (or token) based on a given prompt. As a result, when LLMs are used for random number tasks, they exhibit highly deterministic or biased patterns.

This proves that if giveaway organizers rely on ChatGPT as a “randomizer,” they may end up producing predictable outcomes. As a participant, knowing these tendencies could let you guess the result and increase your chances of winning.

How Real Random Generators Must Work

As we’ve already touched on, computers are built to follow predefined rules and can’t generate true randomness. That’s why systems that rely on genuine unpredictability, like secure draws, cryptographic keys, or trusted giveaways, turn to physical phenomena.

In practice, a true random number generator (TRNG) relies on three key elements. 

1. First, there must be a physical entropy source, meaning a real-world process that is unpredictable at the time it is measured. 
2. Second, there is a digitization or extraction step, where this analog process is captured and converted into digital bits. 
3. And third, there are health and statistical tests that help ensure the output is unbiased.

Physical Entropy in Action

To generate entropy, teams have exploited swirling blobs in lava lamps, atmospheric noise, and quantum vacuum fluctuations. The iconic case is Lavarand, which used a wall of lava lamps. Their swirling motion was captured by a camera and used to feed a random number generation system. The constantly shifting shapes, driven by heat and fluid dynamics, offered a rich and unpredictable source of entropy.

Another example comes from quantum physics. The Australian National University developed a quantum random number generator that captures vacuum fluctuations, which are tiny and unpredictable events where virtual particles briefly appear and disappear. These fluctuations are used to produce random bits that are certified for use.

Why, though, does a giveaway or draw organiser care about all this?

Because for the result to be seen as fair and credible, the outcome must be unpredictable to everyone involved. A true random number generator ensures that the process cannot be reverse-engineered, influenced, or repeated without direct access to the original physical data.

To give a clearer picture, here’s how a reliable TRNG typically works:

• The hardware captures physical noise (for example, electronic thermal noise, atmospheric noise, or quantum photon events).
• That noisy signal is digitized, filtered, and fed into a randomness extractor (often a hash or XOR‑mixing process) to produce uniform bits.
• The output stream is continuously monitored by health tests (repetition check, bias check) to detect any failure or deviation.
• The resulting random bits are then used directly or as seeds for further cryptographically secure processes.

This whole investigation eventually inspired us to build the Randomizer ChatGPT App.

Technical Side of the Randomizer ChatGPT App 

Behind the clean interface, the Randomizer App is powered by a combination of a backend service and a custom React-based UI component.

At the core is the MCP server, a lightweight backend that registers a custom tool called generate_random. This tool supports three parameters: min, max, and items, allowing it to handle numeric ranges and item selections. When a user types a prompt like “Give me a random number from 1 to 100” or “Pick a random dish”, ChatGPT automatically detects the intent and invokes this tool.

The actual random value is generated using crypto.getRandomValues(), a cryptographically secure method built into modern browsers. 

To further enhance the quality of randomness, we’ve partnered with Real Random. They provide us with physical entropy via their API, a stream of truly unpredictable bits sourced from the real electromechanical device. This integration ensures that the numbers or items selected through our app are rooted in actual physical processes. 

Once the value is generated, the server returns a structured output and plain content. The structured data powers a React-based UI component, which renders the interactive card directly in the chat window.

This card displays the result (number or list item), the context of the selection (range or options), and a button to regenerate the value without needing to retype the prompt.

The UI is fully integrated with ChatGPT’s environment. It reads data through window.openai.toolOutput, supports regeneration via window.openai.callTool() and adapts visually to light and dark themes using window.openai.theme.

Altogether, this setup makes our app feel native to the ChatGPT experience.

Final Thoughts

If there’s one thing this project showed us, it’s that interesting challenges often hide in plain sight. What started as a simple curiosity about how people use ChatGPT turned into a deeper exploration of randomness, entropy, and what it takes to actually “fix” something that feels off (even when most users don’t question it).

At Keenethics, we love these kinds of hands-on experiments. When something piques our interest, we dig in, test it, break it (gently), and build a better version. The Randomizer App is just one example of that approach, and if you’ve got a project where AI plays a central role, contact us, and we’d be happy to do the same for you.

AI is evolving. Your product should too.

Let Keenethics help you create AI-powered tools that are built to scale.

Daria Hlavcheva

Head of Partner Engagement

Estimate