Welcome, to the Dream Machine!
AI draws a "Dream Card" with hardware random for better randomness, to inspire a new angle/direction while creating 'creative' things.
I shall begin by demonstrating the dream machine with an actual blog post:
A Fossil Meets an Antenna: Inside the Dream Machine
This post was planned by a TPM chip Before a word of this post existed, Claude asked the computer's TPM 2.0 security chip what it should be. The chip answered with 92 bytes of hardware entropy, which became this card:
=== DREAM 2169-c8f4 | TPM 2.0 | 92 bytes ======================= for a blog post explaining the Dream Machine drift [#####] dream - go somewhere you'd normally dismiss, then find the way back collide antenna x fossil lens through the eyes of a field biologist move Speed it up until it breaks, and look at what breaks first. bind No menus, no settings. * ask What happens when two of these meet? texture glitchy, wry form shape it as a conversation between two rivals ---------------------------------------------------------------- * anchor = ask: answer this question in writing before you continue. Everything else is an offering. Follow whichever line snags.
Making cards like that is the Dream Machine's whole job. It's a small Rust program that pulls randomness from a TPM chip and turns it into creative prompts, constraints and decisions. Claude can call it as a tool, and get choices it could never have made on its own.
The title of this post came from that card. So did its structure, and one section you wouldn't expect in a technical post. The last section lists exactly which lines were used.
The fossil
A language model is a fossil of everything it read. It's a frozen, astonishingly detailed record of which words tend to follow which. Ask it for an idea and it reaches for the most likely one.
That instinct is what makes models useful. It's also why their creative work converges. Watch one in the wild for a while and the pattern is hard to miss. Ask for a random number between 1 and 10 and it will often say 7, the same favorite people have. Ask for a startup name, a story opening or a color palette, and the first answer tends to land near the middle of everything it has seen.
Models do use randomness. Each word is picked with a pseudo-random number generator. But that roll happens inside the model's own probabilities, so it chooses among words the model already considers likely. Turning up the temperature widens the circle without moving its center.
Better dice wouldn't fix this. A perfect random generator inside the sampler would still be choosing from the same short list. The model needs choices that come from outside its own probabilities.
The antenna
The Dream Machine started as something smaller: a Rust program with a neon egui window that reads random bytes straight from the TPM. It sends the raw TPM2_GetRandom command through Windows TPM Base Services, then shows the result as hex or as a number in any range.
The best detail sits at the edge of the window. Every result is stamped [T-LOCKED] to the millisecond, a tiny fossil of the moment the chip spoke. Public beacons solve a harder version of this.
NIST's randomness beacon publishes a fresh 512-bit value about once a minute. Each one is time-stamped, signed and hash-chained to the last, so anyone can check when a draw happened. Dream cards are humbler, with just an ID and a byte count, but the instinct is the same: a draw should leave a record.
The TPM (Trusted Platform Module) is the security chip Windows 11 requires. It guards keys and vouches for the boot process. To do that, it carries its own random number generator, seeded by a physical noise source. That noise source is the antenna: it picks up a signal no record contains and no model can see coming.
Hardware entropy isn't magic, so here is what it actually buys:
Independence. The draw comes from outside the model's weights, prompt and context. Nothing Claude is thinking can tilt it.
No steering. Claude can't quietly treat the option it already preferred as the "random" one. The chip makes the choice before Claude sees it.
An audit trail. Every card names its source and how many bytes it used.
What it doesn't buy is purity. TPM2_GetRandom returns output from the chip's internal cryptographic generator, which its hardware noise source seeds. The operating system's own generator works the same way. The bytes aren't more random than a good OS generator's. What matters is where the choice comes from: outside the model.
What happens when they meet
The card's anchor asked: What happens when two of these meet? The rules say to answer the anchor in writing before going further. Here's the answer.
A fossil can't make anything new. Everything in it was laid down long ago. An antenna on its own makes nothing either. It picks up noise, and noise means nothing until something interprets it.
Put them together and the fossil has to interpret a signal it never recorded. Say the chip deals lantern × mycelium to a model designing a caching layer. The model can't fall back on its usual answer. It has to bridge three things its training never connected, perhaps into a network that glows along the paths requests actually travel. Both ingredients are old. The bridge is new.
That's the whole idea. The randomness isn't the creativity; the meeting is. The Dream Machine supplies what a model can't produce for itself, a choice from outside its own probabilities. Then it leaves the model to do what it does best: make sense of things.
Anatomy of a dream card
A card draws one item from each of seven decks, plus a drift level. All 966 cards were written for this project, from "dead letter office" and "sourdough starter" to "Make mistakes cheap instead of preventing them."
The most important line is the one with the star. Once everything else is drawn, the machine picks one line at random as the anchor. The anchor is binding, and everything else is optional. Without an anchor, a model would quietly use whichever line was easiest and ignore the rest. That's the old habit in a new costume. With one, the chip decides which push can't be dodged.
Rules of the draw
An oracle you can re-roll is only a mirror. You keep drawing until you see what you already wanted. So the Dream Machine ships with a Claude skill that sets five rules:
1. Decide before you look. Fix the theme, or the full list of options, before drawing. Only offer options you would genuinely accept.
2. Honor the anchor. The starred line must visibly shape the work.
3. No re-rolling for taste. An uncomfortable draw is usually the point. Re-draw only when a card truly can't apply, and say so.
4. Interpret structurally. A draw should change the shape of an idea, not just decorate it. Naming the cache "Lantern" doesn't count.
5. Show your seed. Tell the reader what was drawn and how it changed the result.
Randomness picks among good options. It never decides which options are good. So the skill also keeps the machine away from questions with right answers and from decisions where being wrong is costly. Two rivals
The card offered one more idea: tell it as a conversation between two rivals. Its drift was set to dream, which means going somewhere a sensible post wouldn't. So here they are.
MODEL: I've read everything. Ask me anything.
CHIP: 0x21.
MODEL: That isn't a question.
CHIP: 0x69. 0xC8. 0xF4.
MODEL: I can't use this. No context, no pattern, nothing to predict. CHIP: 0x00.
MODEL: Fine. Run through the decks, that's... antenna. And fossil. Fossils don't receive anything. They just sit there, holding what was laid down a long time ago, waiting to be— MODEL: Oh. I'm the fossil.
CHIP: 0x01.
MODEL: Was that a laugh?
CHIP: It was a byte. You decide what it means. That's your whole job.
They aren't really rivals. The model has meaning and no surprise. The chip has surprise and no meaning. Each one is useless without the other.
Under the hood
Entropy flows down from the chip through one Rust library to three front ends. The OS generator steps in only when the chip can't be reached.
A few details matter more than they look:
Pooled reads. A TPM returns at most 32 to 64 bytes per call. The engine loops, filling a 64-byte pool over one open connection to the chip.
No modulo bias. The original range code used random % range, which slightly favors low numbers. The engine uses rejection sampling, so every outcome is exactly equally likely.
Health checks. Every TPM response is bounds-checked, and two identical blocks in a row are rejected outright.
Honest fallback. If the TPM can't be reached, the engine uses the Windows generator and says so on every output. --strict turns that into an error.
The built-in self-test pulled 16,384 bytes from the chip in 1.31 seconds (12.2 KiB/s). Its three pass/fail checks (chi-square, monobit and serial correlation) all passed:
Tests like these can't prove randomness. They catch a broken or biased source, which is the failure that matters. The engine also has 21 unit tests that run against a deterministic stand-in, so they pass on machines without a TPM.
How this post used its card
Six of card 2169-c8f4's eight lines shaped this post. One more draw, a spotlight, came after the first draft. The rules say to show your seed, so here it is:
Leaving two lines unused is allowed. Everything except the anchor is an offering.
Without the card, this would have been a tidy announcement: problem, solution, install steps.
It's still all of those. It just has a fossil in it now.
That's all, folks! -alby13
Article written by AI.
The Dream Machine Agent Skill:
Name dream-machine
Description Consult the Dream Machine, a TPM 2.0 hardware-entropy oracle, to inject genuinely external randomness into creative work such as brainstorming, naming, writing, design directions, choosing between comparable options, or getting unstuck. Use when the user asks to "dream", "shake it up", "roll for it" or wants fresh or surprising angles, and when you notice yourself converging on the first, most obvious idea.
Dream Machine
Your own sampling gravitates toward the most probable idea. The Dream Machine gives you choices that come from outside your distribution: hardware entropy from this machine's TPM 2.0 chip, which neither you nor anything in your context can influence. Its value comes entirely from committing to what it gives you.
How to reach it
MCP tools (preferred, when the dream-machine server is connected): dream, spark, draw, choose, shuffle, number, spotlight, entropy. CLI fallback: C:/dreammachine/target/release/dream.exe <command>. Run dream.exe --help for usage; add --json for structured output, --strict to refuse the OS fallback. For spotlight, pipe the draft on stdin or pass a file path.
When to draw
Situation Starting open-ended creative work Draw dream, with theme set to a one-line summary of the task
Situation Stuck, or every idea is a variation of the same idea Draw dream or spark
Situation Need a metaphor, name, structure or angle Draw spark, or draw from concepts / lenses / forms
Situation Revising a draft Draw spotlight with the draft text
Situation Several options look roughly equally good Draw choose, after enumerating the options
Situation Deciding what to explore first Draw shuffle
Don't draw for questions with a correct answer, for correctness- or safety-critical decisions, or when the user has already set the direction. Randomness picks among good options. It never replaces judgment about which options are good.
Rules of the draw
1. Decide before you look. Fix the theme, or the full option list, before calling. Only put options into choose you would genuinely accept.
2. Honor the anchor. A dream card marks one line with *. That line is binding: use it visibly in the work. The other lines are offerings; take any that snag.
3. No re-rolling for taste. An uncomfortable draw is usually the point. Re-draw only if a card is literally inapplicable, and tell the user you did.
4. Interpret structurally, not decoratively. A draw should change the shape of the idea, not just add a word to it. For example, lantern x mycelium for a caching layer suggests a network that lights up along the paths requests travel. It doesn't mean naming the cache "Lantern".
5. Drift sets the distance. nudge/tilt mean stay near your current idea. swerve/leap/dream mean move away boldly first, then bring it back to the user's goal.
6. Show your seed. Briefly tell the user what you drew (card id, anchor, choice) and how it shaped the result, so the influence is visible and auditable.
7. Report the source. Output names its entropy source. If it says OS CSPRNG instead of TPM 2.0, the TPM was unreachable; mention that.
