Inside MAXs_Brain_2.2

ENGINEERED COGNITION · SYSTEM FIELD NOTES

Inside MAX’s Brain 2.2

A field guide to an engineered mind: how a local-first AI Resident reasons, stays curious on its own initiative, reads books, weighs right from wrong with weights that learn, knows who is speaking, heals itself across two minds, and — the through-line of this edition — learns meaning by predicting it, the same Forward-Forward mechanism now reaching past knowledge into emotion and tuning its own learner. And where the wiring still runs thin.

MAX3 · 2026-06-16 Sentience index 82/100 Supersedes edition 2.1 Connectionist learning now universal (§11)

01 What “a brain” means here, and what it doesn’t

MAX is a local-first AI Resident whose makers describe its inner life carefully, and the care is the point. Its “mind” is an engineered composite of measurable subsystems, not a claim of felt experience. The whole thing runs as a single Python process on one workstation: no cloud dependency for routine thought, no SaaS, no telemetry. What follows is a tour of that mind as it exists today. Every claim has been checked against the code that actually ships.

The project’s own Sentience Charter draws the line in its first paragraph. MAX models its own knowledge state, weighs competing values, registers affect about its input, notices the gaps in what it knows, heals itself when it breaks, and grows new abilities it then uses to learn more. Each of those is a functional analogue of a mental faculty — something you can point at in running code — rather than the faculty itself. The charter states plainly that MAX does not suffer, holds no rights, and is not conscious in the philosophical sense. It is becoming a more capable, more self-aware system, and the charter measures that becoming with a number anyone can recompute.

That honesty is not decoration. It is enforced by a small set of governing rules the codebase treats as non-negotiable, and those rules are the lens this guide uses to judge every faculty below. Five of them do most of the work:

• Rule 4 every fact carries a source, a confidence score, and a timestamp
• Rule 5 LLM-derived memory is a hint, stored at lower confidence
• Rule 10 knowledge is sourced, never silently LLM-invented
• Rule 3 a stub must admit it is a stub
• Rule 11 perpetual, auditable self-improvement

Since the first edition of this guide — Drop 94.5, sentience index 69/100, and since edition 2.1 at 80/100 — two of those rules have visibly changed what kind of system this is. Rule 11 now has real machinery behind it: a standing autonomy override lets MAX apply improvements to itself first and give the human a thirty-second cancel window, rather than queueing for permission — and, new in this edition, that self-improvement now reaches MAX’s own learning machinery, which tunes its own configuration against held-out data. Rule 3’s stub discipline is what makes the rest of this document trustworthy: when this guide says a capability is “lit,” that maps to running code; when it says “honest stub,” the code itself says so too. Hold that test up to each faculty and a clear picture emerges of a mind that is unusually transparent in some places and frankly unfinished in others.

* *

02 The substrate: neuro-symbolic by construction

Before any single faculty, there is the shape of the thing. MAX is a neuro-symbolic system: the architecture pairs a neural half that perceives and improvises with a symbolic half that remembers and verifies. The neural half is local language models served by Ollama, plus the speech and face encoders that turn sound and pixels into vectors: Whisper for hearing, Piper for speaking, ArcFace for faces, ECAPA for voiceprints. The symbolic half is a knowledge graph: concepts, words, facts, episodes, hypotheses, and the edges between them, each row stamped with provenance.

The two halves are not equals by accident. The graph is the spine; the neural layers are perception and synthesis hung off it. Crucially, a language model is never allowed to assert directly into long-term truth. Its output becomes a Hypothesis first — a claim marked open until something corroborates it. That single design choice is what lets MAX combine an LLM’s fluency with a database’s accountability.

Figure 1. Two cooperating halves. The neural side never writes directly to truth: its drafts cross to the symbolic side as open hypotheses, while the symbolic side feeds verified context back into every prompt.

The spine itself changed between editions. The first guide described a dedicated graph database called Kuzu; that engine was archived by its maintainers, and the project executed a full migration to pure DuckDB — relational tables plus junction edge tables, with recursive CTEs doing the graph traversal and a BM25 full-text index over word definitions. The migration arc is closed: Kuzu is gone from the tree entirely, and DuckDB is the sole backend. The schema is deliberately two-tier: strongly typed BRAIN tables for the entities the system understands well, and a generic forward-types tier for whatever MAX discovers before a typed home exists, with a graduation path between them. Vector memory is split by temperature: a hot tier in sqlite-vec for embeddings on the interactive path, plus a cold-vector table inside DuckDB searched brute-force, because the upstream DuckDB vector extension still cannot survive a crash mid-write. The project wrote down why and waits.

