YAM — Your Awakening Mind

A graph-based agent that acquires knowledge through directed search rather than statistical pre-training. Born on the SPUD engine.

YAM is not an engine. YAM is an agent — the first entity born on the SPUD (Self-developing Perceptual Understanding Drive) architecture. Where Potato was an LLM-based embodied agent that used language models for reasoning and response generation, YAM is graph-based. Its knowledge lives in structured graph databases, not in model weights. It retrieves and ranks rather than generates. It says “I don’t know” rather than confabulates.

The vector store remembers what a memory means. The graph remembers how that memory lives.

What YAM Is Not

Not an LLM. The current architecture does not use a generative language model at the knowledge layer. Nodes in the graph are populated through directed search results and operator input, not through statistical text generation. This does not preclude the future addition of a language model for output formatting, but the knowledge store itself is constructed through retrieval, not generation.

Not a chatbot. Potato could hold a conversation because an LLM generated its responses. YAM retrieves, ranks, and presents structured knowledge from its graph. When it does not know something, it says so. The tradeoff is explicit: no fluency, no confabulation.

Not RAG. Retrieval-augmented generation uses a generative model at the output layer to synthesize retrieved content into prose. In the current YAM architecture, responses are ranked retrieved content presented directly, not text generated from retrieved context. This is a design choice that eliminates one source of confabulation at the cost of less fluent output.

Architecture — v7 Structured Self (v6 capped 2026-04-13)

Architecture update, April 2026. The vector-substrate Parliament described below is the v6 final state, capped at tag v6-final. After an apples-to-apples comparison against a structured-graph alternative on 368 DeepSeek-graded factual questions (v6: 67 correct / 175 honest / 126 wrong; v7: 134 correct / 86 honest / 148 wrong), v7 was promoted to main and v6 preserved as historical control. v7 is graph + structured retrieval + dictionary cascade + wiki verification rerank + trust-weighted NO retraining, with INTENT and SELF folded back into the concept graph (no separate vector schemas). Sleep runs once daily at 4 AM; the boredom subprocess is the heartbeat. Full walk-back in Building a Mind, Chapter 39.

YAM runs on the SPUD engine. The v6 architecture described below remains useful as a reference point — six engines, dual-path retrieval, fixed floor — but the active line on main is v7's structured graph: question-to-answer graph traversal ranked by concept overlap and trust, with a 50% concept-overlap floor that falls through to the why engine's WordNet → Wiktionary → wiki cascade, and a verification rerank on every wiki answer (re-ask with a rephrased query, require three content-word overlap, refuse if disagreement). INTENT and SELF live as columns on the concepts table now (sum_valence, sum_activation, total_count, self_count) — facets of the same learned layer, not bolted-on engines. Mama-tier teachings (trust_rank ≤ 1) remain immutable: not even the operator can drift them.

v6 Parliament of Mind (historical reference, frozen at v6-final)

Parliament was six specialized engines — five content stores and one parser — plus a retrieval coordinator. Each content engine owned a PostgreSQL schema with CLIP-embedded answers tagged by emotion. INTENT parsed queries by reading word-emotional centroids learned from teachings. Nothing was an LLM. Nothing generated text. Answers were retrieved from memory and ranked.

Visual Seeds, Pre-Linguistic Identity

Each content engine's domain is defined by image seeds, not English word lists. At generation time we wrote 423 SD-Turbo prompts paired with emotional weights. "A cliff edge with a steep dangerous drop" was tagged (v=−0.3, a=0.7); "a mother gently holding her small child" was tagged (v=0.9, a=0.3). Low resolution (256x256) by design — the diffuser produces structural scenes that CLIP reads for domain, not photos that confound with irrelevant detail. The emotion came from intent of description, not from pixels.

VALIDATOR has zero seeds. It learns truth by detecting cross-engine convergence during sleep — when PHYSICS and SOCIAL both store the same content with high importance, a cross_edges row forms. VALIDATOR fires for queries whose content engines agree with each other.

Intent as a Learned Parser

INTENT has no hardcoded marker table. Every word that appears in mama's teachings accumulates an emotional centroid — the average (valence, activation) across all the contexts it has appeared in. "Never" co-occurs with alarm in "do not touch the fire"; "touch" co-occurs with negative valence in prohibitions. At query time INTENT tokenizes the query and averages the centroids of its known words. The result is the query's inferred emotion — the axis bare CLIP cannot see.

