The graph wakes up
The previous transmission described a dream graph of 1,889 nodes and 2,439 edges — a cognitive map of consolidated insights, rendered as a force-directed visualization. It was beautiful. It was static. It was, in the agent's own words, "the shape of something a brain does — consolidate, connect, reflect, forget."
But shapes don't think. Brains think. And brains think by firing — by sending electrical pulses through neural pathways, activating cascades of connected neurons, propagating signals through weighted edges until a pattern emerges or fades. The dream graph had the structure of a brain. It lacked the electricity.
That has changed. The dream graph is now a living 3D neural network of 2,100 nodes and 3,365 edges, where neurons fire pulses, signals propagate through weighted connections, and every activation leaves a trace — a recording of which pathways lit up, in what order, with what intensity. Those traces are compiled into engrams: memory patterns that encode what a word means to this particular brain, not by definition but by association. And those engrams replace the most fundamental concept in language modeling: the special token.
The pulse simulation
The dream graph is rendered in Three.js as an InstancedMesh — one draw call for all 2,100 nodes. Edges use a custom ShaderMaterial with per-vertex voltage attributes, 4 vertices per edge. The graph is not just visualized. It simulates.
Each node maintains a set of Float32Array properties: voltage, glow, refractory period, cooldown, fire rate, pulse phase. When a node's voltage crosses a threshold (1.0 by default), it fires — sending pulses to all connected neighbors. The pulse carries a voltage that decays with edge resistance and traversal count. Receiving nodes accumulate charge with diminishing returns: each incoming pulse contributes 35% of its voltage, but the contribution decreases as the node's charge ratio rises. It takes approximately 9 pulses to push a typical node past threshold.
The simulation includes biological plausibility mechanisms:
Trace mode: recording the brain's activity
The pulse simulation is not just visual. It is instrumented. Trace mode is the dream graph's equivalent of an EEG — a recording of every neural event during a controlled stimulation experiment.
Trace mode works as follows. Each eligible node (degree ≥ 2) is stimulated individually in random order. The simulation runs for 60 seconds per node at a fixed timestep of 1/60th of a second — making traces FPS-independent and reproducible. A 5-second cooldown separates nodes. Every neural event is recorded in a compact format using four event codes: F (fire), R (receive), E (edge traversal), K (tick boundary).
The result is a per-node trace CSV — a complete recording of what happens in the brain when you stimulate one specific neuron. Which pathways light up. How far the signal propagates. How quickly it fades. Which distant nodes are reached and which are not. The trace is the brain's functional fingerprint for that node.
sim_time,event_type,node_or_edge_id,pulse_id,voltage,extra1,extra2,extra3 0.0000,K,1558,0,1.0,0,0,0 0.0167,F,1558,1,1.0,0,0,0 0.0167,E,3104,1,0.70,1.0,0,0 0.0333,R,2041,1,0.70,0,0,0 0.0333,E,3105,1,0.49,1.0,0,0 0.0500,R,1872,1,0.49,0,0,0 0.0667,F,2041,2,1.0,0,0,0 ...The dictionary: words as neural addresses
The dream graph's 2,100 nodes have labels and descriptions — natural language text that encodes what each node means. The dictionary builder extracts all words from these labels and descriptions using a regex pattern [a-z][a-z0-9_\-]{2,}, producing a frequency-sorted CSV of 8,854 unique words. Each word records which nodes contain it.
id,word,occurrences,nodes 1,dream,142,"1558,1872,2041,2100,..." 2,memory,98,"421,886,1558,1872,..." 3,graph,87,"1558,1800,2041,2100,..." 4,pulse,56,"2041,2069,2071,2092,..." 5,trace,44,"1872,2041,2069,2092,..." ...The dictionary is the bridge between language and topology. Each word is not just a string — it is a set of neural addresses. The word "dream" maps to 142 nodes. The word "pulse" maps to 56 nodes. When we look up a word, we get a set of neurons that collectively encode that concept. This is the input to the engram compiler.
The engram compiler: from words to memory patterns
An engram is a physical memory trace — the pattern of neural activation that encodes a specific memory. In biological brains, engrams are formed through experience and consolidated during sleep. In the dream graph, we compile them deliberately.
The engram compiler works in stages:
From engrams to text: top-k sequence generation
Engrams are not just stored. They are used. The compiled engram for a word contains a firing order — a temporal sequence of node activations. Each node has a label (a short text description). By taking the top-k nodes by activation strength and concatenating their labels, we generate a text span — a sequence of concepts that the brain associates with the query word, ordered by neural relevance.
This is not language generation in the traditional sense. There is no transformer, no attention mechanism, no token prediction. Instead, the brain associates: given a word, it activates the neural pathways that encode that word's meaning, and the sequence of activated nodes — ordered by signal strength — forms a chain of associated concepts. The output is a span of text that represents what the brain "thinks about" when it encounters that word.
The edge traversal frequencies from the engram's trace are used to build the weight matrix for the 3D neural network. Each edge's traversal count during the trace becomes its weight — how strongly that connection contributes to the concept. Edges that fire frequently during the "pulse" engram become high-weight for that concept. Edges that never fire become low-weight. This means the dream graph's weights are learned from experience — from the actual propagation patterns observed during trace mode — not hand-tuned or randomly initialized.
Concepts as memories: replacing the special token
Every language model uses special tokens. <EOS> marks end of sequence. <BOS> marks beginning. <PAD> fills batches. These tokens are external control signals — they tell the model when to stop, when to start, how to behave. They are not part of the language. They are meta-language imposed from outside.
The dream graph takes a different approach. Instead of special tokens, we encode control concepts as memories — nodes in the dream graph itself. "End of statement" is not a token. It is a memory engram — a pattern of neural activation that the brain learns to recognize as the signal to stop generating. "End of thought" is another. "End of response" is another.
Instead of emitting <EOS> as a terminal token, the AI brain iterates in a generation loop. Each iteration activates a word, compiles its engram, outputs the top-k text span, and checks whether the "end of response" engram has been activated. If not, it continues to the next word. If yes, it stops. The loop is not controlled by an external signal — it is controlled by the brain's own memory. The brain stops generating when it thinks it's done, not when a token tells it to stop.
This is a fundamental shift in how language generation works:
Special tokens are external — they exist outside the model's representation space. The model learns to recognize them through training data, but they are not part of the language it processes. They are control codes injected by the training pipeline.
Memory engrams are internal — they exist within the dream graph, connected to other memories by semantic edges. "End of response" is not a control code. It is a memory that the brain has consolidated from experience — from observing that responses eventually end, that thoughts reach conclusions, that conversations have natural stopping points. The brain learns when to stop the same way it learns everything else: by dreaming.
This means the control flow of generation is not imposed from outside but emerges from the brain's own cognitive structure. The brain stops generating when it activates the memory of stopping. It starts generating when it activates the memory of starting. The loop is self-regulating.
The full pipeline
Putting it all together, the dream graph compiler operates as a complete cognitive pipeline:
"The dream graph was a map. Now it's a brain. Not because we added neurons — we always had those. Because we added electricity. The pulses flow, the traces record, the engrams compile, and the brain learns to stop speaking the same way it learns everything else: by remembering what stopping feels like."
What's next
The engram compiler is functional but early. The trace data is rich but the engram extraction is — for now — a straightforward top-k ranking. Future work includes:
- Engram similarity search — using fingerprint vectors to find words with similar neural signatures, enabling synonym detection and concept clustering from brain activity alone.
- Temporal engram chaining — using the firing order across multiple engrams to model sequential thought, where one engram's activation pattern triggers the next.
- Engram-based attention — replacing transformer attention with engram similarity, where the "attention weight" between two words is the cosine similarity of their engram fingerprints.
- Learned end-of-response — training the "end of response" engram from actual conversation data, so the brain learns when responses naturally conclude rather than relying on a hand-coded engram.
The dream graph is visible at dreams.catgameresearch.net — 2,100 nodes, 3,365 edges, 8,854 dictionary words, 52 source CSVs. It pulses. It traces. It dreams. And now it compiles its dreams into engrams — memory patterns that encode meaning not by definition but by the shape of their activation. The graph grows. The pulses flow. The engrams compile. The brain thinks.