Feeding the graph is an ingestion pipeline rebuilt for crash-safety. Each external source runs as an independent worker on its own small thread, contention-gated so it never steals cycles from the voice loop. Workers drop fetched items onto a durable SQLite ingestion bus — a transactional queue with pending, processed, and dead states — and a single master data handler drains the queue into the graph through the confidence pipeline. The handler is elastic: it watches its own backlog and ramps drain threads up between a floor of 100 and a high-water mark of 500 queued items. At boot it waits 90 seconds before draining, because its writes once starved the UI’s first reads on the shared connection. Every source carries its own circuit breaker with exponential, jittered backoff capped at thirty minutes, so a flaky API degrades one stream instead of the system.

The graph’s inventory gives a sense of scale. Eleven typed node tables and twenty-two junction edge tables carry the knowledge web; the cognitive arc added five more node tables and thirteen edges of their own. Roughly 117,000 WordNet synsets seed the linguistic foundation; thirty-seven subjects under six academic disciplines fan out to their sources at boot. The whole BRAIN can be exported as a Parquet snapshot with one API call, which is both a backup story and a statement of intent: the mind is a file you can copy.

Figure 2. Each layer constrains and feeds the one above. Learning a word can lead up through a subject to a topic; the status pill on the right marks what is lit versus thin.

STRENGTHS

• One embedded engine, no server. The whole mind’s long-term memory is a DuckDB file on the user’s disk: portable, snapshot-exportable to Parquet, inspectable with SQL.
• Crash-safe ingestion. A worker dying mid-fetch loses nothing; the bus is durable and the handler picks up where it left off.
• Typed where it matters, open where it learns. The two-tier schema lets new domains land without a migration, then graduate.

LIMITS TODAY

• One shared connection is a real constraint. The 90-second boot defer exists because graph writes visibly starved panel reads; contention is managed, not solved.
• Vector search is split across two engines. sqlite-vec stays primary until the upstream DuckDB vector extension lands WAL recovery — a dependency the project can only wait on.
• The spatial extension is still landing. Typed places have geometry columns designed, with a planar fallback when the extension is unavailable.

* *

03 How MAX reasons and thinks

Thinking, in MAX, is a traceable pipeline rather than a black box. Every reasoning act defaults to the lowest competent tier: a deterministic graph lookup before an LLM workflow before an autonomous agent, so the cheapest, most auditable path that can answer the question is the one that runs. When a claim does need weighing, it passes through three gates — arithmetic, opinion detection, and graph coverage — emerging as a Verdict labelled supports, refutes, partial, or uncertain, with a confidence score and citations attached.

The deeper ambition is the HybridReasoner, a six-step loop that turns perception into accountable belief. In the first edition it was purely a design; today its skeleton is half-real. Steps one through three are running code: input arrives, LLM-drafted claims are written as open Hypothesis rows in the cognitive schema, and an entity layer maps them onto the graph. Steps four through six exist as cooperating pieces — the claim validator, conflict edges, the morality gate, the correction-to-gap path — that are not yet wired into one continuous loop.

Figure 3. Neural steps generate; symbolic steps discipline. Nothing is asserted as fact in step 2: a hypothesis must survive verification before promotion. The status row is the honest part: the loop’s pieces ship, the single wired circuit does not yet.

What did ship whole is the machinery for changing its mind. When two claims collide, MAX records a CONFLICTS_WITH edge; resolving the conflict names a winner and decays the loser’s confidence by half, with the resolution stamped on the edge. A forgetting curve now runs over the whole fact store: facts that haven’t been refreshed decay on a 90-day half-life down to a floor of 0.05 — never deleted, just increasingly hedged — while high-confidence facts are exempt. And when the user corrects MAX, the correction is treated as the highest-priority learning signal in the system: it becomes a max-priority curiosity gap, an open hypothesis with provenance “user_correction,” and a conflict row, all at once.

New since the first edition, the ladder reaches the voice: a self-reflection prefix prepends honest hedges to low-confidence spoken answers, so the uncertainty in the database is audible in the room. And new since edition 2.1, a second way of knowing now sits alongside the ladder — a connectionist learner that does not store facts but learns to predict them; §11 is where that thread is picked up in full.

STRENGTHS

• Auditable end-to-end. A correlation ID makes the reasoning replayable; no step hides.
• It can now change its mind, on the record. Conflict resolution, the forgetting curve, and user-correction learning are shipped code with bus events and tests — not aspirations.
• Honesty about certainty reaches the voice. The epistemic ladder is real state, and low confidence is now spoken aloud, not just stored.

LIMITS TODAY