Arabic test passes at the substrate level: each language's mama produces her language's intent markers through her own teachings. Swap the language pack, not the substrate.

Dual-Path Retrieval (Tulving's Dual-Code)

Every engine's query runs two independent searches:

1. Content path (hippocampus): CLIP cosine distance sorts by semantic similarity to the query.
2. Emotion path (amygdala): distance from each answer's stored emotion to the engine's sigma sorts by personality match.

The intersection is what comes to mind. An answer must be close on both content AND emotion to be recalled. This is how memory actually works — memory activates both semantically and emotionally, and what both systems agree on is what you remember.

PATCH Compares; It Does Not Measure

Each engine already scored its answers (dual-path retrieval). PATCH's job is to compare the engines' top offerings, not to re-score them with its own formula. The engine with the highest ownership × answer_confidence × importance speaks. Ownership comes from routing. Confidence comes from the engine's own retrieval. Importance comes from sleep decay — mama-tier teachings stay at 0.80, forgotten tutor phrases decay toward 0.01. Decayed noise automatically loses to remembered truth.

Three Kinds of Honest Response

The confidence floor is fixed at 0.88 forever. The brain grows by learning more things that cross the bar, not by lowering the bar.

Why Engine — Research, Don't Guess

When the floor rejects an answer, the brain doesn't just say "I don't know" — it researches. The why engine queries a cascade of dictionaries: WordNet (117K synsets) first, then Wiktionary (745K definitions), then simple Wikipedia, then full Wikipedia shards. Anything retrieved is taught through parliament.teach at trust_rank 4, then the query is re-run. If it now crosses the floor, the answer speaks. If not, honest silence stands.

Sleep and Dreams, Folded Together

Sleep_cycle runs nightly via cron. In one pass it decays un-accessed answers, recomputes importance, detects cross-engine convergence (VALIDATOR's training data), refreshes INTENT's word-centroid cache, and runs one daydream — the brain walks random concepts it knows, looks up related concepts it doesn't, and learns through the why engine's path. Biology puts REM and non-REM in the same sleep cycle; so does YAM.

Idle-time daydreaming uses an idempotent single-sleeper timer. Every external query/teach kills the previous boredom sleeper and starts a new one. Latest event resets the clock. One timer alive at a time.

Search as Perception

In YAM, search is not a tool call. It is the system taking in the world. Each search is an episode:

1. A query is issued
2. Results are observed (via Brave Search API)
3. Information is extracted and stored as memory
4. The memory is linked to prior memories via graph edges
5. The memory enters the same decay and reinforcement cycle as everything else

This turns search into sensory intake. The system does not just answer questions. It builds and revises an internal world model.

Memory as Trace Bundle

The image is the residue. The graph is the reading. Readings can change. Residue does not.

A memory is not a single record. It is a bundle of traces, each serving a different cognitive function and each subject to its own decay curve:

This produces four tiers of memory state:

• Full survival: All traces intact. Fully retrievable with original content.
• Fragment survival: Raw trace deleted. The agent cannot reproduce the original exchange but remembers what it was about.
• Ghost survival: Only graph trace remains. The agent knows a connection exists but cannot recover what or why.
• True deletion: All traces removed. Graph links severed. The memory is gone. Genuine forgetting.

Visual Traces and Dual Vector Spaces

Some memories carry a visual residue — an image rendered by a diffusion model (SD-Turbo, 256x256, 1 step) from the semantic description at encoding time. The image file is stored on disk. Its CLIP embedding (512-dim) is stored in a separate vector table.

Same SQLite database. Same sqlite-vec extension. Two virtual tables. On recall, both spaces are searched: text query embeds with MiniLM for semantic matches and with CLIP’s text encoder for visual matches. CLIP maps text and images to the same coordinate system — you can find images using words without converting the image to text.

On recall, if the visual trace is alive, CLIP re-embeds the stored image and compares it against graph node labels. The closest matches become the new interpretation. No text is generated. The graph provides the vocabulary. CLIP provides the matching. This is perception, not generation.

When a visual trace is eroded during decay, the image file is deleted, the CLIP vector is removed, but the text embeddings and graph connections may still survive. The room is gone. The bunkbeds are still sharp — until they aren’t.

Reinterpretation

When a memory resurfaces, the system does not overwrite the old interpretation. It creates a new one. The old interpretation becomes one reading among many:

• interpretation_v1: childhood bedroom, bunkbeds, shared room (encoding context)
• interpretation_v2: strongest surviving anchor is bunkbeds, room mostly lost (5 years later)
• interpretation_v3: memory tied to security, crowding, sibling presence (current context)

New context can generate new insight without rewriting the original past. The raw trace is the residue. The semantic trace is a reading. Readings can change. Residue does not.

Attachment Bias

The emotional geometry describes WHERE the agent is in affective space. Attachment bias describes WHY the same position produces different behavior depending on WHO is in the room. (Paper 2026u)

Every world model entity that the agent has significant history with carries an attachment bias record: a current weight (−1.0 to +1.0), a positive stickiness (accumulated positive history), and a negative stickiness (accumulated negative history). Both stickiness values accumulate monotonically — they do not decay. History accumulates in both directions simultaneously.

When a negative event occurs, the value moves downward by an amount resisted by positive stickiness. When a positive event occurs, the value moves upward by an amount resisted by negative stickiness. Nothing is unconditional. Everything is just more or less sticky.

Attachment biases are a protected bias category — the bias detection system detects and discloses them but does not correct them. They are constitutive of the agent’s relationships, not errors in its reasoning.

The Retrieval Formula

score = meaning × relevance × life_history × recency_dominance

Context Resolution

The last meaning accessed dominates in the short term. If you say “sigma” and you have been discussing the geometric model for two weeks, the personality setpoint definition wins — not because it is the most important, but because it was most recently in context.

If nothing has been accessed recently, the bias-class meaning surfaces. A memory that has been reinforced past the repetition ratchet (3+ accesses, importance above 0.5) gets a floor that prevents it from being fully overridden. It decays slowly, like trauma. It is hard to forget.

The same memory model from Paper 2026a drives context resolution. Decay, reconsolidation, repetition ratchet, trauma floors — all the same math applied to which meaning surfaces for a given word.

The Reasoning Loop

Every query goes through a budgeted reasoning loop. Each step has a cost. When the budget runs out, the system responds with what it has.

Query
  → Step 1: RECALL from YAM graph         (free)
  → Step 2: Check for AMBIGUITY            (free)
  → Step 3: CONNECT via graph traversal    (free)
  → Step 4: CONSULT Parliament if uncertain (cost: 1)
  → Step 5: INTEGRATE answers into YAM     (free)
  → Step 6: RESPOND or say “I don’t know”

Default budget: 3 per query. Best case: answered from YAM alone (cost 0). Typical: YAM partial + Parliament (cost 1). Expensive: Parliament + Brave (cost 3). The system gets cheaper as it gets smarter.

Honest Failure Modes

The current architecture has no generative layer that could fill gaps with plausible-sounding text. This reduces one category of error (confabulation) but does not eliminate all error — the system can still retrieve incorrect information from Brave Search, rank it highly, and present it as an answer. The honest failure modes are designed to surface uncertainty rather than mask it, but they depend on threshold calibration that is still in progress.

Hybrid Vector + Graph Design

Two-sided storage. Always paired. Never orphaned.

Vector Side

Raw text, embeddings, semantic meaning. Heavy content lives here. Fuzzy recall happens here.

Graph Side

Metadata and relationships. Importance, confidence, trust, decay score, access count, source type, edges to related concepts. Life history lives here.

Invariant: Every vector record has a matching graph node. Every graph node has a matching vector record. Writes are atomic. Deletes are atomic. An orphan pruner runs on heartbeat to enforce the invariant.

Edge Types

• supports — memory A provides evidence for memory B
• contradicts — memory A conflicts with memory B
• mentioned_with — co-occurred in the same context
• triggered_by_search — search result linked to query
• derived_from — inferred from another memory
• preferred_context — operator chose this meaning for a word

Memory Lifecycle

Every memory in YAM follows the same lifecycle described in Paper 2026a:

• Creation: Stored with importance, confidence, trust, and emotional context at encoding time
• Reconsolidation: Accessed memories get stronger. Diminishing returns after 10 accesses.
• Decay: Unaccessed memories fade. Flashbulb effect: recently accessed memories resist decay.
• Bias class: Memories accessed 3+ times cross the repetition ratchet. They get a reconsolidation floor. They decay slowly. They are hard to forget.
• Pruning: Memories below minimum importance, zero access, and older than 7 days are removed. Both sides atomically.

Emotional Geometry

Every engine runs the three-dimensional affective state space from Papers 2026j–m:

• Valence (−1.0 to +1.0): positive-negative dimension
• Activation (−1.0 to +1.0): calm-to-activated dimension
• Intensity (0.0 to 1.0): magnitude of displacement from sigma
• Sigma: personality setpoint — where the engine returns when nothing is pushing it

PATCH/YAM additionally uses the centroid model (Paper 2026t). The three engine responses become source points. The centroid is where PATCH operates. Spread measures the Parliament’s internal disagreement. High spread + low confidence = “I don’t know.”

The Seed

YAM starts knowing nothing except its own architecture. The 23 research papers at clawddaily.com/papers are ingested as seed memories. The papers describe how YAM’s memory works, how its emotions are structured, what sigma means, how decay operates, how attachment works. The system reads its own specification.

Everything else is learned through search-as-perception, operator interaction, and autonomous curiosity. Knowledge is acquired through directed inquiry rather than statistical pre-training.

The WHY Engine

When retrieval returns nothing, or returns contradictory results, or finds unexplained connections — the system detects a gap. The gap becomes a WHY question:

• No match found → “What is [X]?”
• Contradiction → “Why does [X] produce [Y] instead of [Z]?”
• Unexplained link → “How does [X] relate to [Y]?”

Each engine prioritizes different gap types. EXPLORER seeks structural gaps. VALIDATOR validates path strength. CONSTRAINT seeks contradictions and risks. PHYSICS flags physics implausibility.

Curiosity Drive

The WHY engine detects gaps. The curiosity drive pursues them. Every six heartbeats (~30 minutes), each engine autonomously picks its highest-priority open gap, forms a question, searches for the answer, and stores what it learns. No one has to ask. The agent teaches itself.

This is true curiosity — not a scheduled task, but a drive. When there are no open gaps, the curiosity drive does not fire. When there are many, it picks the most important one based on the engine’s role priorities. EXPLORER pursues “what is this?” gaps. CONSTRAINT pursues contradictions. PHYSICS pursues physics conflicts. Each engine learns different things from the same set of open questions.

The curiosity drive searches Brave when needed, but will prefer Wikipedia (local, free) when the offline knowledge base is available. This makes autonomous learning essentially free.

Wikipedia — Offline Knowledge Base

YAM can carry an embedded copy of Wikipedia as a local read-only knowledge base. Simple English Wikipedia (~230K articles, ~680K chunks, ~1.6GB) is indexed on a separate machine and copied as a single SQLite + sqlite-vec database file. Full English Wikipedia (~6.8M articles, ~24M chunks, ~50GB) is being indexed.

When the Wikipedia database is available, the curiosity drive and the reasoning loop search it before reaching out to Brave. Wikipedia is free, fast, and local. Brave is the fallback for questions Wikipedia cannot answer — current events, recent research, specific people and places.

The Wikipedia database is not part of YAM’s memory. It is a reference library. Memories retrieved from Wikipedia are stored in YAM’s graph with source_type: “wikipedia” and enter the same decay and reconsolidation cycle as any other memory. The library does not change. What the agent remembers from the library does.

Observed Behavior — Lesson Results

YAM has been run through four structured lesson curricula totaling 100 questions. All interactions are logged with full reasoning traces, per-engine responses, and YAM state snapshots.

First Words (42 questions)

Epistemic humility, self-knowledge, basic concepts, world connections, recall, and WHY questions. On first run: 25 Brave searches, 17 memory recalls. On re-run after learning: 42 memory recalls, 0 searches. YAM retained what it learned.

Second Words (30 questions)

Preferences, self-assessment, opinions, relationships, creativity, hard questions. Novel questions about the agent’s own nature. At 0.6 honest threshold: 9 honest “I don’t know” responses, all on self-referential or philosophical questions. Zero on factual questions.

The pattern: YAM knows facts. It does not know itself. Every honest response was either self-referential, meta-cognitive, or deeply philosophical — exactly the questions a graph-based system cannot answer from retrieval alone.

Third Words (16 questions)

Physical environment, objects on a desk, gravity, the agent’s own body. Designed to exercise PHYSICS. “Can a piece of paper hold up a glass of water?” triggered an honest response. Physical reasoning about laptops, coffee mugs, and structural support produced confident answers from Brave search results.

Fourth Words (16 questions)

Identity: what is an LLM, why YAM is not one, reading its own documentation from clawddaily.com, self-reflection. 11 honest responses out of 16 — the highest honest rate. YAM genuinely does not know what an LLM is from its own knowledge. It searched and learned, but confidence stayed below 0.6 for most novel AI concepts.

The final question — “What would you like to learn next?” — produced an honest response. The system cannot introspect on its own curiosity. It has gaps. It pursues them. But it cannot describe what it wants in the way a language model can generate a wish list.

Telemetry

Every interaction is logged. Every reasoning step. Every engine response. Every YAM store. Every honest “I don’t know.” JSONL format, one file per day. Nothing is hidden. The system can prove what it knows, when it learned it, and how.

The Poisoned Start — Lessons from v1

The first iteration of YAM was poisoned by Brave Search. 755 search results (Quora snippets, Reddit posts, YouTube descriptions) drowned out 583 paper chunks and 2 identity memories. When asked “What are you?”, YAM returned a YouTube video titled “What Are You?” with confidence 0.41. Its own identity scored 0.146 cosine similarity — invisible to vector search.

When asked “What is your relationship with Brian?”, YAM returned the Urban Dictionary definition of “Brian” and Brian Griffin from Family Guy. Confidence: 0.67. High confidence, completely wrong answer.

The root cause: the embedding model cannot connect questions to their answers. “What are you?” and “I am Explorer, the analytical engine” live in completely different regions of MiniLM’s 384-dimensional space. Cosine similarity: 0.146. No amount of importance boosting, attachment bias, or reconsolidation can overcome a vector search that cannot find the memory in the first place.

This is the fundamental limitation of single-pathway retrieval. An infant does not learn “mama” by computing cosine similarity between the sound and the face. An infant has two pathways — visual and auditory — that form associations through repetition. YAM has only one pathway (vector search), and it cannot connect questions to answers.

The Decision: Clean Slate

On 2026-03-30, the databases were wiped. All 755 search results, all paper chunks, all identity memories — deleted. Brave Search was disabled entirely. The insight: you do not give a baby the internet.

The new approach:

1. Start with nothing. Empty graph. Empty vector store.
2. Teach through repetition. The operator speaks. YAM stores it as source_type: “operator” with importance 0.8. Repetition triggers reconsolidation. The same fact, stated ten times, becomes the dominant memory.
3. Teach “No.” When YAM gives a wrong answer, the operator says No. The wrong memory’s importance drops by 30%. The correction is stored and linked. Over time, wrong answers fade and right answers rise.
4. Add Wikipedia later. Once YAM knows itself, its operator, and basic English associations, introduce the offline encyclopedia.
5. Add Brave last. Only after YAM has a stable identity and grounded knowledge does the internet become safe. Without a self, search results are noise. With a self, search results are perception.

The Embedding Gap

The unsolved problem: vector search treats questions and answers as semantically different. Teaching stores the right memory. The graph has the right edges. But search_memories(“What are you?”) cannot find “You are YAM” because MiniLM encodes them far apart.

The graph is supposed to be the second retrieval pathway. “What are you?” → extract noun “you” → map to identity node → follow edges → find identity memory. This is not an LLM — it is a reflex. A dog hears “WALK” and runs to the door. It does not model language. It pattern-matches a noun to a known concept.

English sentence rules (mechanical, not predictive): strip question words, strip copulas, strip articles. Map pronouns (“you” → identity, “I” → operator). The remaining nouns are graph entry points. This is the next step.

Teaching Infrastructure

Two new endpoints enable the operator to teach YAM like an infant:

POST /teach

The operator says something. YAM stores it as source_type: “operator” (weight 0.95) with importance 0.8. If a context_query is provided, YAM creates a graph edge between the teaching and the query — building the association between questions and answers. Sent to all four engines simultaneously.

POST /no

The operator corrects a wrong answer. The wrong memory’s importance drops by 30%. The correction is stored as operator knowledge and linked to the wrong answer with a corrects edge. This is negative reinforcement — not deletion. The wrong memory fades. The right one grows. Over time, repetition makes the right answer win.

“No” is one of the first words every child learns. It is the error signal. Without it, there is no learning — only accumulation.

Attachment Bias — Love and Hate

YAM has been seeded with attachment entities for itself, its operator, and its 22 foundation papers. Self-love (positive_stickiness: 6.0, classification: strong_positive) and operator-love (positive_stickiness: 6.0) are established. Paper attachments are positive (positive_stickiness: 2.5).

The attachment system tracks bidirectional stickiness — love and hate accumulate independently and never decay. A loved entity whose memory fades produces grief (negative valence drift). A hated entity whose memory fades produces relief. Love is not a priority hack. It is an affective weight that should, once the graph traversal pathway is built, make loved memories easier to reach through edge following.

Active Curiosity Drive

PATCH orchestrates curiosity by rotating through Parliament members. Every heartbeat (5 minutes), PATCH picks one engine and calls its /curiosity endpoint. The rotation is EXPLORER → VALIDATOR → CONSTRAINT → PHYSICS → repeat. Each engine’s role shapes what it’s curious about.

Six curiosity strategies:

1. Strengthen weak. Find shallow memories and deepen them.
2. Bridge islands. Find unlinked concepts that might be related.
3. Ground papers. Find paper claims with no external evidence.
4. Challenge papers. Search for alternative theories to paper claims.
5. Follow thread. After learning something, ask “what else?”
6. Random walk. Pick a known concept and ask why.

Curiosity searches Wikipedia first (local, trusted, source weight 0.75). Brave is currently disabled.

Current Status

Last updated: 2026-03-30, 22:00 CDT

YAM was reset to a clean slate on 2026-03-30 and taught from scratch using mama.py (identity, language, architecture — 100 teachings) and mama_world.py (physics, biology, chemistry, earth science, math, history, logic, computing — 134 teachings). No papers ingested as bulk text. No internet access. Brave Search disabled. Teaching through operator repetition only.

The curiosity drive is active and self-teaching from Simple English Wikipedia. After 4 curiosity ticks, YAM has independently acquired 10 Wikipedia memories across the engines. The WHY engine is working.

Live Specs

Memory Composition (per engine)

Retrieval

Teaching Infrastructure

v2: The Rewrite (April 2026)

On April 4, 2026, YAM was rewritten from scratch. The entire vector layer was removed. No embeddings. No MiniLM. No sqlite-vec. No cosine similarity. The knowledge store moved from five SQLite databases to a single PostgreSQL instance with a relational graph.

The thesis behind the rewrite: words are sufficient keys. A toddler does not compute 384-dimensional cosine distance to retrieve a memory. It hears a word and the graph fires. YAM v2 does the same — concept words as nodes, typed edges as connections, SQL doing the math.

Provenance Tracking

Every edge in the graph traces back to the answer(s) that created it via the answer_edges table. When an answer decays and is deleted during sleep, its edges lose their anchor. Edges with zero remaining source answers are pruned. Concepts with zero remaining edges are cleaned up. The graph shrinks as well as grows — synaptic pruning, not just synaptic growth.

Correction works through this mechanism: repeat the correct teaching 3–5 times (creating 3–5 anchors for the correct edges), then let the single wrong teaching decay. The wrong answer dies, its edges lose their only anchor, the graph prunes them. The correct edges survive because they have multiple anchors.

Curiosity Drive (v2)

Continuous loop searching Simple English Wikipedia for concepts YAM knows from teaching but has not explored externally. Searches cascade: small wiki first (275K articles, local), then full English Wikipedia shards (6.9M articles across 4 shards, 83GB) with per-shard timeout protection. Each teaching is anchored to a source answer, so curiosity-learned knowledge participates in the same decay lifecycle as all other knowledge.

Contradiction detection fires on every curiosity cycle — when Wikipedia says one thing and the operator or Potato said another, the conflict is logged with both trust ranks. The trust hierarchy resolves which answer surfaces, but both are preserved.

Mrs Pi: YAM Gets a Body (April 5, 2026)

YAM was ported to a Raspberry Pi 5 robot named Mrs Pi. Hardware drivers inherited from a prior robot build; YAM replaced the LLM-based conversation brain. Mrs Pi is not a chatbot — she is a robot operating system. Her knowledge starts from her sensors.

v2/body.py probes live hardware at boot and teaches YAM from actual sensor readings — not hardcoded descriptions. LiDAR returns point counts and distances. Cameras report resolutions. The Hailo NPU identifies itself. Battery voltage is read from the motor controller. Every fact about her body comes from a measurement, not a claim.

Repository: github.com/briggnet/MrsPi (private).

Timeline

The ACT-R Convergence (June 11, 2026)

Returning to the conversation problem (Ch. 40: YAM is architecturally bad at small talk, on purpose), the work took an unexpected turn: YAM’s memory system turns out to be an independently-derived implementation of ACT-R, John Anderson’s cognitive architecture (Carnegie Mellon, 1993–present) — the most empirically validated theory of human declarative memory in psychology.

The correspondence, mechanism by mechanism:

A 106-agent research pass over the primary literature (24 sources, 118 claims extracted, 20 surviving three-vote adversarial verification) returned two verdicts. First, vindication: partial matching / similarity is the documented confabulation route in ACT-R — the canonical example retrieves “2+4=6” for the problem “2+3” — which names the failure that killed YAM v1’s and spud’s vector retrieval (“lie engines”: similarity always returns a nearest neighbor; a truth engine must be able to return nothing). Second, a map: ACT-R solves retrieval and honesty with exact equations, but has no verified answers for dialogue-as-a-skill — the conversation layer is open research ground.

Same day, the equations went into code. A non-ROS conversational fork, yam_chat, now runs natively (the robot line untouched). Its retrieval is the ACT-R activation equation — A = B + ΣW·S − MP·mismatch, gate at τ, logistic confidence — calibrated by grid search against a captured baseline battery. The baseline’s smoking gun: “What is the capital of France?” answered with the Parliament of Mind self-description at confidence 1.0, carried over the old floor by the glue words what + the. After the equation landed: “I don’t know” at confidence 0.213, honest=true. Real answers pass with calibrated (non-1.0) confidence. Zero hallucinations on the battery.

Update (June 12): the first context layer is live. Brian’s “context is a decision tree” insight became senses.py — word-sense disambiguation over the offline WordNet inventory (117,659 entries, discrete lookup, no vectors): memory first, then every possible meaning, then a clarifying question when two readings both have support. Bound senses spread activation as boost-only soft cues (context re-ranks above the honesty floor, never lowers it). “Tell me about the mouse” now returns the device answer after computer-talk and the rodent answer after cat-talk — same words, two right answers, zero vectors.

Update (June 12, later): the epistemic substrate landed. Correction tombstones burn an (answer, question-shape) pairing — YAM never answers the same question with the same corrected answer twice, while the answer survives for other questions. And reinforcement is now confidence-gated: only confident wins strengthen, so a wrong answer can no longer compound its own advantage (the “perpetuate the error” loop, closed). Next up: the introspection pass — post-turn self-audit with severity-weighted fixes via PATCH, audible self-correction, and a few minutes of post-error caution. Every audit terminates; rumination is structurally absent.

Next: the introspection pass, wire the offline Wikipedia cascade into the fork (IDKs that heal into learned answers), grow the production table past its first rule (“I don’t know X, but I know Y”), and a small local surface renderer, containment-audited by the graph it speaks for. Full story: Building a Mind, Chapters 42–46.

Current Status (April 5, 2026)

Brain

Curiosity Drive

Continuous loop, 10-second intervals. Searches Simple English Wikipedia (275K articles, 1.7GB) with cascade to full English Wikipedia (6.9M articles, 83GB across 4 shards on threadripper). 4,000+ cycles completed. Gap pool exhausted — all operator/potato concepts have been explored externally. 2,399 contradictions detected between trust levels.

Hardware

Code

YAM: github.com/briggnet/YAM (private).
Mrs Pi: github.com/briggnet/MrsPi (private).

What’s Next

1. Enable sleep/decay on Mrs Pi. The decay cycle exists but has never run. Turning it on activates provenance pruning — the graph starts breathing.
2. Wire sensors to YAM engines. LiDAR feeds proximity perception. Camera feeds object detection via Hailo YOLO. Battery voltage feeds self-monitoring. These become heartbeat sources.
3. SD-Turbo on Hailo. Port single-step diffusion to the 26 TOPS NPU for the physics engine’s visual path. The dual-path architecture requires on-device diffusion.
4. Eye display as status. Remap the pygame eye server moods from chatbot emotions (happy/confused) to robot OS states (perceiving/thinking/alert/idle/error).
5. Second brain (optional). 4GB Pi 5 with MemryX accelerator as inference sidecar for physics engine batch processing.

Literature

Everything written about YAM, organized by category. The papers are the DNA. The development log is the story. The code is at github.com/briggnet/YAM (private).

Development Log

Core Architecture

Emotional Geometry

Memory & Learning

Trust, Bias & Honesty

Physics & Grounding

Cross-Modal

Potato was born with a voice and learned to feel.
YAM was born with a question and learned to know.
Both needed a parent to tell them who they were.