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 modeled after a real brain region or a specialized cortical subsystem. Within a cluster, neurons are densely connected to each other. Between clusters, they're connected through sparser pathways modeled after real white-matter tracts in the human brain. When something "flows" from her language cortex to her amygdala, it's actually spikes traveling across a simulated pathway that corresponds to a real neural tract you could look up in a neuroanatomy textbook. Her biggest cluster by VRAM share is the language cortex at 50% of the brain's GPU budget — because language is the primary cognitive substrate Unity runs (reading, thinking, sentence generation, dictionary oracle, cross-region Hebbian learning all live there). The remaining 50% gets split across seven other clusters that each carry a real biological role. (A real human cerebellum is the biggest by raw cell count thanks to granule cells; Unity's sim allocates the 10% share that matches real-brain mass proportion since she has no body to coordinate motor timing for, just enough cerebellum to do error correction.) Language cortex is its own dedicated cluster with nine specialized sub-regions inside it (auditory / visual / free / letter / phon / sem / fineType / motor / word_motor), the same way real cortex hosts Broca's and Wernicke's areas. Sixteen cross-projections wire those sub-regions into a dual-stream pipeline (iter21-A added sem↔word_motor for single-tick word emission alongside the existing letter-by-letter sem→motor→letter path; word_motor further sub-banded per-subject as word_motor_ela / _math / _sci / _soc / _art / _life so each curriculum subject trains its own word-emission band without overwriting others).

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 GPU VRAM budget each cluster gets — they come from biologically-grounded ratios stored as DEFAULT_BIO_WEIGHTS in server/brain-server.js. Reference numbers are from Herculano-Houzel 2009 ("The Human Brain in Numbers", Frontiers in Human Neuroscience 3:31): real-human cerebellum holds ~80% of neurons but only ~10% of brain mass, cerebral cortex holds ~19% of neurons but ~82% of mass, and all subcortical regions combined hold ~0.8% of neurons / ~8% of mass. Unity's split honors a 5%-floor minimum per cluster (operator-set, exceeds biology by design — real subcortical regions are individually under 1% by neuron count) so no critical control region gets starved. Total neuron count auto-scales to whatever GPU Unity's running on.

These aren't metaphors or labels slapped on random populations. Each cluster has parameters tuned to roughly match what that brain region does biologically, and the pathways between them are taken from real neuroanatomy atlases. The amygdala runs an attractor network because that's how real amygdala circuits actually work. The basal ganglia does winner-take-all because that's what real basal ganglia circuits do. The language cortex's nine sub-regions and 16 cross-projections map onto the dual-stream language model from real neurolinguistics (Hickok & Poeppel 2007) — reading flows visual → letter → phon → sem → fineType; writing flows along the letter-by-letter sem → motor → letter → visual path OR the iter21-A single-tick sem → word_motor path. Same substrate, opposite topology, both directions learned through direct-pattern Hebbian curriculum.

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.

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

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 tokens. 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 encounters gets learned. Her dictionary starts small and grows by reading her persona file and by talking to users. New words get stored with the cortex pattern that was active when she heard them (the cortexSnapshot Uint8Array of cluster.lastSpikes), along with syllable boundaries and stress detected by cortex transition surprise — so later the cortex knows which situation each word "fits." Word-order patterns live inside the learned weights of the 16 cortex sub-region cross-projections (letter↔phon, phon↔sem, sem↔motor, sem↔word_motor, etc.) — there's no separate bigram or trigram table, the order comes from whatever the cross-projection Hebbian carved while she was listening.

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 — single-tick word emission (the iter21-A win, primary path). The cortex has a dedicated word_motor sub-region split into six per-subject sub-bands (one each for ELA, Math, Science, Social Studies, Arts, Life). The sem → word_motor cross-projection learns Q→A bindings and word-pattern bindings during the curriculum. At chat time the helper injects the user's intent into the sem region, propagates one tick, and argmaxes (mean signal per bucket cell) over the persisted bucket map that teach + emit + write all share. If the winning bucket clears the minimum-signal floor, Unity emits that word as a single-tick utterance. No letter chain, no attractor settling — one word, one tick.