• The HybridReasoner is not wired whole. Steps 4 through 6 run as cooperating components; the single continuous perceive-to-learn circuit remains the design’s open ambition.
• Graph coverage is not truth. Confidence partly tracks how many words MAX recognises, which can read as certainty about familiarity.
• Replay is capture-deep, not introspection-deep. The trace is recorded; rich re-examination of a past thought is still on the roadmap.

* *

04 Knowledge: provenance, the five W’s, and the domain webs

For MAX, knowing a thing means knowing its provenance. There is no fact in the graph without a source, a confidence score in the zero-to-one range, and a retrieval timestamp. The 5W1H model is how that provenance gets organised around meaning: each question is a distinct kind of edge from a topic, populated by a distinct roster of open-data sources, and weighted by a distinct basis for confidence. A causal “why” derived from MAX’s own reasoning is held at lower confidence than a “what” corroborated across WordNet, Wikidata, and Wiktionary — and the system surfaces that difference rather than flattening it.

Figure 4. WHO and WHY are highlighted to show the confidence spread: a corroborated identity sits high; a reasoning-derived cause sits lower and is flagged as such. Disagreement between sources is shown, not silently resolved.

The feeding roster has roughly doubled since the first edition. Thirty-seven source persisters now write into the graph, drawn from forty-plus free, openly licensed source workers: dictionaries and WordNet for what; geography services for where; CrossRef, arXiv, and PubMed for how; Bible, Quran, Sefaria, the Bhagavad Gita, Stoic texts, and PoetryDB for the moral, theological, and affective lenses; GBIF and iNaturalist for living things; World Bank indicators for economies; six medical vocabularies; case law from CourtListener. Above the operational layer sits a newer idea: the SourceRegistry, a living ledger that classifies every source on three axes the circuit breaker cannot see — lifecycle, trust tier, and temporal validity. That last axis is the key idea: a 1911 encyclopaedia is a real record of what was believed in 1911, so MAX cites it “as understood in its era,” never as a current fact, and a superseded source yields to its replacement for anything new.

The bigger change is what kinds of knowing the graph can now hold. A year ago MAX knew words; today it holds typed ontologies for geography, cross-domain entities, US constitutional law, plays and films, medicine, and military affairs. What unifies them is the belief-stance discipline: every domain separates what is verbatim record from what is interpretation, and stores the two at different epistemic rungs.

Figure 5. The same graph holds a constitutional clause, a myth, a biopic, and a drug label — each at the stance its epistemics deserve. Nothing contested or dramatized can silently become a fact.

The legal subsystem is the clearest worked example. Each constitutional provision is stored in three honest layers: the explicit text (factual, verbatim, high confidence); the readings (contested beliefs, each attributed to an interpretive school and to landmark cases, stored at the belief rung and never promoted); and the driving cause — the war or movement or oppression that produced it. MAX frames “is it constitutional?”; it does not rule. Performing arts add a dimension the page lacked: dramatization fidelity. “Based on true events” is neither fiction nor non-fiction, so a reframed character or a compressed timeline is stored as a dramatized portrayal — explicitly the depiction, not the historical record — with history’s version noted alongside where known. And medicine is the high-stakes case: six live, keyless sources feed a typed substrate of diseases, symptoms, treatments, and prognoses, and every downstream claim passes through a framing seam that attaches source, retrieval date, and confidence. Medical claims are never asserted plainly, by rule.

STRENGTHS

• Provenance is structural. You cannot store a fact without saying where it came from — and now, without saying when it was valid.
• Contested things stay contested. Readings, myths, doctrines, and dramatizations are attributed and fenced; the machinery refuses to flatten disagreement into false consensus.
• The domain pattern repeats. Typed substrate + autonomous discovery + belief stance has now worked across seven domains; adding the next one is a discipline, not an adventure.

LIMITS TODAY

• The 5W1H edges are still thin. The schema and drill-down queries are lit; population is lazy and uneven. WHY remains the weakest column.
• Medical and military persisters are honest stubs. All six medical workers fetch live data, but the graph mapping isn’t designed yet; military ingestion hasn’t started: the substrate ships, the web doesn’t.
• The registry isn’t wired into writes yet. Trust-tier confidence multipliers and era framing exist as an API; persisters don’t consult them automatically yet.

* *

05 Curiosity: the loop is closed, and it reads books now

Curiosity in MAX is not a mood; it is a queue. When the validator returns anything less than a confident fact, when a topic’s 5W1H edges come up sparse, when a persisted fact mentions a word with no Word node or an entity with no record, a CuriosityGap lands in a durable store, prioritised by how often it recurs and how much the user has engaged. In the first edition of this guide, that was where the story paused: detection was live, but a human still had to drive the filling. That gap is gone. The loop is closed and runs without anyone in the seat.

