Floor 5 · 7 exhibits
The Mind Wing
How a model perceives, remembers, reasons — and how it stays honest.
Neural nets, quantisation, recurrence, vector-symbolic binding, memory & forgetting, speculative inference, grounded citation.
The Char-Net
A ~2.9k-param recurrent net — one real forward pass per character.
Press Generate and watch a tiny brain made of numbers write, one letter at a time — live, in your tab.
How deep would you like to go?
show me · the plain-English storyA real, tiny recurrent neural net (~2.9 thousand parameters) runs one genuine forward pass per character, right here in your browser. The temperature slider controls how much randomness is allowed into each guess — low is cautious and repetitive, high is wilder and less coherent.
Wow — It's about the same size class as the 2.2 KB GRU that once ran on a real 1982 ZX Spectrum — tiny on purpose, and every letter really is one fresh forward pass, not a pre-written reply.
Try this — Type your own seed word, push the temperature slider up toward 1.2, and watch the writing get wilder and less predictable — one real forward pass at a time.
What's really happening · A faithful ~few-KB char-level recurrent net (a vanilla/Elman RNN — the same class of tiny recurrent net as the 2.2 KB GRU that ran on a 1982 ZX Spectrum) — computing live in your browser, not a canned reply. It is tiny on purpose, so its writing is simple and sometimes gibberish-ish; that is the honest floor, not a bug.
Read the full lab reportThe Ternary Quantiser
Round-clip weights to {-1, 0, +1}; measure the compression and the error.
Squash every number in a matrix down to just three values — -1, 0 or +1 — and see, honestly, how much you can still keep.
How deep would you like to go?
show me · the plain-English storyA real 144-weight matrix is compressed by measuring its average size (the “scale”), then rounding every weight to just -1, 0, or +1. The demo shows the real compression ratio and the real reconstruction error — how far the simplified version drifts from the original.
Wow — 1.58 bits per weight (log₂ of 3) is the honest theoretical floor for a 3-symbol code — not a marketing number, the actual information content of {-1, 0, +1}.
Try this — Press Randomise a few times and compare the reconstruction error across different matrices — some compress far more cleanly than others, and the demo shows you which, honestly.
What's really happening · A faithful reimplementation of BitNet b1.58's ternary scheme (Ma, Wang et al., “The Era of 1-bit LLMs,” Microsoft Research, 2024): scale gamma = mean(|W|), then round-clip each weight to {-1, 0, +1}. 1.58 bits/weight (log₂ 3) is the theoretical entropy of a 3-symbol alphabet — the honest ceiling for a real packed encoding, not a bitstream this demo actually writes to disk.
Read the full lab reportWave Recurrence
Four resonant channels, velocity-Verlet, running live.
Pluck four little springs and watch them ring, decay and settle — a real recurrence, computed frame by frame, not a looping clip.
How deep would you like to go?
show me · the plain-English storyFour independent channels, each with a position and a velocity, evolve under their own resonant frequency and damping using velocity-Verlet integration — a real numerical method for simulating motion, computed fresh every frame.
Wow — The live readout of total energy is recomputed fresh every single frame from the actual position-and-velocity state — there is no pre-recorded animation underneath it.
Try this — Send an impulse, then drag Damping down toward 0 and Frequency up — watch the ringing last far longer and swing faster, live.
What's really happening · A visualisation of the recurrence dynamics this class of wave-native design is built from — position-and-velocity state, integrated with velocity Verlet — not the lab's trained (and protected) model. Nothing here reflects the architecture's internals or weights.
Read the full lab reportDoes It Stick?
Real gradient descent on two tasks: catastrophic forgetting vs rehearsal.
Teach a tiny model one thing, then teach it something else — and watch, honestly, how much of the first thing it forgets.
How deep would you like to go?
show me · the plain-English storyA tiny linear classifier is trained by real gradient descent on Task A, then kept training on Task B alone. Task A's held-out accuracy is tracked every epoch — watch it genuinely fall as the model's weights drift toward Task B. Rehearsal — mixing old examples back in — is a real, standard fix.
Wow — Task A and Task B are two genuinely different straight lines (y > x vs y > −x) — one single line truly cannot fit both perfectly, so there's a real trade-off to make here, not a rigged demo.
Try this — Train on Task A, then Task B alone, and watch Task A's accuracy fall — then drag the rehearsal slider up and watch it recover, at an honest cost to Task B.
What's really happening · Real logistic regression, real full-batch gradient descent, real held-out accuracy — Task A is 'y > x', Task B is 'y > -x', two genuinely different linear boundaries so there is a real trade to make, not a rigged demo. Rehearsal (Ratcliff, 1990; a standard continual-learning technique) mixes a fixed 40-example memory buffer into every step at the slider's weight. This models the mechanism behind the personal-local-ai report's honest finding — a fine-tune is a frozen, driftable snapshot — at a toy scale: a single linear model genuinely cannot fit two different boundaries perfectly at once, so even the fix trades some Task-B accuracy for Task-A retention, honestly, rather than getting both for free.
Read the full lab reportHolographic Binding
Circular convolution via a from-scratch FFT: bind, superpose, unbind.
Bind a country to its capital in one shared memory, mix in a few more pairs, then ask for one back — and watch the real algebra recover it.
How deep would you like to go?
show me · the plain-English storyToggle country⊛capital pairs into a shared memory vector; the demo binds each pair with real circular convolution and adds them together. Ask for one country's capital, and a real “unbind” operation recovers an approximate vector, compared by similarity against every candidate.
Wow — It's real circular convolution, computed via a from-scratch radix-2 FFT — and as you pack more pairs into memory, the correct answer's lead over its nearest rival honestly shrinks, because that cross-talk is a genuine property of the algebra, not a limitation being hidden.
Try this — Toggle in three or four country/capital pairs, then query one country — watch the similarity bars, and notice how much closer the runner-up creeps as memory fills up.
What's really happening · A faithful implementation of Holographic Reduced Representations (Plate, 1995): random vectors, circular convolution to bind, addition to superpose, circular correlation to unbind, run here via a from-scratch radix-2 FFT. This is the algebraic substrate the calculated mind's holographic/Fourier reasoning core is built from — not the trained system itself, which stays protected. Unbinding is approximate by construction: as you add more pairs to memory the recovered vector picks up cross-talk from the others, so the correct match's margin over its nearest rival shrinks — an honest property of the algebra, shown plainly, not hidden.
Read the full lab reportSpeculative Decoding
Real accept/verify — a real acceptance rate and speedup.
A fast, sloppy guesser proposes several words ahead; a slower, careful checker only keeps the ones it agrees with — and the result is genuinely faster.
How deep would you like to go?
show me · the plain-English storyA weak bigram “draft” model proposes several tokens ahead; a stronger trigram “target” model checks them in order and accepts the longest matching prefix. Step through rounds and watch the real acceptance rate and real tokens-per-verification-pass speedup accumulate from the actual outcomes.
Wow — The acceptance rate and the speedup you see are measured live from the actual accept/reject decisions this run made — not looked up from a table.
Try this — Auto-run a few passes, then drag “Draft depth K” up to 8 and watch whether guessing further ahead genuinely helps, or just gets rejected more often.
What's really happening · A schematic of the accept/verify mechanism behind speculative decoding (Leviathan et al. 2023; Chen et al., DeepMind, 2023), simplified for a browser tab: two real n-gram language models (order-1 draft, order-2 target) are counted from a small fixed corpus, live; acceptance is ‘draft token equals the target's greedy top pick’ rather than the full rejection-sampling test the published algorithm uses. The acceptance rate and speedup numbers below are real, measured from the actual accept/reject decisions this run made — not looked up. This is not PRISM's own inference engine, which stays protected; it's the same shape of mechanism at toy scale.
Read the full lab reportCite or Refuse
A grounded answer with its source — or an honest refusal.
Ask it something it knows, and it answers with a source. Ask it something it doesn't, and it refuses — on the spot, before the model even gets a vote.
How deep would you like to go?
show me · the plain-English storyA tiny fact store is checked by real keyword-overlap retrieval before the model is ever asked. A match gets a grounded answer with its citation; no match gets an honest refusal — and crucially, the model is never even called in that case, so it can't be talked into guessing.
Wow — The refusal is architectural: with no keyword match in the tiny fact store, the model is never even called — it isn't a request the model might grant or deny on a given roll.
Try this — Try “How does BitNet quantise its weights?” (in the fact store, cited), then “What's the capital of Portugal?” (not in the fact store, refused) and compare the two outcomes for yourself.
What's really happening · A tiny fact store, checked by real keyword-overlap retrieval before the model is ever asked. In-store questions get an answer with a real citation; anything else gets refused, on the spot, without a model call. A small open model runs entirely in your browser via WebGPU, but it is never the one deciding whether to answer or refuse — no match, no model call: the refusal is architectural, not a request the model might grant or deny on a given roll. Needs a WebGPU browser and an explicit opt-in model download; without WebGPU it falls back to the same retrieval/refusal logic with template-phrased answers instead of model-phrased ones.
Read the full lab report