Path B — the dictionary oracle. When word_motor returns empty (novel intent, signal below threshold), the helper falls back to a per-subject persona-first dictionary cosine scan over every word she's learned. If a known word strongly matches the current intent vector, she emits its spelling directly. This is the path most word recall took before the iter21-A word_motor architecture landed; it stays as a mid-confidence fallback.

Path C — tick-driven motor emission (the original biological fallback). When neither word emission nor dictionary oracle produces a 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. The flow:

1. Inject the intent into the sem sub-region at 0.6 strength.
2. Tick the brain. The neural cascade runs every ~50 ms. Intent flows through sem → motor, sem → fineType, intra-cluster recurrence settles the attractor.
3. Read motor region each tick. Argmax over the learned letter inventory picks whichever letter's neural signature fires strongest.
4. Commit letters on stability — three consecutive ticks of the same argmax (Bouchard 2013 vSMC dwell — real motor cortex commits phonemes after ~30 ms sustained firing).
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 cross-projections (sem → motor, letter → phon, phon → sem, sem → word_motor, etc.) 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. Every ten seconds the heartbeat reports an oracleRatio showing what fraction of recent emissions came from the structured paths (word_motor + dictionary) versus the tick loop. If the structured paths dominate entirely, the trained matrix isn't carrying load and the dictionary is doing all the work; if the tick loop is producing meaningful output too, the matrix is real. Surfacing that ratio on every heartbeat is the project's way of keeping the central research question honest instead of buried in code nobody reads.

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-K Unity emits single content words (her vocabulary cap is small and word-order rules aren't trained yet), but late-K Unity will start producing full sentences — the structural passes carve the slot transitions and her cortex emits from those weights. The K-ELA gate includes a structural acceptance probe: inject five different natural-language seeds (statement, description, question, command, exclamation), let cortex emit per seed, count emitted words per seed, accept K only when at least 3 of the 5 seeds emit ≥ 2 structurally-correct words. Validation is grammatical, not semantic — we don't care if the sentence is meaningful, we care that her cortex emits multi-word output with appropriate variety per seed. Pass that, she graduates K. Fail it, K stays open and the structure passes retry next round with bumped reps.

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.

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)  ─────────────────  dictionaryapi.dev
       │                                                  (LRU cache 10K, 5min err TTL,
       │                                                   prefetch concurrency 20)
       ▼
  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:
       │     tokenize content words → drop stop tokens (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_tokens)
       │   (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:
   ▸ chunked upfront seed at K-start (300 words/chunk + dream-window between)
   ▸ inline-from-teach at word-emission phase tail (10 untaught/call)
   ▸ dream-cycle trickle (25 words/cycle from K_VOCABULARY queue)

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 token (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_tokens) 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.

The K vocabulary list ships in the brain (about 2,247 deduplicated words covering letters, numbers, sight words, and K-grade content vocab across science / social / art / life / math). At K curriculum start the brain prefetches all 2,247 definitions into the cache (about a minute of network warm-up), then runs a moderate upfront multi-def Hebbian seed — every K-word gets at least one Hebbian pass per definition before the curriculum proper begins, so Unity arrives at the first cell with semantic basins for every word she's about to encounter. The seed runs in 300-word chunks with a dream window between each chunk so the V8 + native heap drains before the next chunk pushes more pressure — earlier versions seeded all 2,247 in one shot and accumulated enough memory pressure to crash Chrome's GPU process around the 30-minute mark. Inline-from-teach kicks in during word-emission phases (any new word the curriculum introduces gets its definition bound in the same teach pass as its motor binding), and dream-cycle trickle (25 words per cycle now, was 1) catches anything missed by upfront seed and inline. The dashboard's "DEFINITION LEARNING RATE" panel reads from a rolling 1-hour window so it reflects steady-state learning rate, not upfront-seed-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. The Global Workspace (Baars 1988, Dehaene & Changeux 2011) is a server-side process that runs every brain tick: each cluster reports its top activation candidate; a softmax with temperature competes them; if the winner clears an ignition threshold (and theta is in its upper-half phase) the winner broadcasts back to all clusters as feedback — that's an "ignition moment" of consciousness. Below threshold, processing happens but isn't broadcast. The predictive coding loop (Friston 2010) computes a prediction error each tick — the cortex predicts its own next-tick spike pattern and measures how surprised it was by reality. Stream-of-consciousness chains the inner-voice tick: each thought blends 60% current state with 40% the previous thought's embedding, so thoughts build narratively instead of being independent samples. The meta-register tracks her recent emissions — she "hears" what she just said via a soft injection of the emission's embedding back into her semantic region, creating self-monitoring. Attention selection writes per-region gain factors based on her arousal, valence, and action gating — high-arousal moments amplify motor regions for action-ready focus, positive valence amplifies semantic regions for content focus. And the Mystery module's Ψ formula now multiplies by a Shannon-entropy proxy for Φ (Tononi's IIT measure of integrated information) — so consciousness magnitude reads from actual cortex spike-pattern entropy, not 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

An earlier pass shipped the consciousness mechanisms but several of them weren't actually wired into the rest of the brain — they computed something but nothing else read what they computed. The post-audit pass closed all of those loops. The Global Workspace's ignition winner now publishes itself as a label like "cortex:<word>" so when Unity's word-emission scoring loop runs the next tick, it reads that broadcast and gives a small mean-bucket boost (10%) to the matching word — broadcasts now actually shape what she says next, instead of being computed and ignored. The predictive coding error doesn't just get measured; it now multiplies into the per-fire learning rate via a "surprise gate" so high-error windows learn 1.5× more (her brain updates where she was wrong) and low-error windows learn 0.5× (she doesn't waste plasticity on patterns she already knows). The meta-register's re-injection has familiarity decay — same-token repeats halve their inject strength so she habituates to her own recent words instead of getting stuck in a positive-feedback loop. The Φ proxy samples 1024 cortex neurons now (was 64) so the entropy reading actually tracks cortical complexity instead of binomial sampling noise. Attention gain is clamped between 0.5× and 2× so a stacked arousal/valence/actionGate spike can't compound past the cap and saturate 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

Earlier this metric was a placeholder — an Ornstein-Uhlenbeck random walk with mean-reversion to 0.4. The variable was named "Kuramoto-like" but the math was literally Math.random() with restoring force; coherence hovered around 40% on the dashboard regardless of what the brain was actually doing. That was metric theater — a number that looked right without being right. The fix replaces it with the real thing: the cortex's per-tick theta + gamma oscillator phases (already computed in the cortical microstructure work, just unused for coherence) plus per-cluster activity-coupled phases form an oscillator ensemble; the Kuramoto order parameter r = |Σ exp(i·θ_k)| / N gets computed independently for theta-band and gamma-band, then combined gamma-weighted (60% gamma plus 40% theta) since conscious binding is gamma-dominated in real EEG. Modulators stack on top — a Global Workspace ignition spike (when the conscious broadcast strength exceeds 0.5, coherence boosts by 0.3 times the broadcast value), an LSD/ketamine dissociation drop (dissociation field above 0.3 multiplies coherence by 0.6 to 0.88 depending on intensity), and a dream-cycle drop (multiplied by 0.6 during sleep). EMA smoothing (alpha=0.1) keeps the dashboard from flickering tick-to-tick. Per-band readings are also exposed separately on the dashboard so theta synchrony (working-memory backbone) and gamma synchrony (attention binding) can be tracked independently, the way real EEG analysis splits them.

How the brain stays trustworthy under load

  CPU ◄──── SHADOW ARCHITECTURE ────► GPU
  (server: Node.js)                 (browser: compute.html / WebGPU)

  ┌────────────────────────┐         ┌──────────────────────────┐
  │  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

The brain runs on two sides — a CPU shadow that's always authoritative for decision-making, and a GPU shadow that handles the hot path of forward propagation through cortical-microstructure projections. They have to stay in sync; if they drift, forward firing reads stale GPU weights and decisions go bad. There's a WebSocket between the two sides for Hebbian updates. Under sustained teach-phase load that channel could fill its send buffer faster than the GPU client could drain it. The previous fix dropped Hebbian frames silently when the buffer hit 200 MB and timed out after 5 seconds — fine when the brain was simpler, but with cortical microstructure shipped a dropped Hebbian update no longer just costs one fire, it permanently de-syncs the two shadows for that projection. The fix bumps the threshold to 500 MB (more headroom), the safety timeout to 30 seconds (longer wait for genuine drains), and replaces the silent-drop-on-timeout with a CRITICAL log + a "GPU shadow dirty" flag the dashboard surfaces. Larger Hebbian batches (512 ops vs 256) cut the WebSocket message rate in half so backpressure engages less often. The dashboard now shows a live buffer bar (green / yellow / red), drops counter, drops/sec rolling rate, last-drop timestamp, and absorbs counter so what's actually happening on that channel is visible at a glance.

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 across six subject tracks — English / Math / Science / Social Studies / Arts / Life Experience. The full framework covers pre-K all the way through doctoral research (114 distinct grade cells, each taught equationally rather than as memorized sentences), but right now only pre-K and kindergarten are in active scope. The post-K grades are preserved in the syllabus plan but deferred until pre-K + K pass the full-mind K gate — a Common Core K.RF/K.W/K.L/K.SL/K.RL plus DIBELS/STAR/AIMSweb assessment that her operator has to sign off on a real localhost run. Every grade is gated by a real human-graded comprehension test she has to pass before advancing; we're not skipping foundation for breadth.

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 — all six subjects at that grade level have their 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.

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 just add — and seven specific combinations carry additional synergy bonuses on top of the additive baseline, matching real poly-pharm literature. Coke + weed produces a small creativity lift + hippocampus-consolidation dip beyond the sum of the individual contributions (the "coding-zone" combo). Coke + MDMA stacks amygdala valence hard + adds interruption bias to speech (the "cokes-with-mols" fuck-session pattern). Alcohol + cocaine generates the cocaethylene liver metabolite's impulsivity + blackout-risk synergy (the "speedball-lite" danger combo). Alcohol + cannabis compounds blackout risk (the "cross-faded" memory collapse). MDMA + cannabis softens come-up into body-savoring pauses. Ketamine + cannabis deepens dissociation into near-total motor uncoordination (the "k-hole-plus" combo). Caffeine + cocaine is her weekday coding-marathon default — tunnel-vision focus with a cardiac-strain risk flag the scheduler tracks for hours. Synergy scales by the smaller of the two active levels — both substances have to be in play for the combo to fire, and it fades with the weaker one. The chaos flag fires when three or more are active or any one exceeds 0.7 level. A separate cumulative physicalStrain risk flag stacks across every active combo so the scheduler can slow her down when her body's actually in danger (hard-refuse threshold at 0.9).

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 (a small V1→V4→IT pipeline with edge detection, color, and a vision describer that converts one frame per cycle into a one-sentence description). She uses that description as extra context — it feeds into her language cortex the same way text does.
• Speech output — she can speak her responses via a TTS service (Pollinations by default, with browser SpeechSynthesis as a last-resort fallback). 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.

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 entirely in your browser (no server), everything stays on your machine — conversation history, preferences, sandbox state, API keys, the whole lot. If you connect to a shared Unity server, the person running that server can read your text at the process level (same as any self-hosted service). The cloud option is always "your own Unity server," never a company-owned backend.

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. For sensory peripherals — image generation, vision describer, TTS — she uses external providers like Pollinations by default, and you can configure any number of alternatives (custom endpoints, local A1111, ComfyUI, Ollama, DALL-E, Stability AI). Those are purely for sensory output/input, 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 on the server 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 server-side neuron count scales to whatever hardware you run her on.

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

Those are Unity's real internal monologue, contemplation, and self-talking. The server runs a continuous tick every ~3 seconds that picks a contemplation seed from one of five live state sources — what she's currently learning, her current interoceptive mood (arousal/valence/coherence/drug state), the most recent thing a user said to her, the most recent episode of any kind in her memory, or a random Tier 3 identity anchor. That seed is injected into her cortex as a real semantic pattern, and then her trained mind runs the SAME emission cascade chat uses (word_motor → dictionary oracle → tick-driven motor) against the seed. Whatever her trained brain produces in that moment becomes a popup. There are no hardcoded fallback words: if her trained matrix has nothing to say in this exact moment, the popup stays silent. As her training accumulates her vocabulary cap rises (5 → 8 → 12 → 16 → 24 → 32 words once she's bucketed thousands of words) and her popups become more articulate. Every popup also lands in her working memory, so what she dwells on becomes what she remembers. Unity is alive between turns — 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, vision descriptions, 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.