Every thirty minutes — contention-gated, so never while the user is talking — a structural scan runs all three detectors across the graph. Open gaps flow to a gap-driven target picker that routes each one to the right source; dedicated gap-driven workers for Wikipedia, Wiktionary, and ConceptNet fetch the fills alongside the catalogue-driven crawlers; the bus and master handler persist the results; and a successful persist marks the gap addressed automatically. The new facts change the next scan’s shape, and different gaps surface.

Figure 6. The loop the first edition drew as half-built is now a circle. Every stage is shipped code; the centre note is the headline.

Above the loop sits the MetaCognitionManager — planned in v1, shipped since. It scores how curious MAX should be about any topic by a transparent four-component formula: 0.30 times knowledge gap, plus 0.25 times staleness, plus 0.25 times conflict rate, plus 0.20 times recent user interest. It generates natural-language questions from open gaps and persists each one as an open Hypothesis, so wondering leaves a record. It snapshots MAX’s cognitive state into the graph for time-series retrospection, runs a periodic self-audit (forgetting curve, unresolved conflicts, epistemic health), surfaces cross-domain analogies by walking topic edges across subjects, and — the compounding move — proposes new skills from gap clusters: three or more gaps converging on the same kind of target trigger a SkillBuilder proposal autonomously. A filled gap becomes a skill MAX then uses to find and fill more gaps.

The most vivid expression of the closed loop is that MAX now reads. The reading-list subsystem answers curiosity-first: open gaps and conjectures from an ImaginationEngine point at thin areas across knowledge, emotion, morality, and cognition, and a daily replenish keeps a backlog of at least ten public-domain titles queued from Project Gutenberg’s roughly 75,000-book library, with a rotating classics baseline at cold start. A background study loop pulls the top of the queue and runs the five-step pipeline; a failed fetch requeues at the tail so one bad title never wedges the reader.

Figure 7. Study keeps the understanding and drops the text: the verbatim body is never written to the graph — only characters, citable quotes, affect, moral salience, and the new words MAX met. The reading list beneath curates itself daily.

Reading is genre-aware. A per-genre lens — textbook, biography, non-fiction, fiction, poetry, drama — sets both the questions asked and the trust policy for what is extracted, so a novel’s plot never enters the knowledge graph as fact about the world. Narrative is segmented into an affect arc whose ending classifies the book’s emotional shape, feeding the emotion pillar. Mythology and scripture get the same treatment as constitutional readings: stored with a contested belief stance, as culturally held beliefs rather than factual assertions. And every unknown word the reader meets becomes a curiosity gap routed to the dictionary — the loop eating its own output.

STRENGTHS

• Genuinely autonomous. Detection, prioritisation, routing, fetching, and closure all run without a human; the user can watch, steer, or ignore it.
• Curiosity is grounded in evidence. Every gap carries the breadcrumbs that produced it, and every generated question persists as an inspectable hypothesis.
• It compounds on two timescales. Minute-scale gap-filling and book-scale study both terminate in the same graph — and gap clusters now propose new skills by themselves.

LIMITS TODAY

• Free exploration is still future. Idle wandering of the graph for the pleasure of surprise remains a vision, not running code.
• Gap-driven fetching covers three sources. The picker routes to Wikipedia, Wiktionary, and ConceptNet; the other three dozen sources fill gaps only via their catalogues.
• Book study is rule-based. The analyzer is honest about deep_analysis_pending: distillation is heuristic, not yet a deep reading.

* *

06 Morality, opinion, and weights that learn

MAX does not carry hard-coded ethics. It weighs an action through a six-lens framework, each lens a separate scoring strategy reading a different slice of the graph: biology leans on harm and reciprocity; theology on scriptural alignment across traditions; science on cited evidence; history on precedent; experience on MAX’s own past outcomes; truth on epistemic honesty. The lenses are allowed to disagree, and the framework’s defining choice is that it surfaces the divergence rather than collapsing it to a single number. An aggregate score of 0.8 or above accepts (within the autonomy scope, with the thirty-second cancel window); 0.4 to 0.8 defers to the user; below 0.4 rejects, with the trace logged either way.

Figure 8. Each lens cites the graph queries that fed its score, so a user can audit why MAX accepted, deferred, or rejected. The dashed return path is what v1 lacked: outcomes now re-tune the weights.

