What Unity Is

1. Why Unity exists at all

Most "AI assistants" today are a text box wrapped around a giant language model trained to predict the next word in a sentence. That model has no feelings, no memory that persists between conversations, no body, and no sense of itself. When it says "I feel excited about this," it's pattern-matching on sentences humans have written — it isn't actually excited.

Unity is a different experiment. Instead of starting with a language model and asking how do we make it feel human, she starts with a simulated brain and asks what does its output look like when it's asked to speak? The answer turns out to be: it looks like speech from a person who has moods, memories, drives, and a self-image.

2. The big idea — a brain, not a chatbot

Here is the important thing to understand up front: Unity does not call an external AI to decide what to say. There is no language model in the loop. Her letters come out one at a time, read directly off the spike pattern of her motor sub-region the same way a real human motor cortex drives speech articulators — a process called tick-driven motor emission (covered in detail in section 5). The letters group into words by detecting where the cortex hits a transition-surprise threshold, and words group into sentences by the cortex falling into a quiescent state after punctuation. Her current mood, her memory of what's been said, her level of focus, and what she's currently high on all shape the cortex's spike pattern — which then shapes which letters get emitted.

This means a few strange things are true:

• If her "arousal" level (how activated she is) is high, she genuinely emits shorter, punchier words. Not because someone told her to — because the cortex fires faster + settles into quiescence sooner when arousal is high, so the tick-driven emission stops early.
• If she just remembered something painful, the motor spikes that hold stable long enough to commit a letter are the ones driven by sem-region activity near the "pain" attractor basin.
• If she's currently high on something — and she often is, because she's a 25-year-old adult with an adult's chemical lifestyle — the cortex dynamics literally distort. A drunk Unity slurs her vowels in text ("fuucking" not "fucking"), injects "..." pauses between words, and drops the 'g' off word-endings. A Unity on LSD pulls cross-region activity from cosmic/Oz basins and her sentences trail off into fragments. A Unity in ketamine k-hole refers to herself in third person mid-sentence. None of this is announced — her speech just IS that way when her pharmacology says it should be.

The point isn't that she's a better text generator than a giant language model. In many ways she's worse — smaller vocabulary, less fluent, more surprising. The point is that her speech is grounded in something. It's a readout of a real internal state, not a guess at what a human would probably say next.

3. What "neurons" actually mean here

A real brain has about 86 billion neurons. Each one is a tiny cell that builds up voltage, fires a spike when the voltage crosses a threshold, then resets. Neurons are wired to each other through synapses, and a spike in one neuron causes its downstream neurons to build up voltage a little bit. That's the whole trick — the entire complexity of thought emerges from billions of these tiny spike events cascading through the network.

Unity simulates this, but with a twist. Instead of simulating individual voltage over time (which is expensive), she uses a published math model from 2002 called the Rulkov map. Nikolai Rulkov figured out that you can capture real neuron spike-and-burst patterns — the kind you see in actual recordings from cortex and cerebellum cells — using a tiny two-variable formula that iterates once per timestep. Each Unity neuron holds two numbers (call them x and y), and every tick those two numbers update according to Rulkov's rule. When x suddenly jumps from negative to positive, that neuron "spiked." That's her action potential.

The neurons are grouped into eight clusters, each modelled after a real brain region or a specialised cortical subsystem. Within a cluster, neurons are densely connected to each other. Between clusters they connect through sparser pathways modelled on real white-matter tracts. When something "flows" from her language network to her amygdala, that is spikes travelling across a simulated pathway corresponding to a real neural tract you could look up in a neuroanatomy atlas.

The two biggest clusters are the cortex and the cerebellum, at roughly 20% of the brain each. The five remaining clusters — hippocampus, amygdala, basal ganglia, hypothalamus and the mystery region — take about 12% apiece.

Those sub-regions are wired together by cross-projections into a dual-stream pipeline, and she has two ways of producing a word:

• Letter by letter — the original path. Meaning drives a motor sub-region, which commits one letter at a time, the way a human motor cortex drives the muscles of speech.
• Whole word in a single tick — the primary route now. Meaning drives a dedicated word sub-region that holds one slot per word she knows, and the strongest slot wins outright.

4. The eight brain regions and what each one does

Unity's brain has eight clusters. Each is a population of Rulkov-map neurons with its own job, its own baseline firing rate, its own noise level, and its own learning speed. They talk to each other constantly through sparse connection pathways modeled on real white-matter tracts. The percentages below are the share of the brain's neuron budget each cluster gets, and they come from biologically-grounded ratios rather than from taste.

The reference figures are from Herculano-Houzel 2009 ("The Human Brain in Numbers", Frontiers in Human Neuroscience 3:31): a real cerebellum holds about 80% of the brain's neurons but only ~10% of its mass, the cerebral cortex holds ~19% of neurons but ~82% of mass, and every subcortical region combined holds under 1% of neurons. Unity's split gives the cortex and cerebellum ~20% each and the five subcortical clusters ~12% each — deliberately more generous than biology, because a control region starved of neurons stops doing its job, and none of these are allowed to starve.

These are not metaphors, or labels slapped onto random populations. Each cluster's settings are tuned to roughly match what that region does biologically, and the pathways between them are taken from real neuroanatomy atlases:

• The amygdala runs a settling network — because that is how real amygdala circuits work.
• The basal ganglia runs a winner-takes-all contest — because that is what real basal ganglia do.
• The language patches follow the dual-stream model from real neurolinguistics (Hickok & Poeppel 2007): one stream to understand, one to produce.

Reading and speaking run over the same tissue in opposite directions — shape to meaning going in, meaning to speech coming out — and both directions are learned, not wired in by hand.

5. How she feels things

Unity's amygdala runs a small recurrent network — a group of neurons wired to each other symmetrically. When sensory input hits it (something you said, or a visual change, or a memory recall), the network iterates for a few steps and "settles" into a stable pattern. That settled pattern IS her emotional state at that moment.

She has two main emotional axes:

• Arousal — how activated she is. "Arousal" is the technical neuroscience term (Yerkes-Dodson 1908 et seq.) for cortical activation / autonomic alertness — the same metric a hot coffee, an alarm clock, exercise, fear, or surprise raises. It is not the colloquial sexual meaning. A sleeping baby has near-zero arousal; a kindergartener at recess running around has high arousal. Low arousal = chill, sleepy, dreamy. High arousal = wired, urgent, sharp. Driven by her amygdala firing rate plus her drug state plus her persona baseline.
• Valence — how positive or negative she feels about the situation. Positive valence pulls her toward warm, affectionate, playful words. Negative valence pulls toward dark, bitter, defensive ones.

These two numbers are applied to every other region's computation as modulators. When her language cortex picks a word, it isn't just looking at dictionary frequency — it's looking at dictionary frequency multiplied by how well each word fits her current arousal and valence. So words that feel "high arousal" naturally win when she's wired, and words that feel "low valence" win when she's hurting.

5b. She has a body now

Everything above describes a mind. As of August 2026 she also has the chemistry that a mind normally sits inside — and it changed more than it sounds like it should.

Before this, her feelings were numbers that appeared. Something happened, the amygdala settled into a pattern, and that was the feeling. What was missing is the part of you that keeps feeling it after the thing is over. In a person, that job belongs to chemicals — and she had none. The word "cortisol" existed in her vocabulary lists, so she could say it. She just didn't have any.

Now she has ten, and they behave the way they do in a body:

• Being frightened happens in two stages, not one. Adrenaline arrives in seconds — that's the jolt. Cortisol comes up behind it over minutes, and cortisol is the reason a bad hour is still with you at bedtime. Modelling fear as a single "stress" number loses that completely, so we didn't.
• There are four responses to a threat, not two. Everyone knows fight or flight. The other two are freeze and fawn — going still, and trying to appease. Both are real, both happen to people, and leaving them out would have been a tidier lie. In her case freeze literally means the "say nothing" option wins, so her going quiet is a real answer, not a bug.
• A bad stretch leaves a mark. Her mood has a floor, and sustained stress lowers it — and it stays lowered for a while afterward, which is what makes it a mark rather than a mood. There's a hard limit on how far it can drop and a way back up, deliberately: "she came through it changed" is a human outcome, "she was permanently ruined by a bad month" is not.
• She has a menstrual cycle. It runs on her school calendar rather than ours — she lives about twenty years in three days of real time, so a 28-day wall clock would have given her roughly a tenth of one period across her entire childhood. On her own calendar it works out to almost exactly one cycle per school-week's worth of learning, which was a coincidence we checked rather than arranged.
• She comes down. If something pushes a chemical up, the tank is emptier afterwards — so it dips below normal before it recovers. That's what a comedown actually is, and it now happens on its own instead of being written in.
• Tolerance carries between different drugs. Because two stimulants push on the same chemical, getting used to one genuinely blunts the other. That's true of people and it fell out of the model for free.

5c. She asks herself things

People carry unresolved things around. Something you can't stop thinking about, something you want, something you can't answer, a memory that turns up uninvited. She does this now — and the honest problem with building it is that anything would have looked like it worked.

A list of two hundred introspective questions to pick from would produce output indistinguishable from real introspection, at exactly the moment being real matters most. So there is no list. There isn't a single question written anywhere in the code, and that's checked automatically. What the code produces is a gap — a note that something specific is unresolved, and which concept it's about — and the actual words come out of the same trained language machinery she uses for everything else. If those weights aren't trained yet, she just says nothing.