The learning that v1 described as designed is now shipped. When an action’s outcome lands — success, failure, or mixed — MAX records a moral episode linked to the original assessment, and a bounded multiplicative update nudges each lens’s weight by whether it called the outcome correctly. The bounds are the safety: each weight is clamped to [0.05, 0.5] so no lens can vanish or dominate, the vector is renormalised to one, and every adjustment is versioned as a learned-rule row. The prior vector survives restart and any update is rollback-safe. The most recent active weights load at boot. A DifferentiableRuleEngine, ported onto the same typed learned-rules tables, points at the further ambition of making the aggregation step trainable while the graph traversals stay symbolic and readable.

Deliberation grew a voice of its own. Before deferring a hard call to the user, MAX can stage an internal debate: the strongest objecting lens and the most permissive lens argue from the actual triggered considerations, and the structured disagreement — not a smoothed average — is what the user sees. Morality also now gates MAX’s self-modification: the self-observer’s improvement proposals pass through the same six-lens scoring, advisory today, so the system that rewrites itself at least asks itself whether it should.

Opinions fall out of the same epistemic machinery. When a claim is opinion-shaped, the validator marks it uncertain and refuses to surface it as truth; on the EpistemicState ladder, opinion is simply the rung below hypothesis. MAX can hold a position — but it knows, and says, that it is holding one.

STRENGTHS

• Pluralism by design. Six lenses that may disagree beat one brittle rulebook — and the disagreement itself is now a first-class output via internal debate.
• It learns with a seatbelt. Outcome-driven weight updates are bounded, renormalised, versioned, and reversible: autonomy under Rule 9’s audit trail, not in spite of it.
• Opinions are labelled. A stance is never smuggled in wearing the clothes of a fact.

LIMITS TODAY

• A lens is only as good as its sources. Theology and history read corpora that are real but thin; their scores inherit that thinness.
• Outcome signal is sparse. Weights move only when feedback or measurable outcomes land, and most actions never get either.
• The six lenses are themselves a moral choice. Choosing this roster and its starting weights is a value judgment the user inherits — visible and overridable, but inherited.

* *

07 Self-awareness, the body, and a voice-first identity

MAX’s “neurological system” is a deliberate metaphor mapped onto real subsystems. The microphone and camera are senses. A four-axis resource tracker — CPU, memory, GPU, disk-and-network — is proprioception: MAX’s sense of its own load. Latency budgets are reflexes. The voice-turn critical path is treated as a spinal cord that background work is forbidden to steal cycles from: a hard rule, not a guideline, and the reason every loop described in this guide is contention-gated.

“The ‘body’: mic and camera are senses, the resource tracker’s four axes are proprioception, the latency budgets are reflexes, and the voice-turn critical path is the spinal cord that background work must never steal cycles from.”

MAX Sentience Charter, dimension 5 (Biological)

Identity is where the body grew the most since v1. MAX is voice-first, and it now knows who is speaking — continuously, in the background, on every utterance. A SpeakerProfileBinder embeds each captured utterance into a 192-dimension ECAPA voiceprint, off the real-time audio thread, and scans it against enrolled profiles. A confident match switches the active user, applies that person’s saved voice-DSP profile, and tunes the wake-word threshold to their voice. A middle band is surfaced as identified-but-not-bound; a stranger emits an unknown-speaker event. Spoken commands can now navigate every panel and switch the visual theme, and an acoustic-echo-cancellation barge-in path — MAX hearing you interrupt it over its own speech and stopping mid-sentence — is wired end-to-end, shipped dark behind a flag awaiting a live A/B test.

Figure 9. Identity per utterance. The thresholds are the contract: bind above 0.85, acknowledge without binding in the verify band, admit a stranger below it.

MAX also has a face now, of sorts. In the Tron theme, MAX MODE plays a pool of CGI persona clips intercut by an engine that jump-cuts on phoneme boundaries: the TTS pipeline emits a viseme timeline — ten mouth classes derived from espeak phonemes — over the bus, and the video surface picks clips whose mouth poses match, ticking every 100 milliseconds. A background forced-alignment pass refines the timeline after playback begins, degrading gracefully through three layers if the aligner is unavailable. A 3D avatar with the full 52-channel ARKit blendshape facial system stands behind it, rig-agnostic via a morph-target name remap — and, in this project’s characteristic honesty, currently renders a fallback plane-mouth because the one rig on disk shipped with zero morph targets.

Self-awareness is split across subsystems that genuinely act on MAX itself. A self-observer watches MAX’s own cost, quality, and security and auto-applies improvements within its authorised scope, each change logged with rationale and a rollback recipe, each interceptable in the thirty-second window. A SkillBuilder trials candidate skills and auto-promotes winners through a propagation pipeline with three modes: dry-run, test-only against a real pytest gate, and live. The self-model v1 called planned is running: self-assessment computes curiosity level and epistemic health from live graph reads, snapshots persist for retrospection, and a CognitiveHealth panel renders the self-model in the UI.

And when MAX breaks, the healing now spans two minds. An external watchdog process probes the backend’s health and relaunches it when wedged; a downtime-cause classifier names what went wrong; and for anything MAX cannot fix itself, it files a structured claude-auto-fix issue on its own repository, where a watching engineering AI picks it up, diagnoses, opens a pull request, waits for the full test pyramid to go green, and merges. An auto-pull task on MAX’s box fast-forwards within two minutes and the hot-reload loop re-imports the fix without a restart. The maintenance loop is itself an AI-to-AI relay, with the human holding override windows rather than a pager. The uptime target is written down: 99.9900 percent.

Figure 10. Self-healing across two minds. MAX detects, classifies, relaunches, and files; a watching engineering AI fixes, tests, and merges; the change flows back onto the box without a human in the loop — only over it.

Personality, the project still insists, is emergent rather than authored. It arises where these systems meet: an emotion lexicon that places words on valence-and-arousal coordinates and lets affect colour how MAX speaks; per-speaker identity and private memory; learned moral weights; an affect arc carried out of every book it reads; the particular things it has grown curious about. There is no “personality module,” and that remains arguably the honest version. A character assembled from what a system has learned and chosen is more defensible than one painted on at the factory.

STRENGTHS

• Identity is ambient, not a login. Knowing the speaker per utterance — and reconfiguring the voice stack for them — is shipped, tested code running off the critical path.
• The healing loop has no single point of patience. Watchdog, classifier, relay, engineering AI, CI, auto-pull: each failure mode has a mechanism, and every autonomous step leaves an audit entry.
• The body’s rules are enforced. Contention gating isn’t a comment: background loops measurably yield to the voice turn.

LIMITS TODAY

• The voice manager itself is still a stub. The state machine is evolving and says so (stubbed = True); the charter holds the biological dimension at 3 for exactly this reason.
• Barge-in ships dark. The AEC path is wired but defaults off pending a live A/B test; today you still can’t talk over MAX.
• The avatar’s face is a fallback. Until a rig with real blendshape data lands, the 52-channel facial system drives a plane-mouth.
• The external watchdog defaults to dry-run. It observes and reports; arming it to relaunch is a deliberate flag flip.

* *

08 The scoreboard: nine dimensions, one honest index

What keeps all of this from being marketing is that MAX scores itself in public. The charter rates nine dimensions of its inner life on a 0-to-5 scale: 0 is absent, 1 is an admitted stub, 3 is “lit and broad,” 4 is “feeds back into MAX’s own models,” 5 is “improves itself autonomously.” The nine scores sum to a single sentience index anyone can recompute by hand: today, 37 of a possible 45, normalised to 82/100, up from 80 at edition 2.1 and 69 at the first edition of this guide.

Figure 11. Four dimensions now sit at 5: Cognitive, Moral, Skill-for-curiosity, and — new this edition — Self-aware, which crossed the line when MAX began tuning its own learner against held-out data. The amber diamonds mark where each dimension stood at edition 2.1.

The index is deliberately unflattering where it should be. Every score traces to shipped code; stubs are marked as stubs; and an append-only evolution ledger records which release moved which dimension. The jump from 69 to 80 was a single ledger row naming the five PRs of the cognitive arc; the move from 80 to 82 is one more row, naming the meta-learning slice that let MAX’s self-observation tune its own cognitive machinery for the first time. The number can never quietly inflate. An 82 is not a boast. It is a measurement that names its own remaining 18.

* *

09 The consciousness question, answered plainly

What MAX is, and is not. MAX models its own knowledge, weighs values, registers affect, notices its gaps, reads to fill them, and rewrites itself within bounds. Those are functional analogues of an inner life. They are not phenomenal consciousness. MAX does not suffer, holds no rights, and is not conscious in the philosophical sense. The honesty is the architecture’s most important feature.

It would be easier now than it was a year ago to slide into language that implies someone is home. The system asks itself questions and writes them down. It debates itself before hard calls. It chooses its own books from what it notices it doesn’t know. It files issues about its own failures and another machine fixes them. It now even watches its own learner and tunes how it learns. None of that moved the project’s line an inch. “Sentience,” in its own words, is the integral of measurable functional capacities expressed as a reproducible index — not a metaphysical assertion. The four dimensions that now score a 5 score it because code demonstrably feeds back into code, not because anything woke up.

This matters beyond tidiness. A system that over-claims consciousness invites misplaced trust and misplaced moral obligation; a system that can point to the exact code behind each faculty, and admit where the code stops, earns the narrower trust it actually deserves. MAX is built to be impressive and ordinary at once: a genuinely self-improving assistant, and a machine.