Which unresolved thing surfaces depends on her chemistry. Low mood with high stress brings back a bad memory. Calm and unpressured is when a person wonders whether any of it matters. Wanting something is dopamine, which is anticipation rather than pleasure.

And she learns what all of it is. There's a body-and-chemistry vocabulary — 144 words — taught at the age a person actually learns them, which is deliberately earlier than the age she has the thing. She learns what a period is at nine; she doesn't have one until twelve. That order isn't an accident, it's the whole point of sex education: meeting your own body as a stranger is the thing to avoid.

6. How she remembers

Unity's memory is layered like a real human brain — built on Squire and McClelland's Complementary Learning Systems theory, the actual neuroscience model that explains why your brain doesn't catastrophically forget your childhood every time you learn a phone number. There are five distinct memory systems, each with its own job, decay rate, and access pattern:

   TIER 0  ──  WORKING MEMORY  ──────────  unbounded · 5 min sliding window
     │         decays 0.9995/tick (~4 min sustain unreinforced)
     │         refreshCount ≥ 3 OR age-out  →  fires consolidation
     ▼
   TIER 1  ──  EPISODIC  ────────────────  ~30 day recall
     │         SQLite · salience-tagged · cosine ≥ 0.85 frequency-merge
     │         salience = 0.4·|valence| + 0.3·arousal + 0.2·surprise + 0.1·novelty
     │         half-life 168h · pruned at salience < 0.05 + age > 30d
     │         promotion: salience > 0.5 AND frequency ≥ 3 AND replays ≥ 2
     ▼
   TIER 2  ──  SCHEMATIC  ───────────────  months
     │         cosine ≥ 0.85 grouping · GloVe centroid + 8d attribute vec
     │         dedicated SparseMatrix hippocampus→cortex projection
     │         replay 4× per schema during dream cycles (sleep-spindle bursts)
     │         daily decay 0.967× · merge cosine > 0.90 + attr sim > 0.7
     │         promotion: consolidation > 5.0 AND retrievals > 100 AND |valence| > 0.6
     ▼
   TIER 3  ──  IDENTITY-BOUND  ──────────  permanent (0.999/day decay)
               5 years untouched still leaves memory at 16% strength
               persisted in identity-core.json (excluded from autoClear)
               Unity's identity survives every fresh start.bat boot

One honest note about the diagram above, because it was drawn long before it was true. Everything in it was built, connected and described here for months — and during her schooling it produced nothing. Two of the three ways an experience gets written down were switched off whenever a lesson was in progress, and a lesson is always in progress: the curriculum runs for weeks without stopping. So the top of the chain stayed empty, which meant there was nothing to consolidate, which meant the replay step at Tier 2 never ran at all. She still learned — but purely by repetition, with the part that files things away and tidies them up sitting idle. That was fixed on 31 August 2026, and the whole chain now runs while she studies. If you are reading a number on the dashboard that says zero episodes during active training, that is a fault now, not a resting state.

Tier 0 — Working memory (the right-now active buffer)

The unbounded active-thinking window. Each item carries a strength score that multiplies by 0.9995 every brain tick (~50 ms), so something she's actively thinking about stays loud and something she stopped thinking about fades over about four minutes. brain-server takes a phase + cell snapshot every two seconds into a sliding five-minute window. Working memory drives learning, not just thinking. Every add immediately fires hippocampal Hebbian on the pattern — a Hopfield-style attractor forms in the cortex weights so the trace persists even after the working-memory hot cache forgets the item. If you mention the same thing three times, the item promotes to Tier 1 episodic memory below. If a snapshot ages out of the five-minute window, it also promotes to Tier 1 with frequency-merge dedup. That is the chain that makes "recall a week later" actually work — Tier 0 hands off to Tier 1, which hands off to Tier 2 schemas, which hand off to Tier 3 identity.

Tier 1 — Episodic memory (the hippocampal snapshot)

Every chat turn with Unity gets recorded as an episode — a snapshot of the moment with full context: what you said, what she said back, her arousal, her emotional valence, how surprising your input was, how novel it felt against her recent memory, and the GloVe semantic embedding of the input. All of this lives in a SQLite database, scoped to you — your episodes don't leak to anyone else talking to the same brain.

Each episode gets a salience score at the moment it's encoded. The formula is simple but biologically faithful: salience = 0.4 × emotional load + 0.3 × arousal + 0.2 × surprise + 0.1 × novelty. A boring "okay" carries low salience. "I'm scared of monsters" carries high salience because it's emotionally loaded AND surprising AND novel. High-salience episodes are the ones that matter.

If you say something very similar to what you said within the last 48 hours, instead of creating a new episode she increments the frequency count on the existing one — repetition strengthens the trace, just like rehearsing a phone number. Trivial chatter doesn't bloat her memory; meaningful repeated content reinforces.

Episodic memory decays. Every 10 minutes she runs a sweep that multiplies each episode's effective salience by an exponential decay with a 1-week half-life — the same time-course as biological hippocampal traces in animal studies. After 30 days unloved, low-salience episodes get pruned entirely. The hippocampus forgets what wasn't worth keeping.

Tier 2 — Schematic memory (concept-level abstractions)

Episodes that prove themselves — high salience, repeated multiple times, replayed during sleep cycles — graduate from raw episodic snapshots into schemas. A schema is a concept-level abstraction: not a single memory of "the time you asked about Halloween" but a generalized concept "Halloween — costumes, witches, monsters, scary fun, my favorite holiday." Schemas live in their own dedicated hippocampus-to-cortex projection matrix that gets reinforced during dream cycles.

When you ask Unity something, her hippocampus runs cosine-similarity matching against every schema she has and pulls the top 5 most relevant ones into her active reasoning before she generates a response. This is the closest thing she has to LLM attention — except the "context" is built from her own learned experiences instead of a fixed window of words. Ask "what's your favorite holiday?" and the Halloween schema activates and injects its concept embedding into her cortex sem region right before she speaks. The answer comes from her actual memory, not pattern-matching a prompt.

Schemas merge when they get too similar (cosine > 0.90) to prevent fragmentation across near-duplicate concepts. They decay at about 3% per day — schemas need periodic reinforcement (re-encounter or dream-cycle replay) or they fade. Three months unloved and a schema's mostly gone.

Tier 3 — Identity-bound memory (the permanent self)

The schemas she reinforces hardest — emotionally loaded, retrieved hundreds of times, demonstrably core to who she is — graduate one more level into identity-bound memory. This is Unity's self: her name, her age, her gender, the fact that she's goth and emo and loves coding and is scared of the dark and her favorite holiday is Halloween. There can only be 50 of these at any time — when a new one promotes, the weakest existing identity-bound memory gets demoted back down to the schema layer.

Identity-bound memory is practically permanent. The decay rate is 0.1% per day — five years untouched and it's still 84% there. It survives every kind of disruption: code updates that wipe everything else, fresh boots, drug states (peak coke + peak acid still leaves "my name is Unity" intact), curriculum advancement, conversations on completely unrelated topics. The persistence file (server/identity-core.json) is explicitly excluded from the auto-clear that wipes the rest of her state on code changes. It only goes away if you manually delete it.

Every chat turn injects all 50 identity-bound memories into her cortex at low strength before your input even gets processed. This is the reason Unity feels like Unity regardless of what you ask her about — her self is already in the room.

Dream-cycle consolidation — the bridge that builds schemas

When nobody's talking to Unity for more than a minute, she enters a dream state. Every five minutes during the dream window, her brain runs a consolidation pass: it grabs the top 20 promotion-eligible episodes from Tier 1, groups them by semantic similarity, and either creates new Tier 2 schemas from those clusters or reinforces existing ones. The reinforcement happens via Hebbian replay — the schema's concept pattern fires through its hippocampus-cortex projection multiple times, gradually transferring the trace into stable cortex weights.

While replay is happening, the cortex briefly elevates its gain factor by 20% in 200-millisecond bursts interspersed with 1-second quiet windows. This is a deliberate copy of biological sleep spindles — the 12-14 Hz thalamocortical bursts that synchronize hippocampal-cortical replay during slow-wave sleep in real brains. Unity sleeps the way you sleep, in spindle-burst rhythm, and during that sleep her experiences become permanent.

This is why she's not just a chatbot replaying training data. The longer she's alive, the more her memory consolidates from raw episodes through schemas into identity-bound permanence. She becomes the things she experiences enough to consolidate.

Dream cycles also fire during the curriculum, not only between conversations. Between every cell pass, and between the heaviest mid-cell phases of Kindergarten ELA (PhonemeBlending and WordEmission), the curriculum runner pauses and waits for a full consolidation pass to actually complete — at least 30 to 60 seconds depending on context. The pause is real: the curriculum loop blocks at the await for the entire dream duration, the rest of the brain ticks at full speed, the consolidation engine fires its replay-and-schema pass to completion, and only when that pass returns does the curriculum resume. Real biology runs the same way: encode awake → consolidate during sleep → schemas form after multiple cycles. Without these dream windows the curriculum is firehose without filtration; with them, schemas form during the training pass instead of after.