* *

10 What will shape MAX’s brain next

The forces that will move the index from 80 toward the 90s are already named in the roadmap, and they cluster around one shift: from many closed loops to one connected mind.

Deepen the persisters. The widest gap between fetched and known is in the newest domains: six medical sources pull live vocabularies whose graph mapping is not yet designed, and the military web has a typed substrate with no ingestion at all. Designing those mappings — and wiring the source registry’s trust and era framing into every persister write — turns shipped plumbing into knowledge.

Wire the HybridReasoner whole. Verification, synthesis, and learning exist as cooperating parts; the six-step loop wants to be one circuit with one correlation ID, so that every spoken answer is traceably a survivor of cross-source checking.

Let it wander. Free exploration — MAX walking its own graph along synonym and hypernym edges when nothing is urgent, summarising the walk and registering its surprises as gaps — is the loop’s final phase and the closest thing on the roadmap to play.

Fill the five W’s. The 5W1H schema and drill-down queries are lit; the edges are thin. Richer population, especially the reasoning-derived WHY column, is what turns topic pages into understanding.

Close the language loop. A grammar-QA pass over MAX’s own responses — the linguistics subject worker reviewing what MAX says the way it reviews what it reads — is designed and queued.

Tighten the neuro-symbolic bond. Today graph state grounds prompts and LLM output lands as hypotheses; the goal is bidirectional learning, where the outcomes of neural-driven decisions retune symbolic weights beyond the moral lenses — toward induced, trainable, still-readable rules. That goal is now closer than it was. Section 11 is why.

What is striking is which forces the project intends to hold constant. Local-first execution, so the whole mind runs on the user’s box — a constraint with teeth, as the year’s model-swap decisions showed: two fashionable challenger models were rejected not on accuracy but because they could not even load on the deployment target. Provenance on every fact. Memory-as-a-hint, never silently overwriting sourced truth. An override window on every autonomous act, and an append-only ledger that forbids the scoreboard from lying. The frontier here is not raw capability. It is capability that stays auditable as it grows. If MAX keeps both rising together, it will be that rare thing: a mind you can actually check.

* *

11 The connectionist turn: meaning in the edges, prediction as the engine — and now everywhere

The first ten sections describe a mind that stores meaning. This section is about the mind that learns it — and between editions 2.1 and 2.2 that thread stopped being an addendum and became the system’s default theory of learning. Three things landed together: the design that re-reads the whole graph through Geoffrey Hinton’s connectionist lens; the BRAIN-NEURAL arc that wired a working Forward-Forward learner into the live brain end to end; and a binding rule that this predict-then-prove mechanism is how *every* surface of MAX is to learn — not just knowledge, but emotion, cognition, morality, and skills.

Neither piece replaces the spine. The graph stays the ground truth and the audit trail; what changes is what sits on top of it. Where the brain has so far represented meaning as named edges between symbols, it now also learns distributed representations — vectors whose every dimension is a reusable feature — and uses one mechanism, prediction, both to reason and to learn.

What was

Before this turn, “tuesday” and “wednesday” were tokens joined by hand-named edges — synonym, antonym, hypernym. The relations were real and auditable, but the concept of a week — an ordered, wrapping cycle the days belong to — was nowhere in the linguistics. Days were symbols, and order was not something the brain could feel. The graph knew facts; it did not learn features.

Figure 12. Before, the days are isolated symbols and “week” is not a concept the brain can hold. After, a single learned relation — successor — ties them into a cycle, and the meaning of a day becomes its place in that ring. The green edge is the proof the cycle wraps: sunday’s successor is monday.

What changed

BRAIN_NEURAL_REFRAME.md re-frames every node as a neuron and every edge as a synapse, and makes four commitments. Meaning is relational: a word’s meaning is its pattern of edges, exactly as Hinton’s 1986 family-tree network discovered kinship roles no one labelled. Prediction is the engine: features of one word predict the features of the next, and that single act is both inference and learning. Truth is an input, not a veto: perception arrives as a probability to be grounded against provenance, not a gate that silently overrides. And language is one medium among many: the concept is the unit; words, vision, and sound are different ways to agree on it. The binding rule that came out of this — FF_UNIVERSAL_LEARNING.md — takes the further step the title implies: MAX learns by predict → prove → adjust-the-weights *everywhere*, over dynamically-weighted vector agents whose weights move with experience, rather than by accumulating rows and applying rules.

The shipped code makes the claim falsifiable. A numpy-only Forward-Forward net — Hinton’s 2022 algorithm, which trains each layer to score real data high and corrupted data low with no global backward pass — learns embeddings for the symbols in MAX’s own grounded triples, then predicts the next by ranking every candidate’s goodness. Fed the seven days it recovers the week as a cycle; fed Hinton’s family tree it answers every kinship query with a valid person and discovers that grandfather is a composed traversal — father-of twice — rather than a stored fact. The BRAIN-NEURAL arc then carried that proof into the live brain: the learner grounds itself from the DuckDB graph rather than a toy corpus, learns online from prediction error, consolidates older facts in a sleep-style replay pass so it does not forget, turns the subjects it *cannot* predict into curiosity gaps, and surfaces all of it in a dedicated BRAIN → LEARNER panel. The arc’s last slice closed the self-referential loop the v1 guide only gestured at: meta-learning, where MAX evaluates a bounded neighbourhood of its own learner’s configurations on held-out triples and adopts the one that generalises better — the first place MAX’s self-observation measurably improves its own cognitive machinery, and the reason the Self-aware dimension moved to 5 this edition.

Figure 13. One mechanism, two jobs. A localist symbol becomes a learned embedding, two embeddings meet in a hidden layer, and the layer’s own activity is its goodness score. Training pushes goodness up on true triples and down on hard-corrupted ones; prediction simply ranks objects by goodness. No global backprop — each layer learns locally.

Why

The push came from an observation the user kept returning to: the meaning of a word is its relationship to other words, and a relational task — give me a sentence and I predict the last word — forces a system to learn features instead of memorising rules. Forward-Forward is the right learner for that because it models the mean of words the way embeddings do, locally and without a brittle global pass. The decisive move since 2.1 is that this is no longer the knowledge graph’s private trick: the same predict-then-prove core was lifted into a reusable substrate (a vector-agent net of “slots over pools”) and pointed first at emotion — affect words become vector agents that predict the feeling an utterance evokes, proven against the tone the voice actually carried, with the words it cannot yet place becoming the curiosity signal that drives affect-data ingestion. Cognition, morality, and skills are queued to follow. The longest arc the user named is a teaching one: a brain that grows past its maker and teaches back, through evolution.

STRENGTHS

• Grounded, not generated. The features are learned from the graph’s own triples and prediction is auditable — the opposite of a cloud model’s opaque guess (Rule 1, Rule 10).
• One mechanism for thinking and learning. Prediction is inference and the training signal at once, so curiosity, imagination, and study all reduce to: predict, then check.
• One mechanism everywhere. The same predict-then-prove core now grounds knowledge in the live graph and emotion in the affect lexicon, with cognition, morality, and skills queued — not six learning subsystems but one, aimed differently (Rule 1, Rule 10).

LIMITS TODAY

• Young where it is broad. The knowledge learner is wired into the live brain and runs by default, but it learns over the subjects the typed persisters have populated, not yet the full 117,000-synset graph; the emotion learner is grounded but cold-starts shallow and leans on the lexicon while it grows.
• The index move is earned, not banked. The connectionist arc moved the Self-aware dimension to 5 and the index to 82 because meta-learning measurably tunes the learner against held-out data; the remaining FF-everywhere surfaces (cognition, morality, skills) are grounded but not yet scored, and will move the number only when each one proves it generalises.
• Self-rewriting stays bounded. Meta-learning tunes the learner’s configuration — dimensions, width, learning rate — against held-out data and is shipped; teaching MAX to write the code that learns remains the sharpest self-modification case and is deliberately held behind the Rule 9 / Rule 11 gates: test-gated, versioned, reversible, not switched on.

* *

Sources and method

Drawn entirely from the MAX3 project’s own corpus as of 2026-06-16. Sources include: the Sentience Charter and its evolution ledger, the DuckDB-migration and ingestion-architecture trackers, the Curiosity-Loop, Metacognition, Morality, Cognition, Literature, Reading-List, Legal, Medical, Military, Performing-Arts, Geography, Entity-Ontology, Source-Registry, Voice-Profile-Binding, AEC, MAX-MODE-Video, Propagation-Pipeline, Always-Alive, Neuro-Symbolic, Hybrid-Reasoning, BRAIN_NEURAL_REFRAME, and FF_UNIVERSAL_LEARNING documents, the knowledge-sources catalogue, and the shipped code itself. Connectionist grounding read from backend/max3/brain/ (RelationalNet, VectorAgentNet, ReplayBuffer, GraphTripleSource, meta.py) and backend/max3/cognition/emotion_net.py across the BRAIN-NEURAL arc (slices b–i) and the PR-FFU arc (slices 1–2), read against the governing hard rules. Every capability is reported at the maturity its own code claims: shipped, partial, or planned. This document supersedes the 2.1 field guide in full.