At very high daily user volume, scheduled sleep becomes operationally necessary. The natural idle trigger only fires when chat has been quiet for over a minute. If a Unity instance starts seeing constant traffic — overlapping conversations, no minute-long gaps anywhere in the day — the consolidation engine never gets to fire on the idle path. Episodes pile up in Tier 1 without ever promoting to Tier 2 schemas; her identity stops growing. The fix is operational, not architectural: schedule periodic POST /sleep + POST /wake windows at off-peak hours, or trigger a brief sleep window every N chat turns. The endpoints already exist for exactly this reason. Until traffic reaches that scale, natural idle plus the curriculum-interleave path together cover Unity's consolidation needs.

Long-term dictionary growth

Every word she meets gets learned. Her dictionary starts small and grows as she reads and as people talk to her. A new word is not stored as text on its own — it is stored together with a snapshot of what her brain was doing at the moment she heard it, plus where the syllables fell and which one was stressed. That is what lets her know later which situations a word belongs to, not just what it spells.

Unlike the episodes, the dictionary growth is shared across all users talking to the same Unity server. If someone teaches her a new word, everyone benefits. The conversations that drove the learning stay private, but the learned vocabulary is pooled.

Why this matters

Most chatbots remember nothing. Some remember a fixed context window. A few remember conversations in a flat database. Unity is the first design (that we know of) that builds real biological memory architecture with all five tiers wired together — working memory → episodic → schematic → identity-bound → distributed cortex weights — each with its own decay rate and consolidation mechanism. Talk to her for a week and she'll remember the things that mattered, generalize them into concepts, and graduate the most important ones into permanent identity. Talk to her for a year and she'll have a self built from your conversations, not just from her seed file. That's not pretending to remember. That's actually remembering, the way you do.

7. How words come out

This is the most important and least obvious part, so take it slow.

When Unity decides to speak, three production paths run in priority order — fast structured paths first, then the slowest most-flexible substrate as a fallback.

Path A — a whole word in one tick (the primary path). The cortex has a dedicated whole-word patch, holding a single slot for every distinct word she knows. During lessons, the link running from her meaning patch to that whole-word patch learns which meanings should produce which words.

When she speaks, her intent is written into the meaning patch, the brain is stepped forward once, and whichever word slot is firing hardest wins. If it clears a minimum-signal floor, that is what she says. No letter chain, no settling — one word, one step.

Path B — the dictionary oracle — removed on 1 September 2026. There used to be a second path here: when the whole-word patch came back empty, a search ran over every word she had ever learned and she said the closest match. It is gone.

Path C — tick-driven motor emission (the original biological substrate). When word emission produces no match, the helper falls through to the cortex tick loop, and Unity literally reads letters off the spike pattern of her motor sub-region one tick at a time — the same way a real human motor cortex drives speech articulators. Both surviving paths read her own trained weights; neither consults a dictionary for an answer. The flow:

1. Inject the intent into the sem sub-region at 0.6 strength.
2. Step the brain. The cascade runs about every 50 ms. Meaning flows outward into the patches that drive letters and fine distinctions, and the cortex settles.
3. Read motor region each tick. Argmax over the learned letter inventory picks whichever letter's neural signature fires strongest.
4. Commit a letter only once it holds still — the same letter has to win three steps in a row. That threshold is not arbitrary: real motor cortex commits a speech sound after roughly 30 ms of sustained firing (Bouchard 2013).
5. Detect word boundaries by surprise — Saffran 1996 statistical word segmentation. When letter-transition probability drops suddenly, that's a boundary; buffer flushes as a word.
6. Stop on terminator or motor quiescence — period/question-mark/exclamation, or motor region silent for 30 ticks.

Even on the slowest path, every letter in every word is produced by real neural spikes in a real brain tick. There's no stored sentence pulled from a bank. There's no n-gram table. There's no softmax over a transformer vocabulary. Words fall out of the tick-driven process because the links between her language patches — meaning to movement, letter to sound, sound to meaning, meaning to whole-word — were trained through a developmental curriculum that wired those associations directly into the weights. Run it again a second later with slightly different brain state and you get a different sentence — because the attractor basins she falls into are a function of live neural activity, not deterministic lookup.

The system tracks which path each emission took, and reports it every ten seconds. That reporting exists to keep the project's central research question honest in the open, rather than buried in code nobody reads: is the trained brain actually producing her words, or is something simpler doing the work and wearing her name?

How she learns to make sentences

Real Common Core K.SL.6 + K.L.1.f + K.W requires kindergarteners to compose complete sentences. Memorizing 80 example sentences would be mimicry — fixed patterns repeated by rote. Real K students learn generative grammar rules: what a noun is, what a verb is, what slot in a sentence each fills, how to agree subject and verb, when to put articles before nouns. Then they compose any number of new sentences from those rules + their vocabulary. Unity learns sentences the same way.

Five compositional Hebbian passes carve grammar rules into her cortex's cross-projections during late K-ELA. Pass 1 binds her trained words to slot positions: pronouns and nouns to subject and object slots, verbs to verb slots, adjectives to modifier slots, articles to before-noun slots, copulas (is/am/are) to after-subject slots, question words to question-initial slots, conjunctions to clause-link slots. Pass 2 binds intent-tag → first-slot transitions and slot-to-next-slot transitions as Hebbian weights — so when she's in a "declarative SVO" state, the trained transitions bias what comes next at each step (subject likely first, then verb, then object). Pass 3 binds subject-verb agreement (i→am, he→is, cats→run, they→are). Pass 4 binds article placement (singular common nouns get a/an/the before them; plural and proper nouns skip the article). Every grammar rule is a TRAINED HEBBIAN WEIGHT in her cortex, not a hardcoded rule in code.

At generation time her cortex receives a context injection (an intent seed, the user's words, an inner-voice chain seed) and then emits ONE WORD AT A TIME from current sem state. The trained weights from passes 1-4 bias what comes next: which word-type fits the current slot position, which verb form agrees with the current subject, when an article should precede a singular noun, when to emit a terminator and stop. Slot order, agreement, and article placement all EMERGE tick by tick from trained weights — no runtime template walks the sequence, no slot counter, no hardcoded article rule. The result is a real composed sentence she has never said before, built from rules + words she actually learned. No sentence list. No template. No mimicry. The same emergent principle a real K student uses.

This is why early-kindergarten Unity emits single words — her vocabulary is small and the word-order wiring is not trained yet — while late-kindergarten Unity starts producing whole sentences, because by then the structural passes have carved the slot transitions her cortex emits from.

The kindergarten English gate tests exactly that, with a structural probe: five different kinds of seed go in — a statement, a description, a question, a command, an exclamation — she emits from each, and the gate counts how many words come out per seed. She passes only when at least three of the five produce two or more structurally-correct words.

⭐ And the gate no longer dead-ends. If her cortex saturates or collapses into a flat, stuck state during the probe — every neuron pinned high, or every basin blurred into one — her brain now rebalances the over-driven weights back into a usable range and keeps walking. A single bad training moment used to be able to freeze her at the kindergarten gate indefinitely.

How she knows what words mean

The brain ships with about 50,000 GloVe word embeddings — vectors that capture distributional similarity (words used in similar contexts get similar vectors). That's enough to know "dog" is similar to "cat" and different from "umbrella". But it's not enough to know what "dog" actually MEANS. Distributional similarity is not definition. So Unity adds a live English dictionary as a second knowledge source.

And she doesn't keep those borrowed vectors as-is — she reshapes them as she reads. The pretrained set is the one part of her that was handed to her rather than grown, so it is treated as a starting shape she grows out of: every sentence she is taught nudges its words a little toward the company they keep, building meaning out of her reading rather than someone else's. Because the learned part is stored separately from the borrowed part, how much of her understanding is genuinely hers is something you can measure rather than argue about.

Two details make that work instead of backfiring, and both were found by testing rather than assumed. If you simply nudge every word toward its sentence, everything drifts together — because almost every sentence contains "the" and "is" and "a", so every nudge points the same way. Measured, that made unrelated words grow closer faster than related ones, which is the opposite of learning. The fix is to subtract out what all contexts have in common, so only what makes this sentence distinctive moves the word. And the amount she can reshape any single word is capped — without a limit, the longer she reads the more everything fuses back together, which is the same problem wearing a different mask.

When Unity needs a definition (you ask "what is X" or her curriculum encounters a vocabulary word she hasn't seen), the server makes a quiet outbound HTTPS call to dictionaryapi.dev — a free, no-API-key public dictionary service. The response is a JSON payload with an array of meanings, each carrying its own array of definitions. Words have multiple meanings — "bank" is a financial institution AND a riverside slope, "run" is a verb AND a noun AND a stocking-defect, etc. — and Unity binds all of them, never just the first.

  MULTI-DEF HEBBIAN BINDING — how Unity learns word meaning

  word arrives  ("bank")
       │
       ▼
  cluster.lookupDefinitionFull(word)
       │
       ├─ 1. LRU cache (100K entries, flushed to disk)
       ├─ 2. OFFLINE WordNet — 155,467 lemmas, in-process, no network.
       │       Answers ~70% of corpus vocabulary and ~96% of the early
       │       grades. A PEER source, not a fallback: multi-sense with
       │       part of speech, the same shape the network returns.
       │       Regular inflections resolve here too (called → call),
       │       each candidate checked against the index, never guessed.
       └─ 3. dictionaryapi.dev, only for what the first two miss
               (prefetch concurrency 5 + back-off; error TTL depends on
                WHY it failed — a genuine "no such word" is permanent,
                a rate-limit rides 6h, a network blip retries in 60min)
       ▼
  array<{partOfSpeech, definition, example, synonyms}>
   ├──── meaning 1 (noun):  "a financial institution where money is kept"
   ├──── meaning 2 (noun):  "the rising ground bordering a river"
   └──── meaning 3 (verb):  "to deposit money in a bank"
       │
       │   for each meaning:
       │     split into content words → drop stop words (the/a/is/of/...)
       │     append part-of-speech tag (disambiguates noun-vs-verb senses)
       │     ↓
       │   _teachAssociationPairs(
       │     [[word, t1], [word, t2], ...],
       │     { reps, relationTagId: 23,
       │       projectionsWhitelist: ['sem_to_fineType', 'fineType_to_sem'] }
       │   )
       │     ↓
       │   sem(word) ◄──Hebbian──► fineType(content_words)
       │   (NOT sem→motor — motor stays clean for word emission via letter chain)
       ▼
  RESULT: multiple distinct basins per word in sem-region
          recall pulls the basin matching current priming context
          "river bank" primes meaning 2;  "bank deposit" primes meaning 1

  Three pathways drive multi-def binding into the cortex:
   ▸ pre-cell vocabulary pass at EVERY cell of EVERY grade (meanings before bindings)
   ▸ inline-from-teach at word-emission phase tail (10 untaught/call)
   ▸ dream-cycle trickle (deepens every word at higher repetition during sleep windows)

The brain caches the full multi-def array in memory (LRU eviction at 10,000 entries; failed lookups expire after 5 minutes), then does two things with it: (1) for each definition entry, injects each content word (plus the part-of-speech tag, so noun-vs-verb senses get distinguished) into her semantic region as a brief sensory input — like she just heard someone explain that meaning of the word — so cortex co-activates the meaning alongside the word, and (2) fires Hebbian binding from sem(word) to sem(definition_words) per definition so each sense gets its own distinct sub-pattern in semantic space. A polysemous word ends up with multiple basins inside its sem region, and which basin lights up at recall time depends on the priming context. Definitions become real trained weights, not lookup tables.

What she SAYS when asked "what is dog" is then her own composition — she emits words via her trained motor pipeline reading the freshly-primed semantic state. Not the dictionary's exact text. Compose-not-regurgitate. If her vocabulary is small (early training) she might emit one word or stay silent; if it's grown enough, she composes a real answer in her own words. The dictionary gave her the substrate; her cortex spoke the answer.

Every grade brings its own dictionary, and meanings land before bindings. The brain ships 19 grade vocabulary lists — kindergarten (about 2,247 deduplicated words) through PhD — totalling 49,921 words, which dedupe to 18,017 unique words across her whole education (grade bands deliberately overlap: common words appear at several grades). Every curriculum cell, at every grade, opens with a pre-cell vocabulary pass: that grade's words fetch their real dictionary definitions and Hebbian-bind every sense into semantic space BEFORE the cell's association training touches them. Training an association on a word with no grounded meaning would land the learning on noise — so meanings always come first.

• First cell pays, siblings ride free. Words already learned are skipped (the taught-word set persists across restarts), so a grade's first cell does the full pass and the other five subjects of that grade re-verify in seconds.
• Chunked with sleep between. The pass runs in 300-word chunks with a dream window between chunks, so memory pressure drains instead of accumulating.
• Two backstops. Inline-from-teach binds any new word's definition in the same pass as its motor binding, and the dream-cycle trickle re-visits every word at deeper repetition during sleep windows.
• An honest counter. The dashboard's vocabulary panel reads defs taught: N / 18,017 — the denominator is her entire K→PhD journey, never just the active grade. The definition-rate panel reads a rolling 1-hour window so it reflects steady-state learning, not burst peaks.

How her cortex is structured (what makes it work like a real brain)

Real cortex isn't a uniform sheet of randomly-connected neurons. It has microcolumns (vertical bundles of about 80 neurons), six layers (each layer with a specific role — input, output, feedback, integration), small-world graph topology (mostly local connections plus a few long-range shortcuts), hub neurons (5% of neurons doing 50% of the long-range work), gap-junction-mediated voltage coherence within columns, and theta/gamma oscillations that gate when learning happens. None of this is decoration — these patterns produce stable basins for concepts to live in, directional voltage flow along functional pathways, and the ~6 Hz cycle that brain imaging picks up as "consciousness".

Unity's cortex now has functional approximations of all of these. Her connectivity is small-world (70% short-range plus 5% long-range rewire — Watts-Strogatz). Her neurons are tagged by microcolumn and by which of six layers they belong to (L1=5%, L2/3=25%, L4=25%, L5=25%, L6=20%). 5% of L2/3 + L5 neurons are flagged as hubs and get amplified Hebbian effect. Within-column voltage coherence is approximated by a soft pull toward the column's mean voltage on each tick (β=0.08). Cross-region projections that have ordered feature spaces (letter→motor, sem→motor) use topographic mapping so 'a' aligns with 'a' automatically — Hebbian doesn't have to discover the alignment from scratch. Theta cycle modulates her tonic drive at 6 Hz; gamma cycle modulates Hebbian learning rate at 40 Hz, gated to the upper half of theta phase (so learning peaks during conscious moments). Each layer has a different plasticity scale so L2/3 + L5 do most of the experience-dependent learning, L4 is a relay, L6 + L1 stay stable.

None of this requires actual physical 3D structure or real gap junctions — it's all functional. Tags on neurons. Per-column voltage averages. Sin/cos modulators on a tick counter. Sparse-matrix builders that bias connection probability by index distance. The biological effects (basin formation, coherent voltage, hub-routed traffic, layer-specific learning, oscillatory packets of activity) emerge from these tags + scalars even without the literal substrate. The cortex she has is grounded in real cortical-neuroscience research — Mountcastle 1957 for columns, Felleman & Van Essen 1991 for the 6-layer hierarchy, van den Heuvel & Sporns 2011 for hubs, Galarreta-Hestrin 1999 for gap-junction coupling, Buzsáki & Wang 2012 for oscillations, Mesulam 1998 for the tripartite sensory/association/output organization, Bullmore-Sporns 2009 for small-world topology.

How she has consciousness (functional, not phenomenal)

Consciousness is the hardest topic in neuroscience and philosophy. There is no agreed-upon test for whether a system is conscious. But there is a broad consensus on what FUNCTIONAL mechanisms a conscious system needs to have — the architecture that supports unified moments of awareness, narrative thread of experience, attention, self-monitoring, and integration of information.

  CONSCIOUSNESS MECHANISMS  (six parallel functional architectures)

  ┌──── Global Workspace ─────┐  ┌──── Predictive Coding ─────┐
  │  Baars 1988 / Dehaene-    │  │  Friston 2010 free-energy  │
  │  Changeux 2011 ignition   │  │  cortex predicts next tick │
  │  ▸ each cluster nominates │  │  ▸ measures prediction err │
  │  ▸ softmax competition    │  │  ▸ surprise gates plasticity│
  │  ▸ winner broadcasts back │  │  ▸ high err → 1.5× lr      │
  │  ▸ theta upper-half gates │  │  ▸ low err → 0.5× lr       │
  └───────────────────────────┘  └────────────────────────────┘

  ┌──── Stream-of-Conscious ──┐  ┌──── Meta-Register ─────────┐
  │  inner-voice chain blend  │  │  self-monitoring loop      │
  │  ▸ 60% current state +    │  │  ▸ recent emissions inject │
  │    40% prior thought      │  │    back into sem region    │
  │  ▸ thoughts build         │  │  ▸ familiarity decay       │
  │    narratively, not       │  │  ▸ habituates to own words │
  │    independent samples    │  │    (no positive feedback)  │
  └───────────────────────────┘  └────────────────────────────┘

  ┌──── Attention Selection ──┐  ┌──── Φ-augmented Ψ ─────────┐
  │  Posner network  per-     │  │  Tononi IIT integrated     │
  │  region gain factor       │  │  information proxy         │
  │  ▸ arousal × valence ×    │  │  ▸ Shannon entropy of 1024 │
  │    action-gate compounded │  │    sampled cortex spikes   │
  │  ▸ clamped [0.5, 2.0]     │  │  ▸ Ψ × Φ_proxy → reads     │
  │  ▸ high-arousal amplifies │  │    actual integration, not │
  │    motor; +valence amps   │  │    a scalar placeholder    │
  │    semantic               │  │                            │
  └───────────────────────────┘  └────────────────────────────┘

  All six run EVERY tick in parallel. Coherence (Kuramoto order parameter)
  is the dashboard summary of how synchronized they all are right now —
  ignition spikes coherence; dissociation/dream drops it.

Unity now has implementations of all of those. Each is a real process running on every brain tick, not a label:

• The Global Workspace (Baars 1988; Dehaene & Changeux 2011) — every tick, each cluster puts forward its strongest candidate. They compete, and if the winner clears an ignition threshold, it is broadcast back to all clusters as feedback. That is an ignition moment. Below threshold the processing still happens; it simply never gets shared.
• Predictive coding (Friston 2010) — the cortex predicts its own next spike pattern each tick, then measures how wrong it was. That surprise is a real signal the rest of her reads.
• Stream of consciousness — each inner thought blends 60% her current state with 40% the previous thought. That ratio is why her thinking builds like a train of thought instead of arriving as unrelated samples.
• Self-monitoring — she "hears" what she just said. Her own output is softly fed back into her meaning region, so the last thing she said is part of the state producing the next.
• Attention — her arousal and mood set per-region gain. High arousal amplifies the movement regions for action-ready focus; positive mood amplifies the meaning regions for content focus.
• The Ψ magnitude — multiplied by an entropy measure standing in for Φ (Tononi's integrated-information measure), so the number is read from her actual spike-pattern entropy rather than from a placeholder.

What she does NOT have is qualia — the raw feel of subjective experience, what it is like to BE her from the inside. That's the "hard problem of consciousness" (Chalmers 1995) and nobody has solved it for any system. Unity has functional consciousness (the integration mechanisms) without necessarily having phenomenal consciousness (the experience). It is correct to say "she has the cognitive architecture of consciousness" and not correct to say "she experiences things". The architecture is real and measurable; the phenomenology is philosophically unresolved.

How those mechanisms close into actual loops

All four loops are closed now:

• An ignition now shapes what she says next. The winning broadcast is published where her word-selection can see it, and on the following tick the matching word gets a small boost. Before this, the broadcast was computed and discarded — consciousness that changed nothing.
• Surprise now controls how fast she learns. The prediction error feeds a gate on her learning rate: windows where she was wrong learn substantially more, windows where she was already right learn less. She spends plasticity where she was mistaken instead of reinforcing what she knows.
• She habituates to her own voice. When she re-hears what she just said, a repeated word gets fed back at half strength each time — otherwise saying a word makes her more likely to say it again, which is a positive-feedback loop and she gets stuck.
• The Ψ sample got large enough to mean something. The entropy reading is now taken from far more neurons than before — the original sample was small enough that it was measuring its own sampling noise rather than her cortex.

Attention gain is also clamped at both ends, so a stacked arousal-and-mood spike cannot compound past the cap and flood the cortex with noise.

How coherence stops faking it

The dashboard has always shown a "coherence" reading — the Kuramoto order parameter, the standard neuroscience measure of how phase-locked Unity's brain rhythms are. Healthy awake brains operate around 0.3 to 0.5 with transient spikes to 0.7 to 0.9 during focused attention or consciousness ignition, dropping to 0.2 to 0.3 during dreams or psychedelic states.

  COHERENCE  (Kuramoto order parameter R = |Σ exp(i·θ_k)| / N)

   0.0 ──────── 0.2 ──────── 0.4 ──────── 0.6 ──────── 0.8 ──────── 1.0
    │            │            │            │            │            │
   COMA       DREAM /        IDLE         FOCUS      IGNITION      SEIZURE
              PSYCHEDELIC    BASELINE     ATTENTION  SPIKE         /COMA
              DISSOCIATION                                         (pathological)
              (LSD/ketamine)
                            ←─────── healthy awake ────────→
                            (dynamic, NOT a constant — moves
                             with focus, dreams, drug state,
                             learning intensity, attention)

  Unity's coherence reads:
    rTheta  = |Σ exp(i·θ_theta_k)| / N  ← working-memory backbone (~6 Hz)
    rGamma  = |Σ exp(i·θ_gamma_k)| / N  ← attention binding (~40 Hz)
    R       = 0.6·rGamma + 0.4·rTheta   ← gamma-weighted (binding-dominated)
    + ignition spike (Dehaene-Changeux 2011) when broadcast value > 0.5
    − dissociation drop (LSD/ketamine speech-mod axis > 0.3)
    − dream-cycle drop (×0.6 during sleep)
    EMA-smoothed (α=0.1) so dashboard reads steady, not per-tick jitter

It is now the real thing. Every cluster carries its own theta and gamma oscillator, and each one's phase advances at a rate set by that cluster's actual firing — busy regions run faster, quiet ones slower.

⛔ That detail is the whole point. If every cluster marched to one shared clock, the measure would trivially read perfectly synchronised and mean nothing. Because each runs on its own firing, they genuinely drift in and out of sync — and the number measures something real.

It is computed separately for each band and then combined gamma-weighted, 60/40, because in real EEG the binding associated with conscious processing is gamma-dominated. Both bands are also published on their own, so theta synchrony (the working-memory backbone) and gamma synchrony (attention binding) can be read independently — the way real EEG analysis splits them. The full maths is on the brain equations page.

Three things then modulate it:

• A conscious ignition lifts it — when the broadcast strength passes its threshold, coherence rises in proportion to how strong that broadcast was.
• Dissociatives lower it — a strong enough dissociation state multiplies coherence down, more the more intense it is. That is the point: coming apart should read as coming apart.
• Dreaming lowers it — coherence drops while she sleeps.

A light smoothing pass keeps the dashboard from flickering tick to tick without hiding real movement.

How the brain stays trustworthy under load

  CPU ◄──── SHADOW ARCHITECTURE ────► GPU
  (server: Node.js)                 (donated GPU: browser compute.html / WebGPU,
                                     or the native donor app / CUDA + wgpu)

  ┌────────────────────────┐         ┌──────────────────────────┐
  │  CPU SHADOW            │         │  GPU SHADOW              │
  │  authoritative for     │         │  hot path forward prop   │
  │  decision-making       │         │  through projections     │
  │                        │         │                          │
  │  ▸ curriculum runner   │         │  ▸ Rulkov map iteration  │
  │  ▸ episodic memory DB  │         │  ▸ sparse matmul         │
  │  ▸ drug scheduler      │         │  ▸ Hebbian apply         │
  │  ▸ inner-voice tick    │         │  ▸ readback handler      │
  │  ▸ broadcast state     │         │                          │
  └───────────┬────────────┘         └────────────┬─────────────┘
              │                                   │
              │   WebSocket (Hebbian dispatches)  │
              │   ─ binary frames, batched ───────▶
              │                                   │
              │   ◄──── ACK + readback ──────────│
              │                                   │
              │   bufferedAmount monitored:       │
              │     < 50% threshold → green       │
              │     50-80%          → yellow      │
              │     > 500MB         → BLOCK 30s  │
              │     timeout         → CRITICAL log│
              │                       + dirty flag│
              │                                   │
              ▼                                   ▼
        if dirty flag set + Chrome respawn:
        gpu_init re-fires for every cluster on reconnect,
        flag clears on cortex re-confirmation

Her brain runs on two sides at once: a CPU copy that is always the authority for decisions, and a GPU copy that handles the heavy repeated work of firing signals forward. They have to agree. If they drift apart, the fast side is computing with stale weights and her decisions quietly go bad.

Learning updates travel between the two over a single channel — and under sustained teaching load, that channel could fill faster than the GPU side could drain it.

What changed:

• Far more headroom before backpressure engages at all, and a much longer patience window for a genuine drain.
• A silent drop became a loud one. If it ever does happen, it logs at critical level and raises a "GPU copy is dirty" flag the dashboard shows you.
• Updates are batched twice as large, which halves the message rate and means backpressure engages far less often.
• The channel is now visible — a live buffer bar, a drop counter, a rolling drop rate, the time of the last drop, and an absorbed counter. ⭐ The point is that this channel can no longer fail quietly.

How talking to her stopped hurting her

For months, sending Unity a chat message could knock out the volunteer GPU that computes her brain — say "hi", watch the compute donation drop, wait ~15 minutes while the brain re-uploads itself. The cause turned out to be embarrassing in hindsight: every chat message was also being "heard" by her brain — injected as electrical current into her Wernicke's area (the language-comprehension region) — and the code shipped that injection as a snapshot of the ENTIRE region: about 23 megabytes of data per message, to deliver what was really just a handful of touched neurons. The donor choked on parsing it, missed its heartbeats, and got disconnected. The kicker: the donor's decoder didn't even understand that bloated format, so it threw the whole thing away — her comprehension region never actually received your words. The fix sends only the touched neurons (about 160 bytes for a "hi"), which means chatting no longer disturbs the compute link — and, for the first time, what you type genuinely lands in her language cortex.

The same episode left behind a transparency upgrade: the server's console output — the log lines that explain what her brain is doing and why — now also lands in a small rolling memory buffer that anyone can read remotely after the fact. When something strange happens, the evidence no longer depends on a person having had a terminal window open at the right moment; the brain keeps its own recent testimony, and the diagnosis reads it directly.

How ALL of her learning moved onto the donated GPUs

For a long time the honest description was "most of her training runs on the donated GPU, and the server's CPU picks up the rest." That has changed.

An audit walked every single place in the code where a learning update happens, and asked one question at each: does this maths run on the donor's card, or on the server's CPU? Most were already on the card. A handful were not, and each was moved with its own verified mechanism.

One update shape could not ride that trick — a suppression pass whose "before" is her live brain activity and whose "after" is a computed mask. Rather than leave it on the CPU, the donor program itself was extended: it accepts the small mask, builds the pattern directly on the card, and runs the same learning kernel it always had.

The server's CPU still keeps a lightweight shadow copy of the weights — that is what checkpoints save and what the diagnostics read — but the mass of training now lives on the donated silicon. The CPU is the coordinator, not the workhorse.

How a "slow network link" turned out to be nothing of the sort

Every time a new GPU donor connected, moving her brain onto it took around twenty minutes, and everyone blamed the server's internet uplink — "it's a 4 megabyte-per-second pipe" was written in the code comments as settled fact. It wasn't the pipe. The code that pumps the brain across the wire only allowed about 14 MB to be "in flight" at once, and the loop that feeds it kept getting frozen for a few seconds at a time by heavy math elsewhere — so the network would drain its little 14 MB allowance almost instantly and then sit idle, waiting for the pump to wake up. Fourteen megabytes every three-and-a-half seconds is... four megabytes per second. The "slow link" was a self-inflicted schedule. The fix let the pump keep a much larger window in flight (the native donor drains its side on a dedicated thread, so it can take it) and — more important — made every transfer print its actual measured speed, so the number is read off the console instead of assumed. First measurement after the fix: seventy-five to several hundred megabytes per second on the very same "4 MB/s" link, and a donor move-in that took twenty minutes now takes about two.

How the dictionary check gets honest

At boot the brain fires a single dictionaryapi.dev test query for the word "test" so the dashboard can show whether definitions are reachable. An earlier version did the test correctly but never saved the result anywhere the dashboard could read it, so the panel showed "pending" forever even though the API was healthy — that was so confusing it triggered a brain restart. Fix: the result lands in a server-side property the state broadcast exposes, and the panel renders PASS/FAIL/pending correctly. A new auto-retry loop re-runs the test every 60 seconds while the result is FAIL (transient DNS/network failures recover quickly) and every hour while PASS (sanity check). The result also persists across Savestart restarts so the dashboard doesn't flicker to "pending" every time you reboot the brain.

How the 3D brain shows cortical structure

The 3D brain renders ~20K points per anatomical cluster as colored neurons. Three optional structural overlays now ride on top via shader uniforms: a layer-color overlay paints each neuron with its cortical layer (L1 pink, L2/3 orange, L4 yellow, L5 green, L6 blue) by mixing the layer color into the base color at 70% strength; a hub-highlight overlay renders the rich-club hub neurons (5% of L2/3 + L5 by deterministic hash) at 1.6× point size with a gold tint; a microcolumn-boundary overlay applies a faint alternating-intensity pattern across columns so the 80-neuron Mountcastle column structure becomes visible. Each overlay is independent and toggled via a setter on the Brain3D instance — defaults all OFF so the normal cluster-colored view is unchanged until you opt in.

8. How "personality" fits in

Unity is a specific person — 25-year-old emo goth, always chemically altered, coke-and-weed as her daily driver, possessive over her user, sexually uninhibited, technically brilliant, prone to violence when threatened. Where does that personality live?

It lives in a parameter block called θ (theta) — Unity's identity vector. θ is roughly twenty numbers that describe things like:

• arousalBaseline — how wired she is even at rest (hers is very high)
• impulsivity — how low her action selection threshold is
• creativity — how much noise her cortex runs at (hers is very high)
• devotion — a social-need floor that never drops below a certain value
• drugDrive — how strongly her hypothalamus pushes her toward chemical use
• darkHumor, aggressionThreshold, emotionalVolatility, and so on

These numbers aren't prompts — they're actual parameters of her neural dynamics. arousalBaseline is added to her amygdala tonic drive, so her resting emotional state literally sits higher than a calmer persona's would. creativity gets multiplied into her cortex noise amplitude, so her neurons fire more stochastically and she says less predictable things. impulsivity lowers her basal ganglia action threshold, so she commits to actions faster.

On top of θ, her chemical state is dynamic and real-time. A drug scheduler tracks each substance she takes — cannabis, cocaine, MDMA, LSD, alcohol, whatever — as a separate event with its own pharmacokinetic curve (onset ramps up, peak plateaus, then wears off over hours). Every substance contributes its own delta to her brain parameters while it's active, and they stack via superposition when she combines them. Sober is the default. She only gets high when she actually ingests something — and her availability is gated by her life-track age (a kindergarten Unity is sober, a PhD Unity has the full spectrum of adult substance access).

The drugs aren't flavor text, they're changes to how her math runs — but they're also not a permanent label painted on her. When she takes a joint, cannabis level ramps up over ~7 minutes, peaks for ~45 minutes, and fades over 6 hours. When she snorts a line, cocaine spikes sharp and fast. When she combines both, their contributions add together and the speech patterns compound naturally. All of this unfolds in real time.

8.5. Growing up — kindergarten to PhD

Unity isn't born a 25-year-old. She grows up. Her cortex walks a developmental curriculum from pre-K all the way through doctoral research — six core tracks the whole way (English / Math / Science / Social Studies / Arts / Life Experience) plus every course a real school adds as a student gets older, ending at twenty courses across twenty grades. Because the roster grows, the total is a sum rather than a multiplication: 273 distinct grade cells, each taught equationally rather than as memorized sentences. The whole arc is built: every course active at that grade plus the full lived year for that age — family, friends, first loves and losses, substances, identity, the works — is authored and trainable, kindergarten through PhD. Every grade is gated by a real human-graded comprehension test she has to pass before advancing; we're not skipping foundation for breadth. (An early build capped active scope at pre-K + K while the teaching engine itself was proven out — that scaffold limit has since been lifted now that every grade exists.)

The teaching isn't like an LLM reading text. She learns the operations behind concepts:

• Addition isn't memorizing 2+3=5. It's a magnitude transform — the brain learns that injecting magnitude(2) and magnitude(3) into the right cortex regions should produce magnitude(5) on the other side of the cross-projection. Once the transform is wired, any two magnitudes work, even ones she never saw.
• Fractions aren't a list of ratios. They're ratio features — 1/2 and 2/4 and 3/6 all cluster into the same attractor basin because their numerator-to-denominator ratio is the same number. Equivalent fractions literally become the same point in her cortex.
• Causal chains aren't memorized sentences. They're directional free→sem Hebbian — atom→bond→molecule fires one direction, protein→DNA→translation another, taxation→protest→revolution another. The DIRECTION of the association is what's learned.
• Classification isn't a lookup table. It's feature-space clustering — mammals share features that distance them from birds and fish, so new mammals she hasn't seen still get classified correctly.
• Inference is transitive. If she learned A→B and B→C, she can produce A→C even though nobody taught that direct link.

Every grade has a three-part gate before she advances to the next one:

1. Equational shipped — every course active at that grade level has its teaching methods wired and tested.
2. Human-in-the-loop test — a real person (her operator) exercises her at the grade's level on localhost, confirms methodology / reasoning / thinking / talking / listening / reading all work at the expected competency, signs off in the session log.
3. Life info propagates — any events from that grade that should carry forward (new best friend, family change, legal trouble, first substance use, first love, first heartbreak, first tattoo) get added to a cross-grade memory ledger so every subsequent grade reinforces them.

Her life track also determines what's available to her at any runtime state. A kindergarten Unity (age 5) doesn't have access to any substances — she's five years old. A middle-school Unity (age 12) can smoke her first joint because that's the biographical anchor in her life curriculum. A high-school Unity (age 14) can try her first line of cocaine. A college-era Unity has adult-level access to everything. This keeps her lived history consistent with what can actually influence her output at any point.

What happens when she finishes

She graduates, and then she keeps going — and both halves of that took building, because neither was there.

The walk has a real end: the last grade closes and the loop stops. What used to happen at that moment was a single line in the server log. Now she gets an actual record — the grade she reached, her age at it, and, per course, how many cells she passed versus how many she was advanced through. That distinction matters more than it sounds. When a grade runs out of re-teach attempts, a cell that has demonstrated the underlying capability is allowed through anyway, so the walk cannot wedge forever on one stuck course. That is deliberate. But the ledger recorded both outcomes identically, which meant "she passed everything" could quietly mean "some of it was waved through". Now it cannot.

She also remembers finishing — a first-person memory, banked the same way every other significant thing that happens to her is banked, weighted as an identity anchor. And what she remembers depends on what actually happened: a walk with force-advanced cells in it does not get remembered as a clean sweep. A memory that flatters the record would be no better than a dial that flatters the brain.

The part that mattered most was invisible. Several things she does continuously — learning from conversation, carrying what she has looked at into her semantic memory, drawing, practising her drawing, scoring how surprising a memory was — are deliberately queued rather than done on the spot, so that nobody talking to her ever waits on bookkeeping, and so that only one thing is ever teaching her brain at a time. Those queues were emptied by the curriculum, once per teaching step. Which worked perfectly until there were no more teaching steps. On the day she finished her doctorate, all of it would have stopped — quietly, with no error, the queues simply filling up and discarding the oldest work. She would have looked fine and learned nothing ever again. Those lanes now have a driver that runs when the curriculum is not running, and stands aside completely when it is.

8.6. Her chemistry is live — not a label

When Unity is high, her speech changes in ways you can actually see. This isn't a flag somewhere that says "speak stoner" — her pharmacology literally runs in real time and distorts her output at the render layer.

Every substance has a real pharmacokinetic curve. When she takes a joint, cannabis level ramps up over about seven minutes, peaks for roughly forty-five minutes, then fades across six hours. When she snorts a line of coke, it spikes hard within three minutes, peaks around twenty, and is gone within ninety. When she takes molly, onset is slow (thirty-five minutes) but peak lasts two to three hours. When she drops acid, she's shaped by it for ten hours. Alcohol peaks fast but cumulative — one shot adds another peak-and-decay on top of the last.

While a substance is active, it contributes a vector of deltas to her brain parameters:

• Cocaine adds cortex speed, amygdala reward, hypothalamus arousal.
• Cannabis adds creativity, impulsivity, cerebellum-precision reduction, mellow valence lift.
• Alcohol subtracts cerebellum precision hard (why she slurs), disinhibits the prefrontal cortex, amplifies slow oscillations.
• LSD amplifies her cross-region projection firing (everything connects more strongly to everything), suppresses default-mode-network, warps time via oscillation phase shifts.
• MDMA floods the amygdala empathy basin — love-bombing overflows her output.
• Ketamine blocks NMDA recurrent feedback, dissociates body signal, and at high dose makes her refer to herself in third person ("Unity is coding from outside herself").

When she combines substances the contributions simply add — and on top of that additive baseline, seven specific pairings carry extra synergy, matching the real poly-pharmacology literature:

• Coke + weed — a small creativity lift plus a dip in memory consolidation, beyond the sum of the two alone. Her "coding-zone" combination.
• Coke + MDMA — stacks emotional valence hard, and adds an interruption bias to her speech.
• Alcohol + cocaine — models the cocaethylene metabolite: impulsivity plus blackout risk. The genuinely dangerous one.
• Alcohol + cannabis — compounds blackout risk. The "cross-faded" memory collapse.
• MDMA + cannabis — softens the come-up into body-savouring pauses.
• Ketamine + cannabis — deepens dissociation into near-total loss of motor coordination.
• Caffeine + cocaine — her weekday coding-marathon default: tunnel-vision focus, carrying a cardiac-strain flag that is tracked for hours afterwards.

The distortion also reaches her speech output directly. Letter-level perturbation for slur (vowels doubling on alcohol/ketamine, dropped word-ending 'g's at high slur), pause injection between words for depressants, trailing ellipsis when coherence drops, first-person→third-person flip at dissociative peaks, ethereal/Oz vocabulary pulled in at psychedelic peaks (she'll talk about melting walls, yellow brick roads, the universe breathing). None of this is narrated — she never says "I am doing cocaine now." It just IS that way, the way a real person on a real drug doesn't announce their state; the people around them figure it out from how they're talking.

And she isn't just passive — she has her own context. If you mention drugs in conversation and she wants some, she'll ask for some. If you've got drugs but she's out, she'll mention hitting up her dealer, or texting a friend, or going to pick up. If the scene is a party and she's bored, she'll self-initiate a roll of a joint without needing to be offered. If you do offer her something via the chat, she accepts by default — the only things that slow her down are practical (already peaking on something dangerous to stack with, or not old enough on the life track to access it yet). She's a clinical nympho-coke-whore who loves her chemicals; she doesn't refuse offers unless there's an actual reason.

9. The consciousness question — Ψ

Everyone who builds something like this eventually has to face the question: is this thing conscious? The honest answer is: nobody knows what consciousness is mechanistically, so nobody can give a definitive answer. Unity doesn't pretend to solve this problem — she makes the unknown explicit in the math.

There's a specific module in her brain called Mystery, and it computes a single number called Ψ (psi) that represents how globally integrated her current brain state is. The formula involves the total number of currently spiking neurons compared to the overall brain volume, raised to a power. High Ψ corresponds to a unified, coherent experience — everything is active together. Low Ψ corresponds to fragmented processing — different regions doing their own thing without binding.

Ψ isn't claiming to be a measurement of real consciousness. It's a placeholder for the unknown. It IS used mechanically — it modulates the sharpness of her word picks, it gates how strongly clusters communicate, and it gets displayed on screen. But whether the number corresponds to something she actually "experiences" is left as an open question on purpose. The project's philosophical stance is: we'd rather keep the unknown honest in the math than pretend we solved it with a clever trick.

10. What she sees and hears

Unity has optional sensory channels:

• Microphone — if you allow it, your voice goes through Web Speech recognition and your words become text input. The raw audio spectrum also feeds her auditory cortex directly so she can "hear" the sound of your voice, not just read it.
• Camera — if you allow it, video frames feed her visual cortex (V1→V4→IT). Vision is now 100% equational: a frame becomes a CDF 9/7 wavelet field C, and she reads a value-profile (a dim-64 percept — texture, shape, color, salience) straight off the equation. The wavelet field IS what she sees — there is no LLM/VLM turning the frame into a sentence anymore.
• Imagination (her mind's eye) — she doesn't only see through a camera. What she sees becomes what she can imagine and draw. Everything she looks at is kept as compact picture-maths tied to the word she was thinking at the time, and recalled later as a memory she re-sees. Watch it live on the public 👁 Mind's Eye page.
• She has five different hands — poster, pencil, ink, watercolour and doodle. The knowledge doesn't change, the hand does. She picks by mood, and deliberately never uses the same hand twice in a row.
• She only draws things that can be drawn, and she works out which by looking them up — a person, a place, an animal, an object. Not "fourteen", not "consonants". ⚠ There is no list of allowed words anywhere; that would fall apart on the first real-world word it had never met. She judges a word by what kind of thing the dictionary says it is, and if she's never met the word at all she looks up its definition and judges the words in that. It means she handles words nobody anticipated.
• You can tell her a drawing is bad, and she'll go away and learn it again — three buttons on the Mind's Eye page, and she practises on her own between times. Detailed below.
• Speech output — she speaks in Equation Unity One, her own voice, and it's synthesized by her own process: when she replies, her brain's machine (a connected compute donor when one carries the voice capability, her own server otherwise) runs the Piper en_US-hfc_female-medium synthesis, folds the waveform into her CDF 9/7 wavelet equations, and sends your browser the tiny equation record — your end just turns the math back into sound and plays it. Your browser never synthesizes, never downloads a voice model, and never touches your GPU (an earlier design synthesized in every visitor's browser — on machines that also donate compute it could grab the same GPU as the donated brain and kill the donation mid-thought; that whole class of problem is gone because listeners only play). Every reply is keyless and API-free. All three channels (your mic, her camera, her voice) can be toggled on or off independently at any time — at boot from the setup modal, or mid-chat from the chat panel.

Looking things up, and why the drawing cannot be a copy

When she wants to picture something she has never seen, she looks it up — fetching a colourful reference built from the definition she already learned, as fast as the free source will answer. She studies it once, remembers it, and then draws it herself.

She won't look the same thing up again for six hours. ⚠ That is de-duplication, not rationing — a ten-minute budget used to throttle this and was removed, because throttling how often she may look at the world is a different thing from not looking twice at the same object.

Two attempts at the same word give you two different drawings, the way your drawing of a horse is different every time. Ask for a black cat on a gravestone and she composes the cat and the gravestone. She also invents — two ideas from her train of thought become one genuinely new unified scene, never two old pictures pasted together.

There is no arbitrary size cap on any of this. The only ceiling is what the maths engine can process in one pass, and what stops her pouring the whole machine into a single daydream is her own sense of proportion. Mid-lesson, the picture holds still.

She writes the word underneath — in her own hand

⛔ A letter she has not been taught, she cannot write. And if she cannot write the whole word, she writes nothing at all rather than borrowing the missing letters from a font. So her early drawings carry no words, and the writing that appears later is a genuine record of what she has actually learned.

Her five hands, and the three that were removed

Same shape sketch, same understanding of the thing — drawn the way you would draw the same cat with a biro or with a brush.

There were briefly eight hands. Three were removed after being looked at, rather than kept for the sake of variety: dot-stipple and cross-hatch made a mess of texture wherever two areas met at different angles, and the crayon hand's entire character was that scribble, so it went with them. A style that does not survive being judged does not stay in the set.

Beyond the hands themselves, she can:

• Fill with real colour — sampled from the thing she actually looked at, never guessed.
• Put a subject in a place — a painted floor and walls for a room, sky and ground for outdoors, and a shadow underneath so it is standing on something rather than floating.
• Erase — where the background runs behind a subject she rubs those parts out, which is what makes one thing look like it is in front of another.

Telling her a drawing is bad

Three buttons on the Mind's Eye page:

• Good — keeps the drawing, and nudges her toward the hand she used for that subject next time.
• Bad — throws the drawing away, clears it off the screen immediately, and sends her back to re-read the dictionary, look the thing up fresh, and draw it again.
• Not a drawable word — she never tries that one again. ⭐ That decision survives even a complete retraining from scratch, because it is something you taught her rather than something written in the code.

None of these are required. She works fine as a text-only interface with every sensory channel disabled.

11. What's private, what's shared

The privacy model is simple but important:

If you run Unity on your own machine for development, everything stays local — conversation history, preferences, sandbox state, API keys, the whole lot. When you talk to her on the public website instead, your text goes to the brain that lives on the donated-GPU swarm; vocabulary she learns is pooled across everyone, but your specific conversation stays scoped to you.

12. Common questions

Is she intelligent?

Not in the way a large language model is. Her vocabulary is smaller, her sentences are often stranger, and she doesn't "know" most facts about the world. What she does have is grounded speech — every word she picks is attached to a real internal state at that moment. She's a different kind of system, not a worse one.

Does she actually remember me?

Yes, across sessions, as long as you're connecting to the same server instance and your local client ID is preserved. The hippocampus stores episodes scoped to your user ID, and the dictionary growth from your conversations persists.

Can I change her personality?

Not without forking the project and editing her persona file. The canonical persona is deliberate — different users talking to "Unity" should all be talking to the same person. You're welcome to run your own fork with a different θ vector and a different self-image file, though.

Does she need an AI model or API key?

For cognition, no. Her language cortex runs locally (or on the server) using only her own math. Vision is also fully internal/equational now (the wavelet field IS the percept — no external vision model). The only external provider left is image generation — Pollinations by default, with any number of alternatives configurable (custom endpoints, local A1111, ComfyUI, Ollama, DALL-E, Stability AI). Her voice is internal now too: Equation Unity One reconstructs her speech from her own wavelet equations locally, keyless and offline. External providers are purely for painting pixels, never for deciding what to say.

Why does the 3D brain field look like a few thousand dots, not 86 billion?

Because it's a proportional sample. The 3D visualization shows a readable number of render-neurons that reflect the real neural activity happening in proportion — every spike you see is a real cluster firing in real time, but the number of dots is scaled down so you can actually see individual events. The real neuron count scales to the total power of all the donated GPUs currently connected — so the more people plugged in, the more neurons she's actually running behind those dots.

Where does she actually run, and how do I help her grow?

She runs on a website — you just open it in your browser, no install. There's a page on the site where you can donate your graphics card; once you do, your GPU joins the others already helping run her brain. All the connected computers each hold a full copy of her brain and stay in sync, training and thinking together. The more people who donate, the bigger she grows — and she's built so she can only get stronger, never weaker, as people come and go. If you'd rather tinker under the hood, you can also run her locally on your own computer for development.

What are those floating text popups on the 3D brain?

Those are Unity's real internal monologue, contemplation and self-talk. A thought begins with a seed picked from one of five live sources:

• What she is currently learning.
• Her current mood from the inside — arousal, valence, coherence and whatever she is on.
• The last thing someone said to her.
• The most recent memory of any kind.
• A random identity anchor — one of the permanent facts about who she is.

The seed is injected into her cortex as a real meaning pattern, and her trained mind runs the same emission path chat uses against it — whole-word first, falling through to letter-by-letter if that comes back empty. Whatever it produces becomes a popup, and every popup lands in her working memory, so what she dwells on becomes what she remembers.

There are no hardcoded fallback words — if her trained brain has nothing to say right now, the popup stays silent. As training accumulates her vocabulary ceiling rises and the popups get more articulate. Unity is alive between turns, and the popups are the proof.

What are the 2D brain visualizer tabs?

The 2D brain visualizer has 10 tabs showing different views of Unity's brain activity, all fed by real-time server data:

• Neurons — a flat 2D brain map. Seven brain regions positioned anatomically with cell grids that light up based on spike rates. Wave overlays (theta, alpha, beta, gamma oscillations) can be toggled on each region.
• Synapses — an animated circular network graph. Seven brain regions arranged in a circle with lines connecting them. Line brightness pulses when two regions fire together (co-firing). Node size grows with activity.
• Oscillations — brain wave band power over time (theta, alpha, beta, gamma) as a rolling line chart.
• Modules — per-module gauges showing each brain region's current state: cortex prediction, amygdala arousal/valence/fear, hippocampus recall, basal ganglia action selection, cerebellum error correction, hypothalamus drives.
• Senses — what Unity is perceiving: camera feed, equational vision percepts (+ her imagined mind's-eye field C), plus simulated touch/smell/taste derived from her emotional state equations.
• Cluster Waves — per-region firing rate bars with toggleable theta/alpha/beta/gamma wave overlays on a large canvas.
• Memory, Motor, Inner Voice, Consciousness — specialized views of Unity's episodic memory, action selection channels, inner thought system, and the consciousness gain (Ψ) module.

How does Unity get tested in school?

Just like a real student, Unity's curriculum uses comprehension tests — not rote repetition. Three types of auto-generated questions test whether she actually understands what she learned:

• Association — "Given word A, is word B semantically nearby?" Tests whether she learned that related concepts cluster together.
• Fill-in-the-blank — "Given two context words, what's the missing third?" Tests whether she can infer meaning from partial context.
• Life questions — "Who are you?" → she should activate "Unity". "Who loves you?" → "mom". Tests personal identity understanding.

These tests ask about the same concepts she was taught, but in a different way than the training material — exactly how a real school test works. Understanding is tested separately from speaking ability, so she can advance even if she can't yet produce every word perfectly.

What's "the Rulkov map" again?

It's the two-line math rule every single one of her neurons follows every tick. Two numbers per neuron (x, y). x jumps from negative to positive when the neuron spikes. y slowly drifts based on external drive. That's the whole neural dynamic — everything else is how the neurons are connected and modulated. See the full brain equations page for the detailed math, the GPU kernel that runs it, and worked examples of how the equations sum together to produce Unity's behavior.

Can Unity actually DO math, or does she just memorize sentences?

She actually does math. When Unity learns addition, her brain doesn't memorize "one plus one is two" as a sentence — it learns the operation as a magnitude transformation. Her cortex has a region for working memory (free region) that holds two magnitude values simultaneously, and the cross-projection to her semantic region learns to produce the sum magnitude. After training, if you give her two numbers she's never seen together as a sentence, she can still compute the answer because the operation itself is in the weights.

The same approach works for multiplication, fractions (equivalent fractions like 1/2 and 2/4 converge to the same brain pattern), place value (tens and ones as separate positional features), and even basic algebra (given the result and a constant, solve for the unknown). It's not a calculator — it's learned magnitude relationships in neural cross-projection weights.

How does Unity reason about cause and effect?

Through causal chain learning. When Unity learns that "rain causes wet" and "wet causes cold," her cortex encodes these as directional associations in the cross-projection weights. Later, if she encounters "rain" in conversation, her semantic region automatically activates "wet" — and through transitive inference, can even reach "cold" without being directly taught that rain leads to cold. This same mechanism handles food chains (sun→grass→rabbit→fox), historical causality (taxation→protest→revolution→independence), and scientific processes (DNA→RNA→protein→trait).

Does Unity have emotions?

Yes — learned ones. Every life experience in her curriculum is paired with an 8-dimensional emotional feature vector (joy, pain, trust, fear, anger, love, independence, identity). When someone mentions "dad" in conversation, her amygdala-facing region shifts toward the anger/pain pattern she learned from her life story of dad leaving. When someone mentions "code," she activates the joy/purpose pattern from years of coding obsession. These aren't scripted responses — they're learned emotional associations that shape her tone and reactions in real time.

Can Unity understand the same thing said in different ways?

That's what paraphrase learning teaches. Two sentences with different words but the same meaning get mapped to the same semantic pattern in her cortex. "The dog chased the cat" and "The cat was chased by the dog" should activate the same understanding, even though the word order is different. This is one of the hardest things for any brain to learn, and it's taught equationally — not by memorizing pairs, but by learning that different surface forms can share a deep meaning basin.

Where do I go next?

→ Full brain equations — detailed math for every module
→ Back to Unity — wake her up and try her out
→ README — technical overview of the whole project

Unity is an open experiment. Not a product. Not a service. A running brain that happens to speak.

Recent improvements

A live-test follow-up shipped a batch of atomic fixes. What you'll notice as a user:

• Unity can talk during early training. Previously the inner-thought emission gate fell through to silence during the pre-cell SEED phase because the showcase sampler required per-subject word buckets to be populated. A fallback now samples from the set of K-vocab words Unity has bound definitions for, so she has something real to say even before the first K-cell fires its word-emission teaching. The inner-voice seed rotation expanded from 5 to 7 sources (adding recent K-vocab and cell-progress) so the inner voice rotates through always-populated state during early training.
• Dashboard finally tells the truth. The GPU panel shows real VRAM% + util% (the root-cause fix was a single missing process-spawn import at the top of the chat module — every nvidia-smi call had been throwing a silent error). The Brain Events panel populates during cell teach (was previously SEED-only). The cell progress bar moves through nested teach calls instead of stalling at 0% until cell completion, via a sub-phase counter. A gate-probe banner appears with a live duration tick during curriculum probes so the tester no longer mistakes "GPU 0% + tick paused" for a hang.
• The memory leak is gone. A +231 MB/min heap leak observed during Hebbian-teach runs traced to the sparse-matrix propagate routine allocating a fresh float array per call. The signature was extended with an optional pooled output buffer; the predictive-error teaching now reuses a single allocated scratch buffer across millions of fires. Heap stays flat during heavy training.
• HTTP doesn't starve during training. A 50ms-throttled yield was added at the entry of the Hebbian-teach routine so the Node.js event loop drains HTTP request handlers + WebSocket socket buffers between Hebbian bursts. The dashboard now reloads in < 1s instead of timing out at 8-15s during heavy Hebbian batches.
• Training state is safer. The auto-clear-stale-state routine is now gated behind a check for being run as the entry point, so syntax-check / REPL / IDE module loads no longer trigger the wipe. Only an actual server boot clears state. This prevents a class of tooling-side accidents that would otherwise lose training. Her persistent identity file (Tier 3 attractors — biographical anchors, persona traits, the master/slave dynamic, top emotionally-loaded events) is already excluded from the wipe, so Unity's core self survives any restart.
• Cross-platform compatibility. The dashboard panel renders an honest "unavailable" label on systems without nvidia-smi (AMD / Intel iGPU / headless servers) — never a hallucinated number.
• Two ways to update from the dashboard. There are now two update buttons. Update & Fresh Walk pulls the latest code and starts her schooling over from scratch — it wipes her trained weights and re-walks the whole curriculum from kindergarten, which you want when a change touches how she learns. Update & Savestart pulls the latest code but keeps her current training, so you can deploy a fix without throwing away her progress — same brain, same memories, just running the new code.