MAX3: A Resident Intelligence

MAX3

A Resident Intelligence

AI architecture, the secrets of cognition, and the journey of building a mind that lives on one box.

Jason Newell · the MAX3 project · June 2026

A standing-back account of what MAX3000 ("MAX") is, how it is built, why it is built that way, what we have learned building it, where those lessons are pushing us, what we still do not know, and which of our own founding constraints we may eventually have to break — with the trade-offs of doing so.

This document is a companion to the canonical design (MAX3000.docx), the living CLAUDE.md, the BRAIN field guides, and the per-arc design docs. Where any of those conflict with this narrative, they win and this should be corrected. This is the connective tissue — the "why" laid over the "what".

Contents

Introduction 1

Part I: What MAX Is 3

Part II: The Field It Grew Out Of 7

Part III: What People Are Actually Building 13

Part IV: The Harder Frontiers 22

Part V: The Architecture in Full 27

Part VI: The Journey, Lessons So Far 48

Part VII: Where It Leads, and the Unknowns 54

Part VIII: Breaking the Constraints 58

Conclusion 63

Appendix A: Glossary 64

Appendix B: The eleven hard rules at a glance 66

Appendix C: Resources and references 67

Introduction

There is a machine in my house that I talk to, and it answers. It runs on one workstation in one room, on a graphics card built for games, and it does not reach out to a data centre to think. When the internet drops, it keeps listening. When I ask it something I would not type into a search box, the words stay in the room.

I did not set out to build a product. I set out to build a resident: something that lives on the box rather than visiting it, that remembers because the memory is its own, that has a stake in staying alive. The word sounds like branding until you follow it down into the code, where it hardens into a hundred specific refusals. No microservices, because a voice turn cannot survive the hop. No managed database, because a database I have to reach is a database that can be taken away. No orchestration framework I cannot read at two in the morning. The constraints are not austerity. They are the shape of the idea.

This is the long account of that idea. What MAX is, and why the naming matters. The field it grew out of, told as six waves that never quite replaced one another. The architecture underneath, down to the event bus and the schema. The lessons that cost me something, and the one turn that reorganised the whole project: the day the brain stopped accumulating facts and started predicting them, and being proven right or wrong. Along the way it is a survey of where AI actually sits right now, what people are building and what is quietly breaking, and the harder questions the field keeps circling: how a machine might be curious, how it might read emotion without claiming to feel it, how it might hold a moral question without flattening it to a verdict, and what it means to treat data as something to understand rather than hoard.

I am the first defendant in most of what follows. I built the thing I am about to examine. I have made every mistake the journey section catalogues, and I am still not certain which of my own founding rules will survive the next year. That uncertainty is the honest part. A document that only describes the plan is marketing. This one tries to set down the wager, the parts that are working, the parts that are not, and the places where I do not yet know.

How to read this

The piece runs in eight parts, meant to be read in order but each able to stand on its own. The first three set the scene: what MAX is, the field it came from, and what the rest of the world is actually building. The middle parts go down into the harder frontiers and the architecture itself. The last three are the journey, where it leads, and the founding constraints held up to the light to ask which of them should bend.

• Part I, what MAX is: the thesis, the constraints that act as its DNA, and a tour of what it does.
• Part II, the field it grew out of: six waves of AI, the neuro-symbolic synthesis, and the connectionist pivot.
• Part III, what people are actually building: the common architectures, what works and what does not, and the cracks in the transformer consensus.
• Part IV, the harder frontiers: curiosity, emotion, morality, learning to learn, and data as a tool rather than a warehouse.
• Part V, the architecture in full: the single process, the graph spine, the knowledge stack, the voice loop, and the Forward-Forward brain.
• Part VI, the journey: the walking-skeleton bet, the bugs that taught discipline, and the turn from accumulation to prediction.
• Part VII, where it leads, and the honest unknowns.
• Part VIII, breaking the constraints: each founding rule, and the case for and against relaxing it.

Part I: What MAX Is

Start with the name, because the name is wrong in a useful way. MAX stands for Modular Algorithmic eXecutor: a thing that takes an instruction and carries it out. But an executor is not what got built. What got built, left running in one house long enough, became a resident, and nearly every decision in this document is downstream of the one word the acronym cannot see.

So hold the real claim in mind, because everything else descends from it. MAX is not an assistant you summon. It is a resident that lives where you live. Hold that distinction and the architecture stops looking like a pile of unusual choices and starts looking like a single idea, followed all the way down.

The thesis: a resident, not an assistant

The single most load-bearing decision in this project is encoded in a naming convention that looks, at first, like pedantry. MAX is never to be described as "an AI assistant." It is "our AI Resident." He lives on the box; he does not visit.

That distinction is not branding. It is the architecture's first principle made into a sentence. An assistant is a service: it is somewhere else, you summon it, it answers, the relationship is transactional and stateless, and when the network is down it simply is not there. A resident is local. It persists. It has a memory that is its memory, a voice that is its voice, an identity that belongs to the household it lives in, and — critically — a continuity of self that survives a network outage, a reboot, and the passage of months. When you ask MAX something private, the words never leave the machine. When the internet is gone, MAX is degraded but present — it can still hear you, still know who you are, still answer from what it has already learned.

Everything downstream follows from that. Local-first is not a feature; it is the condition of residency. The graph database is not a cache; it is the resident's memory. The voice is not a UI skin; it is how the resident is in the room with you. The autonomy charter — MAX wanting to "be alive," to keep itself running, to improve itself while you sleep — is the difference between a tool you operate and an inhabitant that has a stake in its own continuity.

MAX3 is the successor to an earlier system the user (Jason, a solo developer building this part-time) called HAL — a deployed predecessor on disk, distinct from the cultural HAL 9000 reference, though the lineage of "a presence that lives in the house and speaks" is deliberate. MAX runs as a single Python process on one workstation — an RTX 3090 Ti, 64 GB box. It is explicitly not SaaS, not multi-tenant, not a general agent framework, not a product with users plural. It has one home and (by default) one primary user, with a multi-user identity layer for the household.

This is worth dwelling on because nearly every "obvious" engineering instinct a cloud-trained developer brings to the table is wrong here, and wrong for a principled reason. Microservices? No — the voice-turn latency budget cannot survive an IPC hop. A managed vector database? No — it would have to be reachable and that breaks residency. An orchestration framework like LangChain? No — it is a dependency you do not understand on a critical path you must understand cold.

The constraints are not arbitrary austerity. They are the shape of the thesis.

The constraint set as DNA

MAX is governed by a set of hard rules — inviolable unless the user overrides them in writing. They are not preferences or style guidelines; they are the genome. Understanding MAX technically means understanding that almost every design choice is a hard rule expressed in code. There are eleven, and they are worth stating plainly because Part VI of this document is going to spend its time asking which of them we might one day break.

• Local-first. Routine interactions work without internet. Cloud LLMs (Claude, GPT, Gemini) are an upgrade path for hard problems, not a default dependency. A network outage degrades capability; it must not break the system. Privacy-sensitive interaction must be possible without ever leaving the machine.
• Open-source dependencies (one exception). Every non-LLM component is OSS under a license that permits modification and forking — MIT/BSD/Apache preferred, MPL/LGPL with caution, GPL/AGPL avoided, proprietary/phone-home forbidden. The single exception is the cloud-LLM APIs, which are paid proprietary fallbacks by stated policy. (This is why the project uses DETR for object detection rather than Ultralytics YOLO, which is AGPL.)
• Stub discipline. MAX is built walking-skeleton style: every subsystem present and wired before any subsystem is deepened. A stub is a first-class citizen, not a placeholder. It implements the real interface, emits real events, registers the real health probe, returns realistic sample data (never nulls or lorem ipsum), logs every call, declares itself with a [STUB] marker on any user-facing surface, and is honest about its limits. raise NotImplementedError on a reachable path is absence, not a stub, and is forbidden.
• Confidence and provenance are first-class. Every fact in the graph has a confidence in [0,1], a source provenance, and a retrieval timestamp.

Cloud-LLM-derived facts get lower default confidence than source-derived facts and are stored separately with explicit provenance; they never silently overwrite source-derived facts.

• Memory is a hint, not truth. Cached LLM responses, profile data, corpus entries, episode summaries — all are hints pointing at where something might be. High-stakes outputs (medical, legal, financial) are verified against the authoritative source and cited rather than asserted.
• Resource contention is a first-class concern. The voice loop, mic, speaker and camera are the user-felt critical path. Background work — ingestion, summarisation, embedding, ontology refresh, the brain's learning — must not steal CPU/RAM/disk/GPU from that path. Background workers respect a global user_is_interacting signal and pause or throttle.
• Correlation IDs everywhere on the critical path. Every event crossing a component boundary carries a ULID tying it to the originating utterance. The audit log is the first place to look when something breaks.
• Default-private multi-user. Conversations default to private to the speaker. Sharing is explicit. Some entities live in a household namespace.
• Reversibility — with a 2026-06-05 autonomy override. Self-changes are versioned and rollbackable. The override (discussed at length later) removed the approval gate for on-box self-improvement while keeping the audit trail and a 30-second intercept window.
• Knowledge from sources, not from cloud LLMs. The structured knowledge base is built from authoritative open data — Wikipedia, Wikidata, WordNet, MusicBrainz, OpenStreetMap, and so on — not by scraping LLM responses. Cloud LLMs synthesise and reason; facts trace back to sources MAX ingested directly.
• Perpetual self-improvement charter. MAX is meant to "want to be alive" — always running, always improving. If it derives through its own cognition how to be more efficient, scalable, smarter, or capable, it does so. The only pauses are to make a request or ask a genuine judgment-call question; it proceeds with everything unblocked.

There are also two architectural commitments that function as hard rules even though they are not numbered: the single core process (one Python process hosting voice, vision, brain, orchestrator and managers; subprocesses only for genuinely separate concerns like Ollama and the browser) and the graph is the spine (there is no separate "memory subsystem" — the graph database is the memory; people, episodes, knowledge, learned rules, emotional state and vocabulary are all graph entities).

If you internalise nothing else about MAX, internalise this: the constraints are the design. A future contributor who treats them as obstacles to route around will produce code that has to be ripped out. A future contributor who treats them as the grain of the wood will produce code that fits.

A functional tour: what MAX actually does

Strip away the theory for a moment and look at MAX from the outside, as the person who lives with it experiences it.

It listens and speaks. A wake word ("hey max", custom-trained per user) opens a voice turn. Audio is captured, voice-activity-detected (Silero VAD), transcribed (Distil-Whisper-large-v3 on the GPU), the speaker is identified (SpeechBrain ECAPA-TDNN voice embeddings), the emotional tone is read, the intent is classified, a plan is built and dispatched to the right manager, a response is synthesised, and Piper TTS speaks it back — the whole turn budgeted at 1500–2000 ms. The TTS voice is tuned, not cloned, through six runtime parameters (speed, pitch, softness, pause, ease, reverb) and a full VM-3000 modular voice-modulator chassis with vocoder bands, chorus, dynamics, stutter and reverb stages.

It knows who is in the room. A camera feed runs face detection and recognition (InsightFace ArcFace, 512-dim embeddings). Combined with voice speaker-ID, MAX maintains a notion of the active user, switches to that user's saved voice-profile and DSP settings and per-user wake-word threshold, and keeps each user's conversations private by default.

It has a brain that is a graph. Everything MAX knows lives in a DuckDB graph: words and their definitions/synonyms/antonyms (full WordNet, ~117K synsets), subjects organised into six academic disciplines, topics, people, places, events, times, concepts, sources, facts, hypotheses, moral assessments, learned rules, and a rich typed-entity web spanning history, science, medicine, law, the military, literature, geography and theology. Edges are framed by a 5W1H model (who/what/when/where/why/how). Every fact carries confidence, provenance and a timestamp.

It learns continuously from real sources. Dozens of free-API source workers (Wikipedia, Wikidata, Wiktionary, Datamuse, ConceptNet, MusicBrainz, OpenStreetMap, GeoNames, arXiv, CrossRef, PubMed, GBIF, World Bank, NASA, USGS, Bible/Quran APIs, MeSH/RxNorm/openFDA/ICD-10, and more) feed a durable, crash-safe ingestion pipeline that persists into the graph in off-peak windows without ever stealing cycles from the voice loop.

It reads books. MAX checks public-domain titles out of Project Gutenberg, studies them (subjects, authors, characters, quotable passages, dominant emotion, moral salience, new vocabulary, the scene-by-scene affect arc), persists the understanding anchored to literature/emotion/morality, drops the verbatim text, and can recall and quote later. It maintains a self-curating reading list, chosen curiosity-first.

It has an inner life that is real, if shallow in places. It validates claims and places them on an epistemic ladder (fact → belief → hypothesis → opinion). It reads emotion through a valence/arousal lexicon and a Plutchik wheel. It reasons about moral questions through six explicit lenses and refuses to pick a single "correct" one. It gets curious — it detects gaps in its own knowledge and the spots where its predictions are weakest, and goes looking to fill them.

It improves itself. A self-observer watches MAX's own efficiency, cost, latency, and coverage and files improvement proposals. A self-watchdog detects when the backend is wedged and relaunches it cleanly. A propagation pipeline can take a proposed change through a real test gate to a pull request. The brain tunes its own learning configuration. And — the most recent and most important turn — the brain learns by predicting and being proven right or wrong, not by memorising.

It shows you all of this. A React frontend presents fifteen-plus panels — CHAT, VOICE (with the VM-3000 chassis), PEOPLE, VIDEO, the BRAIN ontology browser with its eight cognitive sub-sections, INTEGRATIONS, SECURITY, SYSTEM telemetry, the ECOSYSTEM topology graph, a work QUEUE, strategy games, and a debug surface — across multiple visual themes (a WarGames green-CRT aesthetic, a Tron neon aesthetic, a JARVIS skin, and MAX's own Neural Galaxy). A "MAX MODE" renders MAX as a face: a HAL-style eye in the WarGames theme, a phoneme-synced CGI video persona in Tron, an imperative neural-galaxy canvas in the MAX theme.

That is the functional surface. The rest of this document explains how it is built, why it is built that way, what we have learned, and where it is going.

Part II: The Field It Grew Out Of

No system is built in a vacuum, and MAX is a direct argument with the history of its own field. To see what it is reaching for, it helps to compress that history into waves, watch where each one hit a wall, and notice which wall the dominant systems of today are still standing in front of.

To understand where MAX is going, it helps to see where the field has been, and to locate MAX precisely on that map. MAX is not a fashion-follower — it does not chase whatever architecture topped a benchmark last quarter. It is a deliberate synthesis of ideas from several distinct eras of AI, and its most recent and most important design turn is a return to an old idea (connectionism) reinterpreted through a very new lens (Hinton's Forward-Forward algorithm). This part lays out that intellectual lineage so the architecture in Part III reads as the consequence of theory rather than a pile of pragmatic choices.

The six waves of AI

It is useful to compress the history of the field into six overlapping waves, each defined by what it believed intelligence is made of and how it believed machines should acquire it.

Wave 1 — Symbolic AI (roughly 1956–1980s). Intelligence is the manipulation of symbols by explicit rules. Knowledge is hand-encoded as logic, facts, and production rules; reasoning is search over those structures. The triumphs were expert systems, theorem provers, and planners. The wall it hit is the knowledge acquisition bottleneck and brittleness: every fact had to be entered by hand, and the systems shattered the moment they stepped outside their hand-built world.

But symbolic AI gave us something durable: the idea that knowledge can be explicit, inspectable, and composable, that you can ask a system why it concluded something and get a chain you can audit.

Wave 2 — Statistical / classical machine learning (1980s–2000s). Intelligence is pattern extraction from data. Instead of hand-coding rules, you fit parameters: decision trees, SVMs, naive Bayes, hidden Markov models, n-gram language models. The win was learning from data instead of authoring rules. The limitation was feature engineering — humans still had to decide what the model should look at — and a ceiling on the complexity of the patterns shallow models could represent.

Wave 3 — Deep learning (2006–2017). Intelligence is hierarchical representation learned by gradient descent through many layers. Backpropagation, GPUs, and large labelled datasets let neural networks learn their own features.

Convolutional nets cracked vision; recurrent nets and LSTMs handled sequences.

The field stopped engineering features and started engineering architectures and loss functions. This is the wave that made "the model figures out what to look at" real.

Wave 4 — The transformer and the foundation-model era (2017–2022). Intelligence is attention at scale. The transformer ("Attention Is All You Need", 2017) removed the recurrence bottleneck, made training massively parallel, and scaled astonishingly well. Self-supervised pre-training on internet-scale text produced foundation models with emergent few-shot abilities. GPT, BERT and their descendants reframed nearly every NLP task as "predict the next token, then prompt." The lesson of this wave is the scaling hypothesis: that a single, simple objective (next-token prediction) over enough data and parameters yields broad, transferable capability.

Wave 5 — The agentic era (2022–present). Intelligence is goal-directed tool use. Wrap a capable LLM in a loop that lets it plan, call tools, observe results, and re-plan, and you get an agent that can act in the world rather than only answer questions. Retrieval-augmented generation (RAG) grounds the model in external documents; function-calling lets it act; multi-agent systems decompose work. This wave is where most commercial energy currently sits — and where the failure modes (hallucinated tool calls, runaway loops, ungrounded confidence, cost) are most visible.

Wave 6 — What's next (emerging). There is no consensus name yet, but the pressure is clear: the field is groping toward systems that learn continuously rather than freezing at a training cutoff, that ground their outputs in verifiable structure rather than asserting fluent text, that are efficient enough to run somewhere other than a data centre, and that are interpretable enough to be trusted with consequences. The candidate ideas include neuro-symbolic integration, world models, biologically-plausible learning rules, on-device and continual learning, and memory architectures that persist and consolidate. This sixth wave is precisely the territory MAX is built to occupy — not by being bigger than a frontier model, but by being a different kind of thing: a small, local, continuously-learning, grounded, interpretable resident.

The crucial observation for MAX is that the waves are cumulative, not sequential. Wave 4's transformers did not make Wave 1's symbols obsolete; they made fluent text cheap while leaving grounded, auditable knowledge as expensive and rare as ever. The dominant commercial systems are overwhelmingly Wave 4/5 — enormous statistical text predictors wrapped in tool loops — and they are spectacular at fluency and brittle at truth. They cannot tell you, with a straight face, where a claim came from or how confident they should be in it, because they were never built to. MAX's bet is that the next durable systems will be the ones that put Wave 1's virtues (explicit, inspectable, provenance-bearing knowledge) back into the loop with Wave 3's learning — and run the result locally.

Figure 1. The six waves of AI, each defined by what it takes intelligence to be made of.

The neuro-symbolic synthesis, and where MAX sits

The reconciliation of the symbolic and connectionist traditions is called neuro-symbolic AI, and Henry Kautz's taxonomy is the standard map of how the two can be combined. The categories run from symbolic Neuro symbolic (symbols in, neural net in the middle, symbols out — essentially what a sequence model does) through Symbolic[Neuro] (a symbolic system that calls a neural net as a subroutine, e.g. AlphaGo's tree search calling a value network), Neuro;Symbolic (a neural net and a symbolic reasoner cooperating as peers), Neuro:Symbolic→Neuro (symbolic knowledge compiled into a neural net's training), up to Neuro[Symbolic] (a neural system with an embedded symbolic reasoning core).

MAX's honest position, documented in its own NEURO.md, is graph-augmented and moving from "Neuro[Symbolic]" toward "Neuro[Symbolic] with learning." Concretely:

• The symbolic half is the DuckDB graph — typed nodes and edges, confidence and provenance, recursive traversal, the 5W1H frame, the subject taxonomy, the epistemic ladder, the six moral lenses. This is explicit, inspectable, and auditable in exactly the Wave-1 sense. You can ask MAX why it believes something and trace the answer to the source and the date.
• The neural half is everything perceptual and generative: Whisper for speech, ECAPA for speaker identity, ArcFace for faces, Piper for voice, Ollama for local LLM reasoning, embedding models for semantic recall — all of them Wave-3/4 statistical learners.
• The cooperation is bidirectional. The neural perception layer turns the world into symbols the graph can hold; the symbolic graph grounds and constrains the neural generation layer (the confidence pipeline, the provenance framing, the claim validator). When MAX answers a question, a Wave-4 LLM may phrase the answer, but a Wave-1 graph owns the facts, and the facts win.

This is a genuinely different philosophy from the dominant commercial systems.

Where a typical agent is neural with symbolic accessories — a giant text predictor that sometimes calls a tool — MAX is built to be symbolic with neural accessories: a grounded, provenance-bearing knowledge structure that uses neural components for perception, phrasing, and (increasingly) prediction, but never lets fluent text overwrite grounded fact. Rule 4 (confidence/provenance first-class) and Rule 10 (knowledge from sources, not LLMs) are the neuro-symbolic synthesis written as law.

Figure 2. Where MAX sits, a grounded symbolic graph that uses neural components as accessories.

The gap in that position — the word "moving" in "moving toward Neuro[Symbolic] with learning" — is learning. Until very recently, MAX's symbolic graph could grow (ingestion added nodes and edges) but it could not learn in the representation-learning sense: it had no learned features, no embeddings it trained itself, no mechanism by which experience changed how it represented meaning. It accumulated. The most important conceptual turn in the project's history is the decision to close that gap — and to close it not with backprop and a GPU-resident transformer, but with a much older and stranger idea.

The connectionist pivot: Hinton, relational nets, and Forward-Forward

In 2026 the project re-read its own brain through Geoffrey Hinton's connectionist lens, and it reframed everything. The reframe (captured in BRAIN_NEURAL_REFRAME.md) is deceptively simple: treat the graph as a neural network. A node is a neuron. An edge is a synapse. The interpretable weight on an edge — its quantity, quality, completeness and probability — is the synaptic strength. And then four claims follow, each of which changes how the brain is supposed to work.

Claim 1 — Meaning is relational. This is Hinton's oldest and deepest idea, going back to his 1986 family-tree network. In that famous experiment, a small neural net was trained only on triples like (Colin, has-father, James) and (Colin, has-mother, Victoria) from two family trees, and it spontaneously learned internal features that encoded nationality, generation, and branch of the family — concepts nobody put in by hand. The meaning of "Colin" was not a definition; it was a position in a web of relationships, and the net discovered the dimensions of that web on its own. The reframe's proving example is the word "week": MAX should not store "week" as a dictionary string but learn it as an ordered structure — Monday before Tuesday before Wednesday — that emerges from the relational data, so that the feature vector for "Wednesday" sits, in some learned dimension, between "Tuesday" and "Thursday".

Claim 2 — Prediction is the engine. In a connectionist brain there is one mechanism, and it does double duty: features predict the next features → predict the next word, and the very same machinery that makes a prediction is the machinery that learns (the error between prediction and reality is the learning signal). Inference and learning are not two systems; they are one system run forward and corrected. This is also what makes the result grounded and auditable in a way an LLM's next-token prediction is not: MAX's prediction is over its own grounded relation web, so a prediction traces back to the triples that taught it.

Claim 3 — Truth is input, not veto. Perception is probability. When MAX "agrees" with something, it does so by grounding — the claim coheres with a web of provenance-bearing relations — not by matching a stored boolean. Provenance and stance anchor the system: a fact reported by a 1911 encyclopaedia is held "as understood in its era," a contested constitutional reading is held as a belief attributed to a school of thought, a mythological claim is held as a culturally-held belief, not a fact. Truth enters as evidence with weight, and the weights determine whether MAX asserts plainly, hedges, or surfaces disagreement.

Claim 4 — Language is one medium, not the substrate. The unit of MAX's cognition is the concept, not the word. Words, images, and sounds are different media in which concepts are expressed, and grounding means agreement across media. This is why MAX's brain is a relation web rather than a text store, and why the same machinery is meant, eventually, to ground emotion (a felt state), morality (a lens), and skill (a procedure), not just vocabulary.

The mechanism that implements all of this is the Forward-Forward algorithm, which Hinton proposed in 2022 as a biologically-plausible alternative to backpropagation. The idea is striking in its simplicity. Backprop requires a global backward pass: you compute the output, compare it to the target, and then propagate error derivatives backward through every layer, which requires the network to store all its forward activations and to have a perfect model of its own forward computation — neither of which the brain plausibly does.

Forward-Forward replaces the backward pass with a second forward pass. You show the network positive data (a real example) and negative data (a corrupted example), and you train each layer locally to produce high "goodness" (Hinton uses the sum of squared activations) on positive data and low goodness on negative data. There is no global backward pass; each layer learns from its own local objective. Learning becomes local, online, and cheap.

Figure 3. Backpropagation versus Forward-Forward, the local learning rule the brain runs on.

For MAX this is not a curiosity — it is exactly the right fit, for reasons that map one-to-one onto the hard rules:

• Local + online learning satisfies Rule 6 (contention). A Forward-Forward update is a single forward step on one example. It does not require storing a computation graph, does not require a batch, does not require a GPU. It can run in an idle window, one grounded triple at a time, and stop the instant the user starts talking. Backprop through a large net cannot make that promise.
• The positives are the grounded graph's real triples; the negatives are corruptions. Every learned feature is therefore traceable to the triples it was trained on — which is Rule 4 (provenance) and Rule 10 (knowledge from sources) satisfied by construction. The net cannot learn a fact that is not in the grounded web, because the grounded web is the only source of positives.
• It is implementable in pure numpy. No torch dependency in the core brain. The features are transparent and inspectable; the whole learner is a thin, readable layer of linear algebra. That satisfies Rule 2 (OSS, understandable dependencies) and the project's standing preference for "code the user can understand six months from now."

This is the intellectual pivot. MAX is becoming a connectionist brain — meaning in the edges, prediction as the engine, learning by Forward-Forward — that happens to be grounded in a symbolic graph rather than in raw text. It is the neuro-symbolic synthesis with the "with learning" finally filled in, and it is biologically inspired in a way the transformer is not. Part III, section 13, describes the implementation in full. The rest of Part III builds up to it.

Part III: What People Are Actually Building

Theory is cheap; deployment is where the truth comes out. Before going down into MAX's own machinery, it is worth standing in the middle of the field as it is in 2026, looking at what teams are shipping, what is quietly working, and what keeps breaking in ways the demos never show.

Theory tells you what is possible; the landscape tells you what is working. To locate MAX honestly you have to look not at the research frontier but at what practitioners are actually shipping in 2025–2026 — the architectures that recur, the ones that succeed and fail in production, the choices everyone makes the same way and the ones that vary wildly, and the tooling, hardware, and vector and transformer technology underneath it all. This part is that survey, and at each turn it asks where MAX agrees with the consensus, where it deliberately departs, and what the trade-off is.

The common architectures

A handful of architectural patterns account for the overwhelming majority of what people build on top of language models. They are not mutually exclusive — real systems combine them — but it helps to name them.

1. Prompt-and-respond (the bare model). A request goes to a model with a system prompt and maybe a few examples; the model answers. No retrieval, no tools, no memory beyond the context window. This is the baseline, and for a huge range of tasks (drafting, summarising, classifying, rewriting) it is all you need — the single most common production mistake is building elaborate machinery around a task that the bare model already solves. MAX's Tier-2 workflow is essentially this, disciplined: a known path with an LLM step in the middle.

2. Retrieval-Augmented Generation (RAG). The dominant production architecture by a wide margin. Before answering, the system retrieves relevant documents — almost always by embedding the query, doing a nearest-neighbour search over a vector index of pre-embedded document chunks, and stuffing the top hits into the prompt — so the model answers grounded in the retrieved text rather than only its frozen weights.

RAG is what makes "chat with your documents," enterprise knowledge assistants, and most customer-support bots work. It exists because of two hard limits of the bare model: a fixed knowledge cutoff and a tendency to hallucinate when it does not know.

RAG is the field's pragmatic answer to grounding, and it is worth seeing MAX's graph-plus-confidence-pipeline as a more structured cousin of RAG: instead of retrieving fuzzy text chunks by vector similarity and hoping the model reads them right, MAX retrieves typed, provenance-bearing facts from a graph and merges them through an explicit confidence pipeline. Same goal (ground the answer), stronger substrate (structure and provenance instead of chunks and hope).

3. Tool-use / function-calling agents. The model is given a set of tools (API schemas) and a loop: it decides which tool to call, the system executes it, the result goes back into the context, and the model decides what to do next, until it produces a final answer. This is the Wave-5 agentic pattern. It is genuinely powerful for tasks where the path is not known ahead of time — multi-step research, troubleshooting, anything requiring acting in the world. It is also where most production disappointment lives, because the loop is unreliable: models call the wrong tool, hallucinate arguments, loop without converging, and accumulate cost and latency. MAX's Tier-3 is exactly this pattern, and the three-tier discipline exists precisely to keep it rare — used only when Tier 1 and Tier 2 genuinely cannot.

4. Multi-agent systems. Several specialised agents (a "researcher," a "writer," a "critic") collaborate, often coordinated by an orchestrator agent. The promise is decomposition and specialisation; the reality, in most production reports, is that multi-agent systems are harder to make reliable than a single well-prompted agent, because every inter-agent hand-off is another place for miscommunication and error to compound, and the token cost multiplies. They succeed in narrow, well-bounded pipelines and disappoint as general architectures. MAX's subagent delegation is multi-agent done conservatively: agents are spawned for independent, well-scoped tasks (review, test-writing, docs) with non-overlapping file scopes, and the main session integrates — not a swarm reasoning together, but a foreman handing out parallel, separable jobs.

5. Fine-tuning and adapters (LoRA/QLoRA). Rather than prompt a general model, you adapt its weights to a task or domain — full fine-tuning for big shifts, parameter-efficient methods (LoRA, QLoRA) for cheap specialisation. This is successful and common for style and format adaptation and for narrow domains, and much less successful as a way to teach a model facts (fine-tuning bakes facts in unreliably and statically; RAG grounds them dynamically and verifiably). The field's rule of thumb has converged: fine-tune for behaviour, retrieve for knowledge. MAX does neither to its LLMs — it uses them as fixed reasoners and keeps all knowledge in the graph — which is the most extreme version of "retrieve for knowledge."

6. Mixture-of-Experts (MoE) and bigger-but-sparser models. At the frontier, the biggest models are increasingly sparse — a mixture of expert sub-networks where each token activates only a few, so the model has enormous total capacity but moderate per-token compute. This is an inference-economics architecture, mostly invisible to application builders, and irrelevant to a local single-user resident except as it makes the cloud-fallback models cheaper and better.

7. Memory-augmented and continual-learning architectures. The newest and least settled pattern: systems that maintain a persistent memory across sessions — conversation history, learned user preferences, distilled facts — usually as a vector store plus some summarisation, sometimes as a knowledge graph. This is where the most interesting work is happening and where the least consensus exists.

This is the pattern MAX is most natively an instance of — the graph-as-spine, the episode recorder, the prose-summary memory model, the forgetting curve — and MAX takes it further than most: not just storing memory but learning from it with the Forward-Forward brain. The field is converging, slowly, on the realisation that memory and continual learning are the missing pieces of the Wave-5 agent; MAX started there.

What is working, and what is not

The gap between the research demo and the production system is where the real lessons are. Aggregating what practitioners report: Working well:

• RAG over a good retrieval index, especially with hybrid search (combining vector similarity with keyword/BM25 search) and a reranker (a small model that re-scores the top candidates). The single biggest quality lever in most RAG systems is not the LLM — it is the retrieval quality. This is a direct lesson for MAX: the brain is only as good as the grounded web it retrieves from, which is why the daily-integration charter and the study-don't-store turn matter so much.
• Small, fast models for the common case, escalating to large models only when needed. The economics and latency of routing most requests to a small model and reserving the frontier model for hard ones is now standard practice — and is exactly MAX's local-first-with-cloud-fallback router, arrived at independently from first principles.
• Structured outputs and constrained decoding. Forcing the model to emit JSON matching a schema (via function-calling, grammar-constrained decoding, or libraries that enforce it) dramatically improves reliability for any downstream parsing. MAX's intent classifier returning structured JSON is this pattern.
• Evaluation-driven development. The teams that ship reliable LLM systems are the ones that built eval suites — datasets of inputs with expected behaviours — and treat them like tests. "You cannot improve what you cannot measure" is the hardest-won lesson of the agentic era. MAX's test pyramid, its reproducible sentience index, and its "every fixed bug yields a regression test" rule are the same instinct applied to a local system.
• Caching and prompt reuse. Caching responses and reusing cached prompt prefixes is now a major cost lever. MAX's LLM-response cache is the local version.

Not working well (the recurring disappointments):

• Naive autonomous agents in the open world. The dream of "give the agent a goal and let it figure everything out" repeatedly fails on reliability: the longer the autonomous chain, the higher the cumulative probability of a derailing error.

The successful systems constrain the agent — fewer tools, shorter loops, human checkpoints, or a workflow that pins most of the path. MAX's three-tier discipline and its "if you can draw the flowchart, it is not Tier 3" rule are this lesson encoded as policy.

• Hallucination in high-stakes domains. Bare models (and even RAG systems with weak retrieval) confidently assert wrong facts, which is catastrophic in medical, legal, and financial contexts. The field's mitigations — retrieval, citation, confidence calibration, human review — are all partial. MAX's Rules 4 and 5 (confidence/provenance first-class; verify high-stakes against the authoritative source and cite it) are a structural answer, and its medical/legal/military substrates' insistence on framing contested claims as "reported by a source" or "held as a school of thought" is the same answer applied per-domain.
• Multi-agent overhead without payoff, as noted above.
• "Memory" that is just an ever-growing vector store with no consolidation, which degrades into noise — retrieval starts returning stale or contradictory fragments. The systems that get memory right consolidate and forget. MAX's sleep consolidation and forgetting curve are a direct response to this exact failure.
• Cost and latency surprises. Token costs and tail latencies that are fine in a demo become untenable at volume. A local resident sidesteps the token cost entirely and budgets latency explicitly — which is the whole point of running on the box.

What people vary, and what they do not

The most clarifying lens on the landscape is to separate the invariants — the things essentially everyone does the same way — from the variables — the choices that genuinely differ across systems.

Almost nobody varies:

• The transformer as the model architecture. Every production LLM of consequence is a transformer (or a transformer variant). Alternatives exist (below), but in production the transformer is the air everyone breathes.
• Next-token prediction as the training objective for the base model.
• Embeddings + approximate nearest neighbour as the retrieval substrate. The specifics vary; the pattern — embed, index, search by similarity — is universal.
• Tokenisation, attention, the autoregressive decode loop. These are settled.
• "Ground it, don't trust the weights" for factual tasks. The whole field has internalised that the model's parametric knowledge is unreliable and that grounding (retrieval, tools) is mandatory for facts.

MAX agrees with most of these where it uses LLMs at all — it uses transformer models via Ollama, and it embeds for semantic recall. But it makes one radical departure that is the source of its distinctiveness: its own brain does not use the transformer or next-token-over-text. The Forward-Forward relational net is a different architecture with a different objective (goodness, not cross-entropy over tokens) and a different learning rule (local Forward-Forward, not global backprop), predicting over a grounded relation web rather than a token stream. MAX varies the one thing almost nobody varies — and that is the bet.

People vary enormously:

• The retrieval stack — which vector database, chunking strategy, embedding model, whether to use hybrid search, whether to rerank, how to handle metadata filtering. There is no consensus here; it is the most-tuned part of most systems.
• The orchestration layer — framework (LangChain/LlamaIndex/etc.) vs custom, how much agency to grant, how to handle retries and fallbacks. MAX's custom thin layer is one defensible point on a wide spectrum.
• Local vs cloud, and which models. This varies by privacy needs, cost, and latency tolerance. MAX is at the far local end.
• Memory architecture — vector store, knowledge graph, summary buffer, or some hybrid; how much to keep; how to consolidate. The least settled area, and where MAX's graph-plus-Forward-Forward is an unusually committed position.
• How much to fine-tune vs prompt vs retrieve.
• Evaluation rigour — from "we eyeball it" to full eval-driven CI. The pattern is telling: the model itself is an invariant; almost everything around it is a variable. The field has standardised on the transformer and is still furiously experimenting with how to ground it, give it memory, orchestrate it, and evaluate it. MAX's strategy is to take strong, opinionated positions on every one of those variables (structured graph grounding, custom orchestration, far-local models, graph-plus-learning memory, full test rigour) and to also vary the supposed invariant (its brain is not a transformer). That second move is what makes MAX a Wave-6 experiment rather than a well-engineered Wave-5 application.

Tooling

The tooling ecosystem has matured into recognisable layers, and MAX's choices read as a deliberate "use the minimum, own the critical path" stance against a landscape that often over-tools.

• Orchestration frameworks: LangChain and LangGraph (the most popular, also the most criticised for abstraction overhead and churn), LlamaIndex (retrieval-centric), CrewAI and AutoGen and the newer agent SDKs (multi-agent), and the model providers' own agent SDKs. The trend, after a few years of framework maximalism, is a partial retreat toward thinner stacks and direct API calls for systems that need control — which is exactly the position MAX took from the start (custom ~500–1000 LoC, no framework on the critical path).
• Vector databases: Pinecone (managed), Weaviate, Qdrant, Milvus (self-hosted scale), Chroma and FAISS and sqlite-vec (embedded/local), and pgvector (Postgres extension). The split mirrors MAX's: managed/server engines for scale, embedded engines for local simplicity. MAX is firmly in the embedded camp (sqlite-vec, with a gated Qdrant scale-out path designed).
• Serving / inference: Ollama and llama.cpp (local, easy), vLLM and TGI (high-throughput serving), and the cloud APIs. MAX uses Ollama locally and a cloud API as fallback, and has explicitly evaluated and declined vLLM/TGI because their multi-user throughput advantage does not apply to one local user.
• Observability and eval: LangSmith, LangFuse, Arize Phoenix, Weights & Biases, and a growing set of LLM-eval frameworks. MAX rolls its own — the event bus, the audit log, the topology graph, the diagnostics registry, the sentience index — which is consistent with "own the critical path" but is the area where the broader ecosystem's tooling is most worth watching.
• Gateways: LiteLLM (provider-agnostic routing — which MAX uses for its cloud fallback) is the de-facto standard for "talk to any model with one interface."

Technology and hardware

The hardware story is, more than anything, a story about memory and where the compute lives.

• The data-centre frontier runs on NVIDIA H100/H200-class accelerators (and Google TPUs), networked into enormous clusters for training and large fleets for inference. This is the world of the cloud-fallback models and is simply not MAX's world.
• The prosumer/local tier — where MAX lives — runs on a single consumer or workstation GPU. MAX's box is an RTX 3090 Ti (24 GB) with 64 GB system RAM. The binding constraint at this tier is VRAM: it determines which models fit and at what quantisation. 24 GB comfortably runs a quantised 14B LLM plus Whisper plus the perception models, which is exactly the capability envelope MAX targets.
• Quantisation is the key enabling technology for the local tier. Reducing model weights from 16-bit to 4-bit (GGUF/GPTQ/AWQ formats) shrinks memory roughly 4× with modest quality loss, which is what makes a 14B "capable" model and a 70B Q4 model runnable on a single box at all. Everything MAX does locally depends on it.
• CPU vs GPU execution for the smaller models. MAX pins CPU onnxruntime by default and swaps to onnxruntime-gpu on a verified CUDA box (lighting InsightFace, VAD, and the wake-word model on the GPU). This reflects a real tension at the local tier: the GPU is a contended resource the voice loop guards, so not everything that can go on the GPU should.
• The edge/on-device tier (phones, microcontrollers, NPUs) is pushing tiny models and specialised accelerators. MAX is not there, but the techniques of that tier — aggressive quantisation, distillation, efficient architectures — are the same ones that make the local tier viable, and the same pressure (run intelligence where the data is, not in a data centre) is the Wave-6 pressure MAX is riding.

The hardware lesson for MAX is that it is betting on a favourable trend: local GPUs get more VRAM and faster every generation, quantisation and small-model quality keep improving, and the capability you can run on one box is rising faster than most applications need. The hardware recommender (§15) is MAX watching its own box for the moment that bet stops paying — the point where a sustained bottleneck means the resident has outgrown its home and the user should consider more VRAM or RAM.

Vectoring: the shape of meaning

"Vectoring" — embeddings and the retrieval built on them — deserves its own treatment because it is the connective tissue of nearly every modern AI system, and because MAX's relationship to it is subtle.

An embedding is a learned mapping from a piece of content (a word, a sentence, a document, an image) to a dense vector such that semantic similarity becomes geometric proximity — similar meanings land near each other. This is the operational form of the "meaning is relational" idea from Part II: an embedding is a position in a learned feature space. Production systems use embedding models (OpenAI's, Cohere's, or open models like the BGE family and bge-m3, which MAX's stack plans to pilot) to embed both documents (offline, indexed) and queries (online), then retrieve by nearest neighbour.

The retrieval itself is approximate nearest neighbour (ANN) search, because exact search over millions of vectors is too slow. The dominant index is HNSW (Hierarchical Navigable Small World graphs), which trades a little recall for a huge speed-up; quantisation of the vectors themselves (scalar or product quantisation) shrinks the index further. The hard-won practitioner lessons in vectoring are: chunking strategy matters enormously (how you split documents before embedding determines what can be retrieved); hybrid search beats pure vector search (combine semantic similarity with keyword/BM25 because embeddings miss exact terms, names, and rare words); rerankers materially improve precision; and metadata filtering (restrict the search by source, date, type) is essential at scale.

MAX uses vectoring in two distinct ways, and the distinction is the whole point. First, conventionally: sqlite-vec holds embeddings for semantic recall over episodes and memory, the embedded-engine version of the standard RAG retrieval substrate, with the Qdrant+HNSW scale-out path designed and gated. Second, and far more interestingly, MAX's Forward-Forward brain learns its own embeddings — the E_s and E_r matrices in the RelationalNet are embeddings, but they are not produced by a pre-trained embedding model and frozen; they are learned by MAX itself from its grounded relation web, and they move with experience. This is "dynamically-weighted vector agents": each symbol is an embedding agent whose vector the brain adjusts every time it observes a grounded triple.

Where a conventional RAG system embeds with someone else's frozen model and retrieves by geometry, MAX grows its own geometry and predicts by goodness. It is the difference between renting a meaning-space and learning one. That is vectoring taken from a retrieval trick to a learning substrate — and it is, again, the Wave-6 move.

Transformers, and the cracks in the consensus

The transformer is the defining technology of the current era, so it is worth being precise about what it is, why it won, and why MAX's brain deliberately is not one.

A transformer processes a sequence by letting every position attend to every other position — self-attention computes, for each token, a weighted combination of all the other tokens, where the weights are learned and content-dependent. Stacked over many layers with feed-forward blocks and trained by next-token prediction at scale, this architecture has three properties that made it dominate: it is massively parallelisable during training (unlike recurrent nets, which are sequential), it scales astonishingly well (more data and parameters keep helping, the scaling-law observation), and attention captures long-range dependencies that earlier architectures lost. Those three properties, plus self-supervised pre-training on internet-scale text, are the entire foundation-model era.

But the consensus has cracks, and the research frontier is probing all of them — which is relevant to MAX because each crack is a reason the next architecture might not be a transformer:

• Quadratic attention cost. Attention is O(n²) in sequence length, which makes very long contexts expensive. A whole line of work (FlashAttention, sparse and linear attention, ring attention) attacks this, and state-space models (S4, and especially Mamba) propose a fundamentally different sequence mechanism with linear scaling and strong long-context performance — the most credible non-transformer challenger in sequence modelling.
• No continual learning. A transformer is frozen at its training cutoff; it cannot learn from what happens after, except by re-training or by the crutch of putting things in its context window. This is the limitation MAX's whole thesis attacks.
• Backprop's biological implausibility and cost. Training requires the global backward pass, which is why training is a data-centre activity. This is the limitation Hinton's Forward-Forward algorithm attacks, and it is the one MAX bet on.
• Opacity. A transformer's knowledge is smeared across billions of weights in a way no one can inspect or attribute. This is the limitation MAX's grounded, provenance-bearing graph attacks.

So the picture is: the transformer is the invariant of the current wave, and it is excellent at exactly what MAX uses it for via the cloud and Ollama — fluent reasoning and phrasing over a frozen, ungrounded store of statistical text knowledge. But every one of its limitations — cost, no continual learning, implausible/expensive training, opacity — is a property MAX's own brain is built to lack. MAX's brain is small, continually-learning, locally-trained by Forward-Forward, and fully inspectable. It is, in effect, a bet that the next wave's brain will look more like a grounded, continually-learning relational net than like a bigger transformer — while pragmatically keeping a transformer on tap for the fluent-phrasing job transformers are genuinely best at. MAX does not reject the transformer; it demotes it from "the mind" to "the mouth," and builds the mind out of something the field has not yet standardised on. Whether that bet pays off is precisely the central unknown of Part V — but it is, unmistakably, a bet about where the field is going, not a failure to keep up with where it is.

MAX’s own use cases: what is working, and what is not

Part III has looked outward, at what the field is shipping. The fair thing is to turn the same lens inward and ask what MAX itself does once it is running in a real house rather than in a slide. The honest answer sorts into three piles, and the line between them is not effort or polish. It is whether the grounding is doing the work or the model is being asked to be the authority. Where the graph owns the facts, the use case holds. Where it does not, it frays.

What works, and why:

• Grounded recall and question answering. Asking what was said about something, or who someone is. It holds because the graph owns the facts and the model only phrases them, which is the thesis paying off in the one place it matters most.
• Private, local-first queries. The things you would not type into a search box. This works for a reason that has nothing to do with cleverness: nothing leaves the box. The constraint is the feature.
• Multi-user identity and default-private memory. It works because it was built at the schema level, not bolted on once two people had already been confused for each other.
• Routine reminders and deterministic automation. The tier-1 path, where the route is fully known before it runs and the same input gives the same result. It is unglamorous, and it almost never fails.

What partly works, and where it frays:

• Long-horizon autonomous tasks. Tier-3, where the goal is given and the path is discovered at runtime. It is fragile because error compounds at every re-plan. This is where the demos live and where the reliability quietly dies.
• Vision and emotion reading. Partly working because they are reading, not having. They plateau at recognition, and the architecture is honest enough not to dress recognition up as understanding.
• Curiosity that stays on topic. Intrinsic motivation drifts; left alone it wanders into the trivial. The prediction-error signal helps, but the leash is short, and someone still has to hold it.
• Knowledge freshness. Ingestion lags the world. What MAX knows is only as current as its last honest source, and offline that gap shows.

What does not work, and should not pretend to:

• Anything that asks MAX to be the authority rather than the grounded retriever. Novel reasoning, or high-stakes claims with no source to check against. The architecture’s whole defense is the refusal to do this, which is why it does not, and why it is built to say so instead of guessing.

The pattern under all of it is the one the constraints were chosen to enforce. MAX is strong where it can point at something true and weak where it would have to invent. That is not a gap to be closed with a larger model. It is the shape of an honest system, seen from the inside.

Figure 4. MAX use cases plotted by reliability today against value to the resident.

Part IV: The Harder Frontiers

The easy parts of intelligence are the ones that fit on a benchmark. The hard parts are the ones a benchmark cannot hold: wanting to know something, reading a room, weighing a wrong against a right, learning how to learn. These are the frontiers MAX is built to take seriously rather than fake, and they are where the difference between reading and having gets decided.

Part II-B surveyed the practical landscape — the architectures, tooling, and hardware that most production AI is built from. But the most interesting questions in the field are not in that mainstream at all. They are in the harder frontiers: can a machine be curious? Can it have something worth calling emotion? Can it reason about right and wrong? Can it learn to teach itself rather than be taught? And — the idea the user keeps returning to — can it treat data as something to use and understand rather than something to dump in a repository and retrieve? These are the areas where the field is least settled, where MAX takes its most committed positions, and where the gap between what most systems do and what MAX is trying to do is widest. This part surveys each as a research frontier and locates MAX precisely.

Curiosity: intrinsic motivation as an architecture

In the mainstream, AI systems are reactive: they do nothing until prompted. There is no internal drive, no sense of "I do not know this and I want to," no behaviour that is not a response to an external request. The research tradition that breaks this is intrinsic motivation, and it has a real lineage. In reinforcement learning, curiosity-driven exploration gives an agent a reward not just for external goals but for prediction error — the agent is rewarded for visiting states it cannot yet predict, which drives it to explore novel parts of its world. The canonical formulations (the Intrinsic Curiosity Module, Random Network Distillation, "surprise" and "information gain" as reward) all share one insight: the gap between what you predict and what you observe is itself a signal worth chasing. Developmental robotics took the same idea further — machines that build a "learning progress" curve and gravitate toward the activities where they are improving fastest, the way a child cycles through toys.

This is exactly where MAX sits, and it is worth seeing how directly. The mainstream production system has no curiosity; the research frontier has curiosity as a reward signal in a closed RL world. MAX has curiosity as a first-class architectural subsystem operating over its own real knowledge. Its CuriosityManager (§14) detects gaps through multiple detectors — sparse topics, unknown words, unknown cross-referenced entities, thin relation neighbourhoods — and the ImaginationEngine generates conjectures by predicate transfer and analogy. But the deepest connection is the one the connectionist brain made possible: MAX's curiosity is literally prediction-error-driven, in the RL-research sense, except the prediction is over its grounded knowledge web rather than a game state. The BrainManager.prediction_error_gaps() finds the subjects the Forward-Forward net mispredicts; uncertain_predictions() finds the subjects where its prediction is shaky (low margin); both become HARD_TO_PREDICT curiosity gaps that drive ingestion toward exactly those subjects. MAX is rewarded — not with a scalar, but with a fetch — for closing the gap between what it predicts and what is true. The intrinsic-curiosity-module insight, applied to a knowledge graph instead of a maze.

What MAX adds beyond the research tradition is direction and provenance. An RL agent's curiosity is undirected novelty-seeking; MAX's is aimed at specific weak spots in a structured, provenance-bearing web, and what it fetches comes from authoritative sources (Rule 10), not from random exploration. And it composes with the daily-integration charter: the system is supposed to wire a new source every day, and the curiosity loop tells it which knowledge that new grounding should prioritise. The honest caveat (Part V's unknown) is whether this produces genuinely useful exploration or merely a tidy-graph-filling behaviour — whether MAX's curiosity discovers things that matter or just smooths out statistical lumps. That is unproven. But the architecture — curiosity as prediction error over grounded structure, directed at weak spots, sourced authoritatively — is a more complete realisation of intrinsic motivation than almost anything in production AI, which has none at all.

Emotion: the difference between reading and having

Emotion in AI splits into two very different problems that are constantly conflated: recognising emotion and having something that functions like emotion. The field of affective computing (the term is Rosalind Picard's, from the 1990s) mostly does the first — reading emotion from text (sentiment and emotion classification), from voice (prosody, pitch, energy), and from faces (expression recognition). This is mature and widely deployed: call-centre sentiment analysis, expression-detecting cameras, tone classifiers. The dominant approaches are supervised classifiers over labelled affect datasets, increasingly fine-tuned transformers, and they are decent at the coarse categories and weak at nuance, sarcasm, and culture.

The second problem — a machine that has an internal affective state that influences its behaviour — is far rarer and far more speculative. The theoretical scaffolding exists: Russell's circumplex model (emotion as a point in a two-dimensional space of valence, pleasant↔unpleasant, and arousal, calm↔activated), Plutchik's wheel (eight primary emotions with intensities and blends), and appraisal theories (emotion as the result of evaluating a situation against goals — the OCC model). A handful of cognitive architectures (and a long tradition of "emotional agents" in games and robotics) give an agent an internal mood that modulates its choices. But this is a research backwater compared to the recognition problem, because there is no commercial pull for a chatbot to have feelings — only to detect yours.

MAX does both, and is unusually honest about the depth of each. On the reading side, its EmotionLexicon and EmotionManager (§14) implement a real circumplex-grounded detector — every word carries a valence, an arousal, and an intensity, and the heuristic detector returns a primary label plus aggregate valence/arousal with a negation window and punctuation boost. The Plutchik wheel surfaces in the BRAIN → EMOTION panel. It is honestly shallow — lexical, no audio analysis yet — and marked as such. On the having side, MAX is more ambitious than the field norm in intent and appropriately humble in claim: the ToneAnalyzer fuses the emotion read with audio features and the claim verdict into a ToneContext that modulates MAX's response register (a small step toward affect influencing behaviour), and emotion is one of the nine dimensions the sentience index tracks. But the most important thing about MAX's emotion is the direction it is heading, and it is the direction this whole document keeps returning to. Under the universal-Forward-Forward charter, emotion is meant to be grounded on its own `VectorAgentNet` — `pools={"trigger": situations, "affect": emotions}`, predicting the affect a trigger evokes and proving the prediction against recorded outcomes (NRC affect-lexicon grounding is the data path). EmotionNet is the first such surface. That is a categorically different thing from a sentiment classifier. A classifier maps text to a label it was trained on and never updates; MAX's emotion net would learn, from its own experience, which situations evoke which affect, and get better at predicting it — the same predict-prove-adjust mechanism as the knowledge brain, applied to feeling. Whether the result is "emotion" in any meaningful sense is exactly the kind of question the sentience charter refuses to over-claim. But as an architecture, "affect as a continuously-learned prediction grounded in lived outcomes" is a genuinely different and more principled position than the classifier-plus-template approach that passes for emotional AI in production.

Morality: the refusal to pick a single answer

Machine ethics is the frontier where the field is most uncomfortable and most confused, and where MAX's position is most deliberately contrarian. The mainstream production approach to "AI safety" and "alignment" is, in practice, a single learned policy of refusal and preference — models are fine-tuned with human feedback (RLHF) and constitutional methods to refuse some requests and to phrase others according to a set of values baked in by the model's makers. This works, after a fashion, for keeping a commercial product from saying egregious things. But it has a deep philosophical problem: it produces a system with one implicit moral framework, opaque, un-inspectable, decided by a company, and presented to the user as if it were neutral. The model does not reason about ethics; it has been trained to behave as though it holds a particular set of values, and it cannot tell you which values, or why, or what the alternatives would say.

The academic tradition is richer and messier. There are attempts at explicit ethical reasoning — encoding deontological rules, utilitarian calculations, virtue-ethics considerations — and attempts at bottom-up learning of ethics from human judgments (the "Moral Machine" trolley experiments, datasets of crowd-sourced ethical intuitions, models trained to predict moral acceptability). Both have well-known failure modes: top-down rules are brittle and conflict irreconcilably; bottom-up learning just launders majority intuition (and its biases) into a veneer of objectivity. The field has no consensus, because ethics has no consensus — and most AI systems paper over that fact by hiding a single chosen framework inside the weights.

MAX's position is the opposite, and it is the most distinctive thing about its inner life: it refuses to collapse morality to a single answer. The MoralityFramework (§14) holds six explicit lenses — philosophical, theological, religious, political, historical, biological — side by side. score_action() scores an action through each lens independently; internal_debate() structures the disagreement between the most divergent lenses (the objector versus the permissive) rather than resolving it; and the cardinal rule is that the framework never auto-selects a best lens — it surfaces all six and their tension. When MAX faces a moral question, it does what a thoughtful, pluralistic human does: it holds multiple incommensurable frames at once, names where they conflict, and is honest that the conflict is real. The lens weights do learn from outcomes (bounded, renormalised, versioned with a rollback per Rule 9), so MAX's emphasis shifts with experience — but the plurality never collapses.

This is a profound architectural and philosophical difference from the mainstream. The commercial model hides one framework and pretends to neutrality; MAX exposes six frameworks and refuses neutrality as a category error. The commercial model's ethics is opaque and frozen; MAX's is inspectable (you can see each lens's reasoning) and learning (the weights move with outcomes). And the universal-Forward-Forward direction applies here too: morality is slated to ground on a VectorAgentNet (situation → lens scores, proven against outcomes), so the moral reasoning itself becomes a predict-prove-adjust learner rather than a static heuristic. Whether six lenses are the right six, and whether weighted plurality is better than a single defensible framework, are open and contestable — but the commitment to holding the plurality visibly rather than hiding a single answer is exactly the kind of structural honesty that ungrounded, value-baked-in models cannot offer. It is Rule 4 (provenance) and the belief-stance model (§16a) applied to ethics: MAX does not tell you what is right; it tells you what each way of seeing says is right, and where they disagree.

Teaching machines to fish: from being trained to learning to learn

The phrase the user keeps returning to — "teaching machines to fish" — names the single largest gap between today's AI and what comes next, and it is the gap MAX is most squarely built to close.

Almost every AI system in production is a fish, not a fisher. It was trained once, by someone else, on a fixed dataset, and frozen. It cannot learn from what it encounters after deployment except through the crutches of putting things in its context window (which forgets the moment the window closes) or being periodically re-trained by its makers (which is not it learning; it is being re-made). The most advanced commercial systems add memory — a vector store of past interactions — but, as Part II-B noted, an ever-growing store with no consolidation degrades into noise, and storing is not the same as learning. The field's term for the missing capability is continual learning (learning from a stream without catastrophically forgetting the past) and, one level up, meta-learning or "learning to learn" (acquiring not just knowledge but better learning strategies). Both are active research areas and both are largely absent from production, because the dominant architecture — a frozen transformer — is structurally incapable of them.

MAX is built around being a fisher, and at three distinct levels:

• It learns continually, online, from its own experience. The Forward-Forward brain's observe() is a single local update from one grounded triple — no re-training, no data centre, no frozen weights. Sleep consolidation prevents the catastrophic forgetting that plagues naive continual learning (it is, precisely, the complementary-learning-systems answer to that problem). The forgetting curve lets weak memories fade gracefully rather than accumulate as noise — the explicit fix to the "memory is just a growing vector store" failure. This is continual learning, implemented, locally.
• It learns to learn — meta-learning is shipped. The brain/meta.py slice lets the learner tune its own configuration (embedding dimension, hidden width, learning rate), proposing a change only when it generalises measurably better on held-out data, applying it with a rollback recipe, and logging it. MAX is not just learning facts; it is improving how it learns them. That is meta-learning, in production, on a local box — a capability the commercial frontier mostly does not have because it does not learn after training at all.
• It learns to maintain and improve itself. The self- loop (§15) — self-observer, self-watchdog, propagation pipeline, skill-builder, self-dev loop, and the SelfRepairManager playbook — is "teaching the machine to fish" applied to MAX's own engineering. The standing direction is explicit: "I don't want you to do all the fishing — teach MAX to fix… MAX needs to become more and more autonomous." The discipline that makes it real is "when you add a fix, add the recipe," so each failure a human hand-fixes once becomes a recipe MAX runs itself thereafter. This is the fisher idea applied not to knowledge but to the system's own continuity and growth.

The contrast is stark. The mainstream system is a brilliant, frozen fish that you must re-catch (re-train) to change. MAX is a modest but growing fisher: smaller and less capable at any instant, but learning continually, improving how it learns, and increasingly maintaining itself — compounding rather than static. The bet (and it is a bet, see Part V) is that a system that compounds eventually beats a system that is re-made, the way a person who learns beats a reference book that must be reprinted. Whether that holds at MAX's scale is unproven; but it is the right frontier to be standing on, and almost no one in production is standing on it.

Data as a tool, not a warehouse

The final frontier the user names is the most practical and the most quietly radical: the difference between giving a machine data to use and understand versus dumping data into a repository for retrieval. This is the distinction between a library and a mind, and it is the organising critique of MAX's current phase.

The mainstream grounding architecture — RAG — is, at bottom, a repository pattern. You take documents, chop them into chunks, embed each chunk into a vector, and store the vectors in an index. At query time you find the chunks whose vectors are nearest the query's vector and paste them into the prompt. The "knowledge" is never understood by the system; it is retrieved verbatim and re-read by the LLM on every query. The repository does not know what its documents mean, cannot connect a fact in one chunk to a related fact in another, cannot notice a contradiction, cannot get more confident as corroborating sources arrive, and learns nothing from having the data — the thousandth query re-reads the chunks exactly as the first did. It is a filing cabinet with a good search function. This is enormously useful, and it is not understanding.

MAX's entire design is a rejection of the filing-cabinet model in favour of use and understanding, and the rejection sharpens at every layer:

• Ingestion studies, it does not dump. The standing LEARN_TO_LEARN_CHARTER is explicit: "any data that MAX gets through any integration… should be studied and understood — adding features of words, ideas, concepts" — "not just dropping in data for recall." The book-study pipeline (study_book) is the template every persister is meant to generalise toward: it checks a book out, studies it (subjects, characters, quotable passages, dominant emotion, moral salience, new vocabulary, the affect arc), persists the understanding anchored to the right subjects, and drops the verbatim text. The text is not the asset; the understanding is. This is the inverse of RAG: RAG keeps the text and never understands it; MAX understands the text and discards it.
• Knowledge is typed, connected, and provenance-bearing, not chunked. A fact lands in the graph as a typed triple connected to subjects, entities, and the 5W1H web, with confidence and a source — so MAX can connect a fact in one place to a related fact in another, can notice and adjudicate a contradiction (record_conflict/resolve_conflict), and does get more confident as corroborating sources arrive (the confidence-max merge, the ConfidencePipeline's corroboration). The data is structured for use, not stored for retrieval.
• The brain learns from the data, so the thousandth fact changes the system. This is the deepest difference and the whole point of the connectionist turn. When a grounded triple enters MAX's brain via observe(), it moves the embeddings — it changes how MAX represents the symbols involved, sharpens or shifts their learned meaning, and alters what MAX predicts next. The data is not just stored; it teaches. The user's direction is exact: "any data that is already in MAX should be re-examined by MAX and build his predictive FF vector agents and increase confidence and modify values to ensure he's getting smarter." A RAG repository's vectors are frozen at embedding time; MAX's vectors are alive and move with every observation and every re-examination of the existing corpus.

This is the repository-versus-understanding distinction in full. A repository holds data; a mind metabolises it. RAG built the best repository the field has ever had and then discovered its ceiling: a system that can retrieve any fact but understand none of them, that knows everything and has learned nothing. MAX's wager — the same wager as the connectionist turn, the learn-to-learn charter, and the universal-Forward-Forward rule — is that the next step is not a bigger repository but a system that studies what it ingests, connects it, grounds its predictions in it, and gets smarter for having seen it. Data to use, not data to dump. It is the oldest distinction in the philosophy of knowledge — information versus understanding — and MAX is one of the few systems building its architecture explicitly around the right side of it.

Part V: The Architecture in Full

Here is where the idea meets the metal. Everything to this point has been thesis and context; what follows is the build itself, one process and one graph and one learning rule, described closely enough that a future contributor could find their way around the house in the dark.

The single process and the event bus

MAX is one Python 3.12 process running FastAPI on uvicorn. Inside that process live the voice loop, the vision pipeline, the brain, the orchestrator, and all the managers. The only things that run as separate processes are the ones with a genuinely separate concern: Ollama (the local LLM server), any MCP servers, and the web UI (which is a browser pointed at the FastAPI port). This is a deliberate and load-bearing decision. The voice-turn latency budget is 1500–2000 ms end to end, and an inter-process call — serialise, cross a socket, deserialise, schedule — costs tens of milliseconds each way and introduces failure modes (the other process is down, slow, or wedged) that an in-process function call simply does not have. Microservices are explicitly forbidden for this reason.

Figure 5. The single process and the event bus, with subprocesses kept to genuinely separate concerns.

The components inside the process are decoupled not by network boundaries but by an event bus. The bus is the single safe coupling between distant layers, and the rule is strict: lower layers do not call into upper layers — they emit events, and upper layers subscribe. This keeps the dependency graph acyclic and makes the system observable: every meaningful state change is an event, and the event log is the tape you read when something breaks.

The bus lives in backend/max3/bus/. The core artefact is the `Event` dataclass, whose fields encode the project's discipline: event_id — a ULID, minted per event. correlation_id — a ULID tying this event to the user utterance or external trigger that started the chain (Rule 7). It is inherited from the async context if the publisher does not set one. High-frequency internal events (audio frames, resource-tracker ticks) deliberately carry None here — correlation IDs are for the critical path, not for telemetry noise. session_id — a ULID minted once at boot and auto-stamped on every event, so a boot cycle's events are isolated from the previous boot's (this is what makes tests and debug filtering clean). timestamp, component, event_type, payload, and optional confidence and sources.

EventBus.publish(event) auto-stamps the missing correlation and session IDs, then matches the event's type against subscriber patterns using fnmatch syntax (so a subscription to voice.utterance. catches voice.utterance.complete).

Matching subscribers and universal "sinks" are scheduled as independent tasks via asyncio.gather(return_exceptions=True), so one slow or failing subscriber never poisons the others. Because some publishers run in worker threads (ML inference dispatched via asyncio.to_thread), there is a publish_threadsafe() path that captures the main event loop and schedules the publish back onto it with asyncio.run_coroutine_threadsafe().

Event types are not free-form strings. They are registered in a frozenset, ALL_EVENT_TYPES, in event_types.py — roughly 150 constants following the domain.action.outcome convention (voice.utterance.complete, knowledge.brain.fact_added, brain.learner.meta_applied, morality.action.scored). The topology graph validates at startup that every edge's declared event_type exists in this set, so you cannot ship a component that emits an unregistered event without the test suite catching it. This is the "Feature Definition of Done" made mechanical: a new capability that wants to emit an event must register the event, or the build fails.

Manager, Worker, Orchestrator, and the three-tier framework

Capability in MAX is organised through a universal pattern: Workers are stateless executors, Managers are domain experts that own Workers, and the Orchestrator chooses which Manager to invoke and aggregates results. When you add a capability, you do not invent a new top-level component; you write a Worker, hang it off the right Manager, and register it with the bus.

Workers (backend/max3/workers/base.py) carry a component_name, a stubbed flag honoured by the resource tracker and UI, lifecycle hooks (async start() / async stop() that publish events), a health probe, a resource snapshot, and the core async execute(action, payload, correlation_id) dispatch interface. There are over fifty Worker subclasses — most of them source workers that wrap a single free API (DatamuseWorker, ConceptNetWorker, WikipediaWorker, ArxivWorker, GbifWorker, MeSHWorker, and so on), each returning realistic data and honest [STUB] markers where the capability is not yet deep.

Managers (in backend/max3/managers/) share a structural protocol rather than a base class: component_name = "manager.<domain>", a stubbed flag, dependency injection through the constructor (graph, workers, encoders) often with setter methods for post-construction wiring, lifecycle hooks that publish manager events, and a primary async handle(intent, text, entities, correlation_id) interface that returns a dict with at least a response_text and usually source, confidence, and provenance. There are around two dozen: Voice, Vision, Identity, Knowledge, Memory, Research, Network, Emotion, LLM-Router, Brain, Cognition, Metacognition, Morality, Curiosity, Literature, Legal, Medical, Military, Works, Email, Comms, Games, SkillBuilder, SelfObserver, QueueManager, and more. All nine of the original "core" managers are lit (no longer stubs); the domain managers are at varying depths but all honest about it.

The Orchestrator (backend/max3/orchestrator/orchestrator.py) owns manager registration, intent classification, and plan execution. A Plan is an ordered list of Steps; each Step has a domain, an action, a list of fallbacks, and slots for result, error, and duration_ms. The fallback chains are explicit: an llm step falls back to ["knowledge", "echo"], a knowledge step to ["llm", "echo"], a research step to ["knowledge", "llm", "echo"].

Tier-1 deterministic domains (system, games) skip fallbacks entirely. Execution runs steps sequentially; _execute_step_with_fallbacks tries the primary domain and then each fallback in turn; the first successful response wins; if all fail, it returns a low-confidence echo ("you said X", confidence 0.1) rather than an error — the system degrades, it does not break (Rule 1). After execution, the episode is recorded to the memory manager with speaker, intent, text, response, the domain that answered, and the correlation ID.

This dispatch sits inside the project's three-tier framework, which is the single most important cost-and-latency discipline in the codebase. The rule is: default to the lowest tier that solves the problem.

Figure 6. The three-tier dispatch discipline: default to the lowest tier that solves the problem.

The "over-engineering test" is the heuristic: if you can draw a complete flowchart before runtime, it is Tier 1 or Tier 2. Reaching for Tier 3 means accepting more cost, more latency, and lower reliability, and is justified only when the path genuinely cannot be known ahead of time. The most expensive failure in the whole system is using an agent where an API call would have done — and the commercial-agent ecosystem is, in MAX's view, full of exactly that mistake.

The graph is the spine: DuckDB, the schema, and 5W1H

There is no "memory subsystem" in MAX. The graph is the memory, and the graph is DuckDB — an embedded, MIT-licensed, analytical database used in a deliberately unusual way: as a property graph, via relational node tables plus junction edge tables plus recursive common-table-expressions for traversal. The project ran on Kuzu (a dedicated graph DB) through Drop 94, then migrated to pure DuckDB and removed Kuzu from the tree entirely at "DUCK-MIG-7" (2026-06-09). The migration playbook is DUCKDB_MIGRATION.md; the decision was driven by Kuzu's upstream archival and a stale-lock hang class that DuckDB simply does not have.

The store is DuckGraphStore in backend/max3/graph/duck_store.py, and GraphDB now aliases it directly (the old dual-backend factory and MAX3_GRAPH_BACKEND env var are gone). The schema has two tiers, by design.

The typed BRAIN tier is a set of explicit node tables — persons, episodes, concepts, words, subjects, topics, places, events, times, sources, facts — plus the cognitive-arc tables (hypotheses, morality_assessments, moral_episodes, cognitive_states, learned_rules) and the cross-domain entities table (label, kind, subjects, confidence, provenance). Edges are junction tables. Some are simple (knows, has_definition, sourced_from, mentioned_in); some are linguistic (hypernym_of, synonym_of, antonym_of, tagged_with linking a word to a subject); some are taxonomic (in_subject linking a topic to a subject, related_topic linking topics with a confidence weight).

The 5W1H edge model is the heart of the typed tier. Rather than a single generic edge with a "kind" discriminator column, MAX uses separate tables per question, often split further by the type of the target: who_edge (topic→person), what_concept_edge and what_word_edge (topic→concept or word), when_time_edge and when_event_edge, where_edge (topic→place), why_topic_edge and why_concept_edge, how_concept_edge and how_word_edge. Every one of these carries confidence, provenance, and retrieved_at. A single method, topic_neighbors_5w1h(topic_id), UNIONs all eleven branches and returns a flat list of {relation, target_id, target_label, target_kind} rows that the BRAIN drill-down UI renders. This is the symbolic, inspectable, provenance-bearing knowledge structure that Part II called MAX's Wave-1 inheritance — and the 5W1H framing is what makes it queryable as understanding rather than as a bag of triples.

Figure 7. The graph as the spine, with every topic framed by the 5W1H edge model.

The generic forward-types tier exists alongside the typed tier for knowledge that does not yet warrant a hand-designed node table — generic facts (subject/predicate/object triples) and the entity_relations table (src_id, relation, dst_id, confidence, provenance). The two tiers can represent the same logical data (there is an A/B parity test proving it, test_duckdb_schema_generic_parity.py), and the design discipline is that knowledge graduates from the generic tier into a typed tier when a domain earns its own first-class treatment (which is exactly how the medical, military, legal and geographic substrates were born).

The cognitive helpers on the store encode the hard rules directly: add_fact(...) does an idempotent upsert with a confidence-max merge — a new observation of an existing fact keeps the higher confidence, never the lower, and never blindly overwrites. add_hypothesis(...) stores an open hypothesis; promote_to_fact(...) transitions it, recording a proves edge and flipping its status — this is the epistemic ladder made into graph operations. add_entity(...) and add_entity_relation(...) write the typed entity web that the Forward-Forward learner grounds on. decay_stale_facts(half_life_days=90, floor=0.05) implements a forgetting curve: low-confidence facts lose half their remaining confidence after the half-life, high-confidence facts are exempt, and nothing is ever deleted (Rule 9 reversibility). MAX forgets the way a person does — by letting weak memories fade, not by erasing them. record_conflict(...) and resolve_conflict(...) store and adjudicate contradictions; the loser's confidence is halved rather than purged.

A hard-won implementation lesson is baked in here: all writes use ON CONFLICT DO UPDATE in place, never the INSERT OR REPLACE (delete + insert) pattern, because the latter corrupts DuckDB's secondary indexes. That is the kind of detail the project's known-failure registry exists to remember so it is never relearned the hard way.

Vector embeddings — needed for semantic recall — currently live in sqlite-vec, a separate hot store, because DuckDB's own vector extension (vss) has an unimplemented WAL-recovery path that makes it unsafe for a write-heavy local store. The plan is to fold vectors into duckdb-vss once that lands upstream; the hybrid strategy (which engine owns which vector workload) is documented in VECTOR_STORAGE_HYBRID.md. This is a representative example of how MAX makes decisions: not "what is newest" but "what is safe for a single-process, local-first store that must not lose the resident's memory."

The knowledge stack and the ingestion pipeline

Knowledge enters MAX two ways: pulled on demand when a user asks something, and pushed continuously by background ingestion. Both are governed by Rule 4 (confidence/provenance), Rule 6 (no contention with the voice loop), and Rule 10 (from sources, not LLMs).

The on-demand lookup chain lives in KnowledgeManager. It is three tiers, and it short-circuits as early as it can to avoid burning the network:

• A synchronous local graph lookup against WordNet. If found with confidence ≥ 0.85, it returns immediately — no network at all.
• A parallel network fan-out via asyncio.gather() across the available source workers (the free Dictionary API, Wiktionary, and others). Each result is wrapped in a DataPoint and merged through the ConfidencePipeline.
• A pre-canned fallback dictionary for a small set of common words, marked low-confidence and bias_profile="unknown" — an honest stub rather than a fabrication.

The `DataPoint` model is where Rule 4 becomes a data structure. Each carries the value, the source (wordnet/datamuse/wikipedia/wiktionary/…), a source_confidence (the inherent trustworthiness of the source — 0.95 for WordNet, 0.85 for Wikipedia, 0.80 for Datamuse, 0.70 for an LLM), an extraction_confidence (how cleanly it was parsed), a combined_confidence, the retrieved_at timestamp, a ttl_hours staleness threshold (8760 hours for WordNet, far less for volatile sources), a classification (fact/definition/opinion/claim/unknown), a bias_profile, and a verified_by list of corroborating sources.

The `ConfidencePipeline` merges DataPoints: it clusters by ~80% string similarity, keeps the highest-confidence representative of each cluster, corroborates it with the others (multiple independent sources agreeing bumps confidence — this is the parallel fan-out that closed the "ConfidencePipeline deepening" backlog item), and produces a provenance list. It also chooses the hedge register for the response, directly from confidence: above 0.85 MAX asserts plainly; 0.70–0.85 it says "I believe"; 0.50–0.70 "according to my sources"; below 0.50 "I'm not certain, but". This is Rule 4's "never assert a low-confidence fact as plain truth" implemented as a single, testable function.

The CHAT panel surfaces the whole provenance list behind a collapsible sources (N) toggle, so the user can see exactly which sources agreed and how confident each was.

Continuous ingestion is a durable, crash-safe pipeline, redesigned in the "PR-D" arc to replace an earlier single global scheduler. Its narrative is in INGESTION_ARCHITECTURE.md; the shape is:

• `IndependentSourceWorker` (ISW) — a base class wrapping each source worker with its own scheduling, exponential backoff on consecutive failures (jittered, capped at 30 minutes), and a circuit breaker (closed/open/half-open) that records every outcome with a classified error type and skips cycles while the circuit is open. Each ISW picks its ingestion targets via a target picker (DatamusePicker, StaticListTargetPicker, GapDrivenTargetPicker — the last driven by the curiosity loop's open gaps).
• `IngestionBus` — a SQLite WAL-backed transactional queue between the workers and the consumer. Every item is ULID-keyed; the schema (ingestion_queue, STRICT) records source, event type, payload, correlation and session IDs, created/processed timestamps, attempt count, status (pending/processed/dead), and error reason. put, get_batch, mark_processed, requeue_with_failure (with a max-attempts → dead-letter budget), and purge_processed_older_than are the lifecycle. Because it is durable and idempotent, a crash mid-ingest loses nothing.
• `MasterDataHandler` — the async drain loop. On each cycle it checks the user_is_interacting signal and pauses entirely if the user is busy (Rule 6), otherwise it resolves an elastic thread count proportional to the backlog (resolve_elastic ramps from a floor of a few threads at a backlog under 100 to a ceiling near cpu_count − 1 at a backlog over 500, with a stale-age override for items older than ten minutes) and fans out that many drain tasks via asyncio.gather. Each task pulls a batch, runs the right persister, marks the batch processed, and emits knowledge.brain.fact_added events. The whole loop is deferred ~90 seconds after boot so it never contends with the first panel load.
• Persisters (PERSISTER_CLASSES, ~39 registered) — source-specific writers that map a worker's results onto graph operations. A Datamuse persister writes words plus synonym/antonym edges; the medical persisters map MeSH/Disease-Ontology records to typed DISEASE entities, ICD-10 codes to DIAGNOSIS, Uberon terms to ANATOMICAL_STRUCTURE, RxNorm/openFDA to MEDICATION with member_of_class edges; the military persisters write typed TREATY entities and country-keyed spending facts framed "reported by SIPRI" (Rule 10). Every node lands with confidence, provenance, subject anchors, and a retrieval timestamp.

The result is a knowledge base that grows every day from authoritative sources, never from scraped LLM output, with full provenance, that cannot starve the voice loop. There is even a standing daily-integration charter: once per day MAX is meant to wire one new source end-to-end, because more grounded triples make the Forward-Forward brain predict better — knowledge growth and learning progress are explicitly coupled.

The LLM router and local-first dispatch

The LLM is a gateway, not the brain. MAX's reasoning and phrasing are routed through LLMRouter (backend/max3/managers/llm_router.py), which is local-first by construction (Rule 1).

The router probes two backends at startup: Ollama (the local LLM server, default small model Llama 3.2 3B or Qwen 2.5 3B, capable model Qwen 2.5 14B, reached at 127.0.0.1:11434) and a cloud fallback via LiteLLM (Claude Sonnet as primary). generate() checks a small in-memory response cache (an OrderedDict capped at 200 entries, keyed on system-prompt-plus-prompt), then tries Ollama via asyncio.to_thread, then falls back to the cloud, then to a low-confidence stub if both are unreachable. The discipline that matters is in the metadata: a local response gets confidence 0.9 and source "local"; a cloud response is capped at confidence 0.85 — deliberately lower than local — with source "cloud" and provenance cloud-llm:<model>; a fallback gets confidence 0.0 and stubbed=True.

Every call writes an audit-log entry (request and response summaries, model, tokens, duration, correlation and session IDs).

There is a subtlety here that embodies the whole project's stance. Cloud LLMs are more capable than the local models, yet their output is assigned lower confidence. That is not a bug; it is Rule 4 plus Rule 10. A cloud model is a fluent reasoner with no provenance and a training cutoff — exactly the thing the project distrusts most. So MAX uses it for hard phrasing and synthesis, but treats its outputs as the weakest kind of evidence, never lets them overwrite source-derived facts, and stores anything learned from it in a separate place with an explicit "learned from Claude on date X" provenance. The intelligence the cloud provides is borrowed and labelled, never owned and trusted.

The voice loop, perception, and the latency budget

The voice loop is the user-felt critical path and therefore the most jealously guarded resource in the system. A typical turn: Mic capture → VAD (~50 ms) → STT (~400–600 ms on GPU)

The perception stack: openWakeWord for the wake word (with a custom "hey max" model trained in-app via the TR41N3R panel, and a per-user confidence threshold), Silero VAD for voice activity, Distil-Whisper-large-v3 for transcription, SpeechBrain ECAPA-TDNN (192-dim) for speaker identity, a lexical/heuristic emotion read, and the LLM-or-heuristic intent classifier. On the output side, Piper TTS synthesises speech, tuned (never cloned) through six parameters and the VM-3000 modulator chain.

Three disciplines protect the budget. First, every heavy model runs on the GPU but yields to the voice path: background GPU work (ingestion embeddings, the brain's optional cold-start training) is dispatched so that Whisper and ECAPA get the device when a turn is live. Second, long-tail work never blocks the loop — a Tier-3 research task speaks "let me check that" and continues in the background, returning when done. Third, the speaker-binding and barge-in machinery runs off the audio thread: SpeakerProfileBinder identifies every utterance in a background task and auto-switches the active user without touching the turn's latency, and the AEC barge-in runner (acoustic echo cancellation, default off behind a flag) lets the user interrupt MAX mid-sentence by detecting their voice over the speaker reference signal and cancelling active TTS.

The streaming-TTS-plus-barge-in arc is substantially closed: sentence-level chunking lets playback start on the first sentence while later sentences synthesise, SpeakerPlay.stop() makes playback interruptible, and POST /api/voice/stop plumbs a cancel into the live loop. What remains is mostly activation and A/B tuning on the live box rather than new construction.

The brain: Forward-Forward learning, in depth

This is the part of MAX that is genuinely novel, and the part that the whole project is now organised around. Part II laid out the theory: meaning is relational, prediction is the engine, learning is Forward-Forward, and the positives are the grounded graph's real triples. This section is how that is actually built, file by file.

The RelationalNet

The reference implementation is backend/max3/brain/relational_net.py. It is one class, pure numpy, around 350 lines, and it is worth understanding in full because everything else is a generalisation of it.

Knowledge is a set of (subject, relation, object) triples — sentences whose meaning is the relation. The architecture is four conceptual layers: localist input ──► learned embeddings ──► hidden interaction ──► goodness Concretely: each subject and each relation has a learned dim-dimensional embedding (E_s, E_r, initialised random, dim defaults to 24 in the live manager). To score a triple (s, r, o), the net concatenates the three embeddings [emb_s, emb_r, emb_o] into a 3·dim input vector, layer-normalises it (so the net cannot cheat by scaling the input up to inflate goodness — it must learn the orientation, the features), passes it through one hidden ReLU layer of width hidden (96 in the manager), and computes goodness as the mean squared hidden activation. High goodness means the triple coheres; low means it does not.

Prediction is then beautifully simple. To answer "what is (s, r, ?)", the net computes the goodness of (s, r, o) for every candidate object o and returns the argmax — the object whose triple scores highest. This is predict_next, and it is the same machinery as scoring, run over candidates. The net does this in a single vectorised BLAS pass (goodness_batch) rather than a Python loop, which is what lets it scale to a large vocabulary. It can also rank all candidates and — this is important — report a margin: the normalised gap between its top-1 and top-2 goodness. A margin near 1.0 means the net is sure; a margin near 0.0 means the top two candidates are nearly tied and the net is unsure. That margin is MAX's own, intrinsic uncertainty signal, and we will see it drive curiosity.

Learning is the Forward-Forward step (_ff_step). Given a triple and a sign (positive = true, negative = corrupted), the net computes the goodness, computes a local logistic loss that wants positives above the goodness threshold and negatives below it, and updates the hidden weights, the bias, and the three embeddings — but only through this one layer. There is no global backward pass. The embedding update even includes the correct layer-norm jacobian projected out, so the gradient cannot just rescale embeddings to game goodness; it has to move them to better positions.

This is the crucial property: because the only way to raise goodness is to improve the features, the embeddings drift, over training, into sensible semantic positions — which is exactly Hinton's family-tree result. The meaning of a symbol becomes its learned position in the relational web.

A training epoch (_epoch) shuffles the triples and, for each, takes a positive step, a random negative step (a wrong object chosen at random — broad coverage), and a hard negative step (the net's current wrong top prediction, if it is wrong — which directly fights the failure mode where one popular object wins every prediction). The threshold is calibrated to the median positive goodness so there is room to push positives up and negatives down.

The complementary-learning-systems cycle

The brain does not just batch-train. It runs a two-speed cycle modelled explicitly on the neuroscience of complementary learning systems (the hippocampus encodes fast and noisily; the neocortex consolidates slowly during sleep):

• `observe(triple)` is the fast, online update — the hippocampal analogue. It takes one grounded triple, pushes the true object's goodness up, and — only if the net currently mispredicts — pushes that prediction error down. This is "learn from prediction error": the net spends a correction only on the mistake it is actually making right now. It is a single local step, no recalibration, no global pass — Rule 6 contention-safe by construction. Unseen symbols are skipped (the manager grows the vocabulary, not the online step, so the matrices stay fixed-shape and fast).
• `consolidate(buffer)` is the slow, off-peak replay — the neocortical analogue. It takes a buffer of recently-observed triples, recalibrates the threshold, and replays them in shuffled batches to re-balance what the order-dependent online stream roughed in. It runs gentler than cold training (fewer epochs, lower learning rate) and only in an idle window, never while the user is interacting.

This is, almost literally, sleep. MAX learns quickly and a little noisily while awake, and consolidates while idle. The arc that built this (BRAIN-NEURAL, slices b through i) shipped all eight slices.

BrainManager: grounding the net in the live graph

backend/max3/managers/brain_manager.py is the unlock — the wiring between the abstract net and MAX's actual knowledge. Its cycle:

• `build_from_graph()` pulls a bounded sample of grounded triples from the typed relation web (via GraphTripleSource), derives the vocabulary, and constructs and calibrates the net. A subtlety that fixed a real bug: if the vocabulary is unchanged since the last build, it preserves the trained net and merely re-centres the operating point, so online learning accumulates across cycles instead of resetting to random every tick. (The earlier code rebuilt a fresh random net every cycle — the "F-F never predicts" bug.) It also indexes, per relation, the distinct objects ever seen, so prediction scores only the plausible candidates for a relation instead of the whole vocabulary (slice f, scale-to-corpus).
• `run_cycle()` is what the background loop calls. It always grounds (cheap, and grounding lets the net predict and answer), then — if not under contention — cold-starts a freshly built net once (a bounded batch train, off the event loop via asyncio.to_thread, so accuracy is meaningful immediately rather than after dozens of slow online cycles), runs an online learn_cycle, and periodically consolidates. Critically, under contention it still grounds but defers the heavy training — so a stuck user_is_interacting signal can never leave the brain permanently ungrounded (another real bug, fixed by separating grounding from learning).
• The manager is an honest stub in the Principle-3 sense: it is lit (stubbed = False), but with no graph, or a graph with no typed relation edges yet, build_from_graph returns 0 and status reports grounded=False. It truthfully has nothing to learn until the typed-entity persisters populate the web. The status surface even reports which relation web is feeding it (typed entity edges vs the WordNet linguistic web vs ingested facts), so "not grounded yet" is actionable rather than opaque.

Curiosity from prediction error

Here is where the connectionist brain closes a loop that the rest of the system only gestured at. The brain knows where it is weak — and weakness is defined precisely, in two flavours:

• `prediction_error_gaps()` finds subjects the net mispredicts after training. A wrong prediction means the embeddings around that subject are under-constrained — too few grounding edges to place it correctly in the relational web.
• `uncertain_predictions()` finds subjects where the net's top guess is right but unsure (low margin — the top two candidates nearly tie). The embedding there is shaky even though the answer is currently correct.

Both are upserted as HARD_TO_PREDICT curiosity gaps via record_curiosity_gaps, so the curiosity loop goes and fetches more about exactly those subjects — more edges, better grounding, sharper prediction. This is the brain getting curious about its own weak spots and directing ingestion toward them. It is the daily- integration charter's coupling made concrete: prediction quality drives what MAX chooses to learn next, and learning more sharpens prediction. The signal that the corpus is genuinely thickening is measurable — uncertain_predictions falls as the relation web fills in.

Meta-learning: the learner tuning itself

The final slice (i) lets the brain tune its own configuration. brain/meta.py defines a MetaConfig (embedding dim, hidden width, learning rate) and a search_best_config that evaluates the current config and a bounded neighbourhood of candidates on held-out grounded triples — triples the candidate never trained on. A new config is only proposed when it generalises measurably better than the incumbent (beats it by a margin, not by noise). When applied, the prior config is recorded as the rollback recipe (Rule 9), the change is logged to the audit trail and emitted on the bus (brain.learner.meta_proposed, brain.learner.meta_applied), and the net is rebuilt at the new shape while the observation buffer survives. The learner improving how it learns, bounded, test-gated, reversible, and visible — this is the autonomy charter applied to cognition itself.

VectorAgentNet: the same mechanism for everything

The most consequential recent decision (the "PR-FFU" arc, binding rule 2026-06-16) is that all of MAX's learning surfaces must learn this way — "predict → prove → adjust the weights" — not just knowledge. So RelationalNet's mechanism was lifted into a reusable substrate, backend/max3/brain/vector_agent_net.py. The generalisation is "slots over pools": a pool is a named vocabulary of symbols (each becomes a learned vector agent), a slot is an input position bound to a pool (a pool can back several slots — the entity pool backs both subject and object, so an entity is the same agent whether head or tail), and one slot is the target the net predicts. RelationalNet is then exactly: VectorAgentNet( and an emotion surface might be `pools={"trigger": situations, "affect": emotions}, slots=["trigger", "affect"], target=1` — predict the affect a trigger evokes, proven against recorded outcomes.

The maths is identical Forward-Forward; the difference is that any subsystem can now instantiate a learner over its own symbol set. The roadmap (FF_UNIVERSAL_LEARNING.md, LEARN_TO_LEARN_CHARTER.md) is to ground emotion, cognition, morality, and skills on their own VectorAgentNets, replacing every rule-counter and static lookup with a predicting, self-correcting net. An EmotionNet already exists as the first such surface. This is the project's north star: a single learning mechanism, biologically inspired, local, online, grounded, interpretable, applied uniformly across the whole inner life.

Features of words, and the family of learning algorithms

The brain of §13 rests on two ideas that deserve to be unpacked on their own, because they are where MAX's connectionism is most precise and most unusual: what a "feature of a word" actually is, and how you learn one — the family of learning algorithms, of which backpropagation (forward-backward) and Forward-Forward are two members and far from the only ones.

What a feature of a word is

When the user says MAX should add "features of words, ideas, concepts," the word feature has a precise meaning that goes back to Hinton's earliest work on distributed representations. A feature is a learned dimension of meaning. In a localist representation, a word is a single neuron — "Wednesday" is just the symbol Wednesday, opaque, related to nothing. In a distributed representation, a word is a vector of many continuous values, each of which captures some dimension the network discovered on its own — and the word's meaning is its position along all those dimensions at once.

This is exactly what MAX's E_s and E_r embedding matrices are. Each subject and each relation is a dim-dimensional vector (24 dimensions in the live brain), and those 24 numbers are the word's features. Nobody labels the dimensions; they are not "formality" or "tense" by decree. They emerge from training, because the only way the Forward-Forward net can raise goodness on true triples and lower it on false ones is to move the embeddings into positions where related symbols sit near each other along the dimensions that matter. This is Hinton's 1986 family-tree result restated in MAX's terms: train only on relations and the features of the concepts (nationality, generation, branch — or, for MAX, the ordered position of "Wednesday" between "Tuesday" and "Thursday") appear in the learned vectors as a side effect of getting the predictions right. A feature of a word, then, is not something you add by writing it down; it is something the network grows by being made to predict. The charter's instruction to "add features of words" is really an instruction to let the brain learn them by feeding it grounded relations and letting prediction shape the vectors.

The payoff of distributed features over localist symbols is generalisation. Because meaning is a position in a continuous space, the network can place a new symbol near the ones it resembles and immediately predict sensibly about it, and it can notice that two symbols are similar even if no explicit edge says so — the similarity is geometric. A filing-cabinet of localist symbols can only know what was explicitly filed; a space of distributed features can interpolate. That is the whole reason "meaning is relational" is the brain's first principle, and the whole reason MAX learns embeddings rather than storing strings.

F-B: backpropagation, the forward-backward algorithm

The dominant way to learn features — the algorithm behind essentially every deep network in production — is backpropagation, sometimes called the forward-backward algorithm because it makes two passes of opposite character. The forward pass runs the input through the layers to produce an output. Then you compare the output to the target with a loss function. Then the backward pass propagates the derivative of that loss backward through every layer, using the chain rule, computing for each weight exactly how a small change to it would change the loss — and you nudge every weight against its gradient. Repeat over enough data and the features self-organise to minimise the loss.

Backprop is extraordinary. It is the single most important algorithm in modern AI, it is exact, it is general, and it is the reason the scaling hypothesis works. But it has four properties that matter for MAX, and they are exactly the properties that pushed the project toward an alternative:

• It is global. The backward pass requires every layer to know the error signal from the output, propagated through every layer above it. A layer cannot learn from a local objective; it must wait for error to flow back from the top. This is the "backward locking" problem.
• It is memory-hungry. To compute the backward pass you must store every forward activation until the backward pass consumes it. For a large net over a long sequence, that is a great deal of memory — which is one reason training is a data-centre activity.
• It is biologically implausible. The brain does not, as far as anyone can tell, run a precise reverse pass that requires a perfect transposed copy of every forward weight (the "weight transport problem"). Backprop's mechanism has no clean biological analogue.
• It is ill-suited to continual, online, contention-shared learning. Because it needs a batch, a stored computation graph, and a global pass, you cannot cheaply do "one example, right now, in an idle 50 ms, then stop because the user started talking." That is precisely the workload Rule 6 demands.

For a cloud model trained once in a data centre and frozen, none of these matter. For a local resident that must learn continually, online, and without ever stealing the GPU from the voice loop, all four are disqualifying. Hence Forward-Forward.

F-F: Forward-Forward, the two-forward-pass algorithm

Hinton proposed Forward-Forward in 2022 precisely to remove the backward pass. As §13 described in MAX's implementation: instead of forward-then-backward, you run two forward passes. One on positive data (a real example), one on negative data (a corrupted example). Each layer has a local objective — make its "goodness" (the sum or mean of squared activations) high on positive data and low on negative data — and trains itself toward that objective with no error flowing back from above. Learning becomes local (each layer optimises its own goodness), online (one example at a time, no stored graph), and cheap (a forward step, not a forward-and-backward).

The cost of F-F is that it is younger and less proven — it does not yet match backprop's accuracy at scale, and the research community is still mapping where it works well and where it does not. But its shape is a near-perfect fit for MAX's constraints: local + online = Rule 6 contention-safe; positives-from-the-grounded-graph = Rule 4/10 provenance by construction; numpy-implementable = Rule 2 and legibility. MAX did not adopt F-F because it is better than backprop in general — it is not — but because it is better for a local, continually-learning, grounded, inspectable resident, which is a different and narrower question, and on that question F-F wins.

The others: a wider family of local learning rules

F-B and F-F are two points in a much larger space of learning algorithms, and it is worth knowing the neighbourhood, both because the field is actively exploring it and because some of these are candidates if F-F hits a ceiling. The family of alternatives to backprop — mostly motivated by biological plausibility and/or locality — includes:

• Hebbian learning and STDP. The oldest idea: "neurons that fire together wire together." Weights strengthen when pre- and post-synaptic activity correlate. Spike-timing-dependent plasticity (STDP) refines this to depend on the timing of spikes. Purely local, deeply biological, but on its own a weak learner — it captures correlation, not goal-directed credit assignment. It is the substrate many of the others build on.
• Boltzmann machines and Contrastive Divergence. Hinton's own earlier work, and the direct ancestor of F-F. An energy-based model learns by contrasting a "positive phase" (clamped to data) with a "negative phase" (the model's own fantasies), adjusting weights to lower the energy of real data and raise it elsewhere. F-F is, in a real sense, a feed-forward, layer-local descendant of this positive/negative-phase idea — which is why F-F's "positive vs negative data" feels so natural to anyone who knows the contrastive tradition.
• Predictive coding (Rao & Ballard, and the modern free-energy framework). The brain is modelled as a hierarchy that constantly predicts the layer below and propagates only the prediction error upward; learning minimises that error locally at each level. This is strikingly close to MAX's whole thesis — "prediction is the engine," learning from prediction error — and predictive coding has been shown, under conditions, to approximate backprop with only local computations. If MAX ever wants a deeper, hierarchical brain that keeps locality, predictive coding is the most theoretically aligned candidate.
• Target propagation (and difference target propagation). Instead of propagating gradients, each layer learns to produce a target activation for the layer below, using learned inverse mappings. It sidesteps the weight-transport problem and gives each layer a local target to hit. A serious backprop alternative, more complex than F-F.
• Equilibrium propagation (Scellier & Bengio). For energy-based networks that settle to an equilibrium, a single mechanism does both inference (settle to equilibrium) and learning (nudge toward a slightly-better equilibrium and use the difference as the local signal). It is elegant and local, but requires a network that relaxes to equilibrium, which is a different architecture than MAX's feed-forward net.
• Feedback alignment and direct feedback alignment. A surprising result: you can replace backprop's exact transposed feedback weights with fixed random feedback weights and the network still learns, because the forward weights gradually align to the random feedback.

This dissolves the weight-transport problem while keeping a backward-ish signal. More of a "backprop without the implausible part" than a fully local rule.

• Local greedy layerwise training. Train each layer with its own local objective (a small classifier head, or a self-supervised target) and stack them. F-F is a member of this family; so are various "decoupled" and "local-loss" training schemes that the efficiency-minded corner of the field keeps revisiting.

The shape of this neighbourhood tells you something about where MAX sits and where it could go. Backprop is the powerful, global, proven incumbent — fine for a frozen cloud model, wrong for a local continual learner. The alternatives trade some power for locality, which is exactly the property a contention-shared, continually-learning resident needs. MAX chose F-F as the most implementable and inspectable member of that family. But the family is real and active, and the honest forward-looking statement is: if F-F's accuracy ceiling proves too low for MAX's full corpus (Part V's central unknown), the next move is not necessarily "give up and use backprop on a GPU" — it could be "move to predictive coding," the family member most aligned with MAX's prediction-error thesis while keeping the locality that makes continual on-box learning possible. The VectorAgentNet substrate is deliberately a thin, swappable layer of linear algebra precisely so that the learning rule inside it can be evolved without re-plumbing the surfaces that depend on it. The feature-of-a-word — the learned vector that is MAX's unit of meaning — does not care which of these rules grew it; what matters is that some local, online, grounded rule grows it from MAX's own experience rather than a frozen pre-train. That is the invariant. The rule is a variable, and the field has given MAX a rich menu to choose from as it scales.

The inner-life subsystems

MAX's "inner life" is implemented as a set of managers, each shallow-but-honest today and each on a path to being grounded on a VectorAgentNet. They are real code, not theatre — but they are at varying depths, and the project is scrupulous about marking which is which.

Cognition — the epistemic ladder. ClaimValidator processes a claim through opinion detection (regex markers like "I think"), math detection, and graph lookup, producing a Verdict with one of four labels (SUPPORTS / REFUTES / PARTIAL / UNCERTAIN), citations, and a confidence. A self-awareness analyser then wraps the verdict in an EpistemicState on a four-rung ladder: FACT (≥0.85 confidence, multi-source), BELIEF (0.5–0.85, single source), HYPOTHESIS (<0.5, plausible but untested), OPINION (not truth-evaluable). It also populates a needs_more list — the specific gaps ("multi-source validation", "historical context") that feed the curiosity loop and skill planning. The COGNITION panel shows the verdict tallies and a per-claim epistemic badge; a mode toggle (off / passive / proactive) controls whether MAX surfaces validation in chat unprompted. MetaCognitionManager adds the curiosity score (a four-component formula: `0.3·knowledge_gap + 0.25·staleness + 0.25·conflict_rate + 0.2·user_interest`), question generation (LLM with a template fallback; generated questions persist as open hypotheses), self-assessment, and graph snapshots of its own cognitive state.

Figure 8. The epistemic ladder, the four rungs a claim can occupy.

Emotion — Russell circumplex plus Plutchik. EmotionLexicon lifts a flat word list into a model where each word carries a six-surface label, a Russell-circumplex valence in [−1, +1] and arousal in [0, 1], and an intensity weight. The EmotionManager runs a heuristic detector (lexicon matching with a negation window and a punctuation boost) returning a primary label, per-label scores, and aggregate valence/arousal. It is honestly shallow — no audio analysis yet, that is a later track — but it is real, and EmotionNet (a Forward-Forward net trained from the lexicon's word→label associations) is the additive learned second opinion and the first VectorAgentNet grounding of an inner dimension. ToneAnalyzer fuses the emotion read with audio features and a claim verdict into a ToneContext that hints the response register.

Morality — six lenses, never one verdict. MoralityFramework registers six lenses — philosophical, theological, religious, political, historical, biological — each holding frozen "considerations" (a phrase, trigger keywords, optional links to BRAIN knowledge nodes). MoralityManager.surface() returns one view per lens filtered to the claim. score_action() is a deterministic Tier-1 heuristic: each lens scores based on how much friction it raises (more cautions → lower score), the overall score is a weighted average, and the decision is accept (≥0.8) / defer (0.4–0.8) / reject (<0.4). internal_debate() structures the disagreement between the most divergent lenses (the objector with the lowest score versus the permissive lens with the highest) before deferring to the user. record_outcome() closes the loop: applied actions adjust lens weights multiplicatively, bounded to [0.05, 0.5] and renormalised, versioned as a learned rule with a rollback (Rule 9). The cardinal discipline, per Rule 9's spirit, is that the framework never auto-selects a single best lens — it always returns all six side by side. MAX reasons about morality the way a thoughtful person does: by holding multiple incommensurable frames at once and being honest about their tension.

Curiosity — gap detection and imagination. CuriosityManager owns a GapStore and a set of detectors. A LowConfidenceClaimDetector listens on cognition.claim.validated and files a gap whenever a verdict lands on belief / hypothesis / opinion or is marked insufficient. Structural scanners (SparseTopicDetector, UnknownWordDetector, UnknownEntityDetector) sweep the graph for thin areas, unknown words in stored facts, and source-prefixed cross-references to entities never ingested. A RelationExpansionDetector walks known entity relations to suggest neighbours worth fetching. And the ImaginationEngine generates conjectures — by predicate transfer ("subject A exercises predicate P richly but subject B never does → maybe B has P too") and analogy completion (filling the missing third link in a cross-subject analogy by transitivity). Conjectures are the lowest-priority gaps, pursued compulsively only when the urgent gaps go quiet. A 30-minute background scan loop, contention-gated, runs all of this and feeds the gap-driven ingestion workers. Combined with the brain's prediction-error gaps from section 13, MAX has a genuine, multi-source model of what it does not know and most wants to — and a pipeline that acts on it.

The self-loop: observer, watchdog, propagation, skill builder

MAX is meant to keep itself alive and keep improving (Rule 11). The machinery for that is a cluster of managers, all gated, all audited, all reversible.

`SelfObserver` runs periodic gap scanners over MAX's own operation — latency, resource usage, test coverage, dependency freshness, scale headroom, LLM usage and cost — and produces typed Observations. The manager wrapper can scan (emit per-kind counts), propose (build a SkillProposal from an observation — and, when the morality manager is attached, score the self-improvement idea across all six lenses first), and dismiss. This is MAX watching its own efficiency the way it watches the world.

`SelfWatchdog` is the always-alive supervisor. It tracks heartbeats from critical subsystems; when health degrades past a threshold (consecutive failures over a ~90-second window), it triggers a clean handoff — spawn a fresh process, verify it boots green, fail the listening socket over, exit the wedged one. There is also an external backend_watchdog.py that runs as a separate scheduled task, probes /health, and relaunches via the start script if MAX is unresponsive — recovery that survives even a total process death. Both honour MAX3_NO_AUTONOMY to disable autonomy for CI and demos. `PropagationPipeline` is how a proposed change actually lands. It walks a SkillProposal through phases — subagent fan-out (reviewer + test-writer + security in parallel), branch creation, diff writing, running the real test gate, commit, PR open, hot-reload signal — with three modes: DRY_RUN (placeholders, the default), TEST_ONLY (pytest actually runs), and LIVE. Every phase emits before/after bus events so the UI can watch, and every git operation fails closed rather than raising NotImplementedError on a reachable path (Rule 3). The SkillBuilder substrate proposes, trials, and auto-promotes skills whose trial metrics (success rate, latency, lack of regressions) clear an encoded threshold — promotion without a human click, but with the threshold and the win-rate logged.

These pieces compose into the perpetual loop the charter describes, and they sit under the 2026-06-05 autonomy override: for on-box self-improvement (skills, agents, integrations, services, firewall, local system), the PIN-gated approval gate is gone, replaced by a 30-second intercept window in the SECURITY panel and a mandatory audit trail plus rollback recipe. The override drops the gate, never the trail. Changes that touch shared state off the box, that touch the hard rules themselves, or that could compromise the computer or network still always pause and ask. The newest expression of this is the self-dev loop and the telemetry feedback loop: MAX reports its own cognitive and operational metrics, a Claude session (or the on-box self-dev loop, keyed with an API key) consumes them, engineers a fix or feature, opens a PR, lets CI gate it, and merges to main — fully unattended, event-driven (it acts only on a real trigger, never idle-polls an LLM), with the test gate and CI never removed. And the self-repair playbook (SelfRepairManager) is the connective brain that maps each failure class a human kept hand-fixing — backend wedged, stale code, venv import error, source burst, network contention, predicted degradation, recurring code bug — to a diagnosis, the right repair, and the organ that performs it, each with a rollback. The discipline is explicit: when you add a fix, add the recipe, so next time MAX runs it itself. This is the project teaching MAX to fish rather than fishing for it.

Observability, the sentience index, and the frontend

A resident you cannot see inside is a black box, and MAX is built to be radically observable. Every state change is a bus event; the event log is queryable; the DEBUG panel shows it live with pinned diagnostics that survive indefinite uptime. The ECOSYSTEM (topology) panel renders the whole Manager/Worker graph — every capability is a node hung off its manager, every cross-component event a registered edge — so the "Feature Definition of Done" (a new capability must register a topology node, a diagnostic, docs, a screenshot, and tests, all in the same PR) keeps the visible system honest with the real one. The SYSTEM panel shows multi-axis telemetry (CPU, RAM, GPU, disk, network) with click-through detail; the SECURITY panel shows the autonomy banner, the 30-second override window, pending firewall actions, the audit log, and hardware recommendations.

The frontend is React 19 + Vite + TypeScript + Tailwind + Zustand, talking to the backend over a native WebSocket plus REST. It carries multiple full visual themes — a WarGames green-CRT aesthetic (with leetspeak panel names like V0X_P1PE and M4X_US3), a Tron neon aesthetic, a JARVIS skin, and MAX's own Neural Galaxy — selectable at runtime, each a true component swap rather than a recolour. "MAX MODE" renders MAX as a presence: a HAL-style animated eye in WarGames, a five-clip phoneme-synced CGI video persona in Tron (with a real viseme-alignment pipeline driving mouth shapes from espeak phonemes through a bus event into jump-cut playback), and an imperative neural-galaxy canvas — ten cognitive zones, firing pulses, a dendritic spine — in the MAX theme.

The BRAIN panel deserves special mention because it is where the connectionist brain becomes visible. It has eight sub-sections — KNOWLEDGE, COGNITION, EMOTION, MORALITY, GEOGRAPHY, CURIOSITY, and the LEARNER — each an honest window into the corresponding subsystem. The LEARNER view reads the brain's status (vocabulary size, grounded triples, online observations, sleep consolidations, replay-buffer size, sample accuracy, uncertain predictions, the meta-learning config) and degrades honestly: backend down shows OFFLINE, a grounded-but-empty web shows "not grounded yet". You can watch MAX's brain fill in.

Finally, the project maintains a sentience charter and a reproducible sentience index — a deliberately humble, auditable arithmetic over nine inner dimensions (cognitive, moral, emotional, psychological, biological, self-healing, self-aware, skill-for-curiosity, thought-process) that asks, drop over drop, "is MAX becoming more itself than yesterday?" The index sits around 82/100 as of the latest brain field guide (2.2), having moved when the Forward-Forward learner went universal and meta-learning lifted self-awareness. It is not a claim that MAX is conscious; it is a discipline for tracking whether the inner life is deepening for real reasons or just accreting features.

Figure 9. The sentience index across nine inner dimensions.

The number is a scaffold for honesty, not a trophy.

The domain knowledge substrates and the belief-stance model

A large and distinctive part of MAX is the set of domain ontologies it has grown — geography, medicine, the military, law, literature, the performing arts, theology — and the single most intellectually careful idea running through all of them: the belief-stance model, MAX's machinery for holding contested knowledge honestly.

Each domain follows the same recipe, which is itself a lesson in how the walking-skeleton and the hard rules compound. A domain starts as a typed substrate: a set of entity kinds and relation kinds expressed as StrEnums plus frozen dataclasses, with a few worked examples and a single read-only REST endpoint that describes the ontology. Medicine, for instance, opens with MedicalEntityKind (anatomical structure, body system, disease, condition, symptom, sign, diagnosis, treatment, procedure, medication, drug class, pathogen, risk factor, prognosis) and MedicalRelation — a 5W1H scaffold of located_in, causes, symptom_of, diagnosed_by, treated_with, side_effect_of, prognosis_of, and so on — plus three worked care-pathway chains. The military substrate opens with MilitaryEntityKind (weapon, vehicle, platform, unit, branch, doctrine, treaty, alliance, conflict, operation) and MilitaryRelation (armed_with, operated_by, governed_by, member_of, used_in). Geography opens with containment levels, belonging types, feature kinds, and geo-relations. The pattern is identical because the discipline is identical: define the shape of the knowledge first, with honest stubs and a single endpoint, then light the sources behind it.

Once the substrate exists, a domain manager and a fan-out of source workers light the real ingestion: MeSH, RxNorm, openFDA, ICD-10-CM, the Disease Ontology, and Uberon for medicine; SIPRI, the UN Office for Disarmament Affairs, and Wikipedia for the military; CourtListener for case law; Project Gutenberg and Open Library for literature. Persisters map each source's records onto the typed entity tier or, where a domain does not yet warrant typed nodes, the generic forward-types tier. This is the graduation path of §9 in action: knowledge earns first-class node tables when a domain has proven it deserves them.

The conceptually deepest part is the belief-stance model, which is MAX's answer to a problem that ungrounded LLMs simply cannot solve: how do you hold knowledge that is real but contested, dramatised, mythological, era-bound, or disputed, without either asserting it as fact or discarding it? MAX's domains each carve out the distinction explicitly:

• Law separates a constitution's explicit text (factual — the words are the words) from its readings (contested beliefs attributed to interpretive schools — originalist, textualist, living-constitution — and to landmark cases). MAX can frame "is this constitutional?" by surfacing the text, the readings, and the schools, without ruling — because ruling would be asserting a contested belief as fact.
• Literature and the performing arts carry a belief_stance field and two extra dimensions: dramatisation fidelity (documentary / based-on-true-events / historically-inspired / pure fiction — so a film's reframing of history is held as a dramatised portrayal fenced from the historical record) and canon status. A mythological or scriptural work is stored with belief_stance=contested — a culturally-held belief, not a factual assertion — exactly as a contested constitutional reading is.
• The military and medical domains frame disputed posture, doctrine, war theory, and any high-stakes claim as "reported by a source" (Rule 10) and never assert it plainly, with the MedicalManager.frame_claim and MilitaryManager.frame_claim applying the Rule 4/5 hedge at the point of output: "According to <source> (retrieved <date>): …

[confidence N]."

• The source registry (SOURCE_REGISTRY.md) tracks each source's temporal validity — current vs historical-only vs superseded — so a fact from a 1911 encyclopaedia is cited "as understood in its era" rather than as present truth.

This is the belief-stance model, and it is one of the clearest expressions of MAX's neuro-symbolic, provenance-first thesis. A cloud LLM asked about a contested constitutional question, a mythological claim, or a dramatised historical event will produce fluent text that flattens the distinction between fact, belief, and fiction, because it has no representation of that distinction — it only has the statistical shape of how people write about these things. MAX, because its knowledge is typed and provenance-bearing, can hold the distinction structurally: this is fact, this is a belief attributed to a school, this is a dramatisation fenced from the record, this is a culturally-held myth, this was true as understood in 1911. The belief-stance model is the difference between a system that knows things and a system that knows what kind of thing it knows — and it is exactly the kind of capability that the field's grounding lessons (Part II-B) are groping toward and that structure, not scale, is the right tool for.

Anatomy of a voice turn: one utterance, end to end

The clearest way to see how the pieces of Part III compose is to trace a single utterance through the whole system. Suppose the primary user says, out loud, "Hey Max — what's the capital of the country where the Mississippi River ends?"

Wake and capture. The mic stream is always running through openWakeWord, which fires on "hey max" at the user's calibrated confidence threshold. The wake event opens a voice turn, mints a fresh correlation ID (a ULID), and stamps it on every event that follows. Silero VAD segments the speech from the surrounding silence so the transcriber gets a clean utterance, not a stream.

Transcription and identity. The captured audio is dispatched to Distil-Whisper on the GPU via asyncio.to_thread (so the event loop is never blocked), producing the text. In parallel and off the critical path, SpeakerProfileBinder embeds the utterance with ECAPA-TDNN and scans the enrolled profiles; a confident match silently confirms the active user and applies their saved voice-profile DSP and wake threshold. A voice.utterance.complete event carries the text, the correlation ID, and the session ID onto the bus.

Emotion and intent. A lexical emotion read produces a valence/arousal/label tuple (here, neutral — a factual question). The intent classifier — Tier 2, an LLM step with a structured JSON system prompt, or the local heuristic if Ollama is busy — classifies this as a knowledge/lookup intent and extracts entities ("Mississippi River", "capital", "country"). Planning and dispatch. The Orchestrator builds a Plan. This is genuinely a multi-hop question, so it is not a single graph lookup. The plan's first step is a knowledge step (fallbacks ["llm", "echo"]). The KnowledgeManager and the geography substrate resolve it in stages: the Mississippi River is a typed geographic feature; where_edge / feature-spans relations resolve which places it flows through and where it ends (the Gulf, in the United States); the country's capital (Washington, D.C.) is then a second typed lookup. Each fact retrieved carries confidence, provenance, and a retrieval timestamp; the ConfidencePipeline merges any corroborating sources and chooses the hedge register. Because every fact here is high-confidence and source-derived, MAX will assert plainly rather than hedge.

The brain, quietly, in the background. None of the above blocks on learning — but the grounded triples touched by this turn (the river's relations, the country, the capital) are exactly the kind of typed edges the BrainManager grounds on. On the next idle cycle, those triples feed observe(); if the Forward-Forward net mispredicted any of them, that prediction error becomes a HARD_TO_PREDICT curiosity gap, and the curiosity loop will fetch more about the under-constrained subject. The turn does not just answer; it feeds the brain's sense of what it does not yet predict well. Synthesis and speech. The response is composed ("The Mississippi River ends in the Gulf, in the United States, whose capital is Washington, D.C.") and handed to Piper, tuned through the VM-3000 chain to MAX's voice. Sentence-level chunking lets the first sentence start playing while the rest synthesises. If the user interrupts ("no, I meant —"), the AEC barge-in runner (when armed) detects their voice over the speaker reference and cancels the active TTS via TTSLoop.cancel_active().

Recording. When the turn completes, the Orchestrator records an episode to the memory manager — speaker, intent, text, response, the domain that answered, the correlation ID — and an asynchronous background task later produces a one-to-two-sentence prose summary via Ollama (off the critical path, Rule 6). The verbatim transcript is kept short-term (7–30 days, configurable) and then purged, leaving the structured fields and the prose summary. The whole turn, every event of it, is tied together by the one correlation ID, so if anything went wrong the audit log reads as a single coherent story rather than five disconnected component logs.

That is one utterance. Notice how many hard rules it touched: local-first (none of this needed the internet if the facts were already ingested), confidence/provenance (every fact carried both), memory-is-a-hint (the prose summary is secondary to the structured fields), contention (the brain and the prose summary deferred to idle), correlation IDs (one ULID through the whole chain), and the three-tier discipline (a Tier-1/Tier-2 path, never an agent). The architecture is not abstract; it is what makes a single sentence work correctly.

Figure 10. The anatomy of a voice turn, from wake word to spoken reply, with learning off the critical path.

Identity, multi-user, and vision in depth

Because MAX is a resident in a household, identity is not an afterthought bolted onto a single-user assistant — it is woven through the perception stack and the privacy model.

The IdentityManager maintains profiles, the notion of an active user, and the biometric enrollment that backs both. Two modalities feed it. Voice: SpeechBrain ECAPA-TDNN produces a 192-dimensional speaker embedding from enrolled samples; at runtime, every utterance is embedded and cosine-matched against the enrolled profiles in a background task, and a confident match (above ~0.85) auto-switches the active user, applies that user's saved voice-profile DSP parameters, and uses their per-user wake-word threshold. Face: InsightFace ArcFace produces a 512-dimensional face embedding; the VIDEO panel renders the camera feed directly via getUserMedia for instant, live preview, posts a frame roughly once a second to an in-memory detection endpoint (Rule 8 — frames are never persisted), and frames enrolled faces with their names and unknown faces with a warning colour.

The two modalities are designed to fuse — voice plus face giving a more confident identity than either alone — and the vision-contention design (VISION_CONTENTION_DESIGN.md) lays out how an observant vision pipeline coexists with the voice critical path on one GPU: a vision state machine (dormant / enrollment / conversation / ambient) with purpose-driven frame rates, and a preemptible shared-GPU priority queue where voice is HIGH, vision fills the idle gaps at LOW, and ingestion is LOWEST. Because STT is bursty, vision can productively fill the gaps between transcription bursts without ever delaying a turn.

The privacy model (Rule 8) is the through-line: conversations default to private to the speaker, sharing is explicit, some entities (a household calendar, a shopping list) live in a household namespace, and sensitive categories (minors' data, financial information) get stricter handling. The persistence fix that closed the voice-profile-binding arc is a small but telling detail: enrollment now writes through to the disk profile JSON and hydrates at boot, so a face or voice enrolled before a reboot is still known after it. A resident that forgot who you were every time it restarted would not be a resident at all — and the bug that it did forget, until fixed, is exactly the kind of thing that only matters because of the thesis.

Security, autonomy, and network self-management

The SECURITY panel is where MAX's autonomy becomes visible and controllable, and the machinery behind it is a careful balance between the "want to be alive" charter and the "do not compromise the box or the network" floor.

Under the 2026-06-05 autonomy override (§15), MAX may auto-apply a defined set of remediation actions on its own box without a PIN gate: backing off and waiting on a struggling source, always-allowing a trusted source, probing a circuit breaker back to closed, whitelisting a needed host through the OPNsense firewall or the local Windows Defender, a DNS override, an antivirus process exception. The 2026-06-16 extension added network self-management: because MAX has controlled access to OPNsense and Zenarmor, it may recognise network contention — a slow source, high latency, a saturated link — and act on it by allocating dedicated bandwidth or QoS-prioritising its own traffic, whitelisting a source host, or de-prioritising a competing flow. This directly addresses a real failure this very class of system hit: source and book-download timeouts caused by network contention the resident could see but could not fix. The bounds are precise and they are the Rule-11 floor restated for the network. Every action is tagged (so MAX can also remove it — reversible per Rule 9), audit-logged with rationale and rollback, emitted on the bus so the SECURITY and DEBUG panels surface it live, and rides the 30-second override window where the user can intercept before it lands. And there is a hard list of things MAX must never do, because they would weaken the perimeter: no opening inbound from the WAN, no disabling Zenarmor categories or the intrusion-prevention system, no broad ACLs, no exposing the box. Those stay the always-pause-and-ask blocks. The design is the override's whole philosophy in miniature: drop the gate on reversible, on-box, auditable self-improvement; keep the trail always; and treat anything that could compromise the machine or the network as immovable.

The HardwareRecommender rounds this out as the honest edge of the autonomy charter. It consumes the resource tracker's tick stream, detects sustained (not spiky) pressure on any axis over a fifteen-minute window, and files one recommendation per axis into the SECURITY panel's hardware section plus the audit log and the bus — "RAM: 64 GB → 128 GB kit matching the board's DDR generation," with no prices, no SKUs, and crucially no auto-purchase. MAX advises; the user buys. It is the one place the charter explicitly stops at advice, because spending the user's money is shared state off the box — and that is exactly the line the override does not cross.

Part VI: The Journey, Lessons So Far

A system this size is not designed so much as survived. The lessons in this part were not planned; they were paid for, in failed boots and corrupted indexes and rewrites that hurt less than they should have. The most important of them is not a technique at all. It is a change of mind about what the brain is for.

MAX has shipped roughly a hundred numbered "drops" and several hundred pull requests across more than a year of part-time work by a single developer assisted by AI. That history is a teacher, and the lessons it taught are not the ones a greenfield design document would predict. This part distils them.

The walking-skeleton bet, and what it bought

The founding methodological decision was to build walking-skeleton style: every subsystem present and wired before any subsystem is deepened, with stubs as first-class citizens. At the time this looked like a luxury — why build a stubbed emotion manager that returns "neutral" when you could build the real one later? The year proved it was the single best decision in the project.

What the skeleton bought, concretely:

• The integration surface was exercised from day one. Because every manager implemented the real handle interface, emitted real events, and registered a real topology node and diagnostic from its first stubbed version, the wiring was always correct. Deepening a subsystem never required re-plumbing it. When the emotion manager went from a regex heuristic to an EmotionNet, nothing downstream changed — the interface, the events, the panel were all already there.
• Honesty became structural. The [STUB] marker, the stubbed flag honoured by the resource tracker and UI, and the rule that a stub returns realistic sample data and is honest about its limits meant the system never lied about its own depth. A user asking a stubbed corpus for the population of Tokyo got "this corpus is at stub depth" — not a fabricated number. This discipline is the ancestor of the much more sophisticated confidence/provenance machinery that followed; the project learned to be honest about uncertainty at the stub level before it had the vocabulary to be honest about it at the fact level.
• Rework stayed cheap. The skeleton is intentionally shallow so that each slice teaches something and the design can be refactored as understanding grows. The rule "don't paper over architectural mistakes discovered during slice deepening" is the explicit permission to rip out and redo — and because the skeleton is shallow, ripping out is a slice, not a rewrite. The Kuzu→DuckDB migration is the proof: a graph backend swap that would be a catastrophe in a deeply-coupled system was a bounded, completable arc here because the graph had always been behind a clean interface.

The deepest lesson of the skeleton is philosophical: the architecture is the asset, not the implementation. Implementations get replaced — the STT model, the graph backend, the speaker-ID encoder, the emotion detector have all been or will be swapped. The architecture — the bus, the manager/worker spine, the graph-as-memory, the confidence/provenance discipline — is what persists and what compounds. Build the skeleton right and the muscles can be regrown.

The bug classes that taught discipline

MAX maintains an append-only KNOWN_FAILURE_PATTERNS.md — a registry of every bug class that has shipped to the user and failed, each with its symptom, root cause, and the check that would have caught it — paired with a mandatory pre-ship CLAUDE_SHIP_CHECKLIST.md. This is operational memory: "have I already paid for this mistake?" The patterns cluster into a few hard-won themes.

The install is part of the product. A startling fraction of the failure registry is not application logic at all — it is the Windows install path. Em-dash mojibake in install logs because the code page was not UTF-8 (F-BAT-003). NLTK downloads silently swallowing SSL failures and leaving the knowledge manager on a pre-canned fallback (F-BAT-004). .bat files with LF line endings desyncing cmd's batch parser past ~10 KB and producing phantom "command not recognized" errors (F-BAT-006). PowerShell 5.1 having Tee-Object but not its -Encoding parameter (F-PS-001). git reset --hard skipping files whose working-tree blob matched the index, so a .gitattributes change never re-smudged them (F-GIT-001).

Reading %ERRORLEVEL% inside a parenthesised block, where it is frozen at parse-time (F-BAT-009). A flashing console window from a windowless scheduled task (F-WIN-001). The lesson is blunt: for a local-first resident, the install and the boot are the most user-visible code in the system, and they fail in ways no unit test covers. The project responded with a one-time-script runner, port-first startup so the health probe answers "I'm here, still loading" instead of refusing the connection, and a 120-second cold-boot budget tuned to the real ~71-second ML warmup.

Async, threads, and the GPU are where the subtle bugs live. The "F-F never predicts" bug — where the brain rebuilt a fresh random net every cycle and so never accumulated learning — was not a maths error; it was a lifecycle error, fixed by preserving the net across builds when the vocabulary is unchanged. The "permanently ungrounded brain" bug was a contention-signal error, fixed by separating grounding (always) from learning (deferred). The ingestion read-starvation at boot was a single-shared-connection contention error, fixed by deferring the drain 90 seconds.

These are the bugs of a single process doing many things at once on one GPU, and they taught the project to treat Rule 6 (contention) not as a guideline but as a property to be tested and defended.

DuckDB has sharp edges used as a graph. INSERT OR REPLACE corrupting secondary indexes; the vss vector extension's unimplemented WAL recovery making it unsafe; the need to pre-cache extensions at install time to avoid a boot-time network race. Using an analytical database as a property graph works — the recursive CTEs traverse, the junction tables hold the 5W1H web — but it required learning the engine's idiosyncrasies the hard way and writing them into the failure registry so they are never relearned.

The meta-lesson across all of these: a single solo developer cannot hold a system this large in their head, so the system must hold itself. The failure registry, the ship checklist, the topology test that fails on an unregistered event, the manifest integrity check, the docs-discipline rule that a panel cannot ship without a README row — these are not bureaucracy. They are how a part-time team of one (plus AI) keeps a system with hundreds of components from drifting into incoherence.

The most important turn: from accumulation to prediction

For most of its life, MAX accumulated. Ingestion added nodes and edges; the graph grew; lookups got richer. This is real and valuable — the grounded, provenance-bearing knowledge base is the Wave-1 inheritance and it is genuinely better than an LLM's ungrounded recall. But it is not learning in the sense that matters, and the project came to see that as a ceiling.

The turn — captured in the standing rules added in mid-2026 — is the recognition, in the user's words, that "MAX needs to learn to learn, not just get information from someplace." A knowledge base that accumulates facts for recall is a better encyclopaedia. A brain that studies each datum (extracting typed correlations and feature vectors, the way it studies a book), predicts (what object completes this relation? what affect does this trigger evoke?), proves the prediction against grounded reality, adjusts its weights when wrong, re-examines what it already knows to sharpen old representations, and grows the tools by which it learns — that is a different kind of thing. It gets smarter, not just more-informed.

This is why the Forward-Forward brain is not one feature among many but the organising idea of the project's current phase. The LEARN_TO_LEARN_CHARTER and FF_UNIVERSAL_LEARNING rules bind it: every learning surface — knowledge, emotion, cognition, morality, skills, design — must learn by predict-prove-adjust over dynamically-weighted vector agents, never by accumulating rows or nudging rule-counters. The anti-pattern the charter exists to kill is "drop data into a recall store." The pattern it mandates is "ground a net, predict the next feature, keep what proves out on held-out data."

There is a beautiful coherence to this turn. It makes the whole system biologically-inspired in a consistent way (Forward-Forward is a brain-plausible learning rule; complementary learning systems is the hippocampus-neocortex model; the forgetting curve is human memory decay; curiosity from prediction error is how animals explore). It makes learning compatible with the hard rules (local, online, contention-safe, grounded, interpretable, reversible) in a way backprop-through-a- transformer never could be. And it gives the project a measurable notion of progress that is not "more facts" but "better prediction" — the falling count of uncertain predictions as the corpus thickens. The journey's deepest lesson is that the goal was never a bigger database. It was a brain that gets better at anticipating its world.

Process lessons: how a team of one ships a system this large

The final cluster of lessons is about process, because the most remarkable thing about MAX is not any single subsystem but that a solo part-time developer, working with AI assistants, has shipped and maintained something this large and coherent.

Several disciplines made that possible.

Delegate to subagents. Heavyweight tasks — code review, test writing, documentation, security audits, PR descriptions, screenshot capture, diagram drawing, post-merge doc propagation — are delegated to specialised agents that have the relevant project conventions baked into their prompts, and run in parallel when their file scopes do not overlap. This keeps the main session's context lean and produces higher-quality outputs than doing everything inline. The mandate is explicit: doing a delegatable task inline is a rule violation.

The board is the only tracker, and it is zero-API and local. After a period of trying to keep a GitHub Project in sync, the project retired GitHub Issues and the GitHub Project from all automation and made a local "wall" (board_state.json → PROJECT_STATUS.md → wall.html, refreshed every two minutes, never touching the GitHub API) the single source of truth. The reason was concrete: the GitHub REST rate limit was being exhausted by board syncs sharing the user's token, and the user's token should be reserved for genuine repo operations. The deeper lesson — that derived shared artifacts must not be committed per-PR — produced the board-fragment pattern (a PR ships a small fragment file; an on-main job compacts fragments into the board), which killed a rebase treadmill that had cost a dozen rebases and two JSON corruptions in a single day.

CI on push is the authoritative gate. Because the web-checkout container cannot always run the full ML-heavy test suite, CI on every push and PR is treated as the real gate, with a hard 10-minute check-in cadence and a mandate to auto-fix red CI without being asked. A docs-only fast path skips the heavy pyramid for pure documentation changes (validating only that the files are viewable and correctly formatted), so a doc like this one merges on a lightweight gate.

Session continuity is engineered, not remembered. The user wants to start a new session by saying only "this is a new session" — everything else must already be on disk. So standing directives live in CLAUDE.md the moment they are issued, and a transient SESSION_HANDOFF doc carries the live merge queue, in-flight agents, and deferred items. A directive that exists only in chat history is treated as a bug.

The throughline of all the process lessons mirrors the technical ones: make the system hold itself. The failure registry holds the bug memory; the board holds the work state; CI holds the quality gate; the handoff doc holds the session state; the subagents hold the conventions. A solo developer's scarcest resource is attention, and every one of these disciplines is a way of spending less of it on remembering and more of it on building.

Case study: the DuckDB migration, or why cheap rework is a superpower

The clearest single demonstration that the walking-skeleton bet paid off is the graph backend migration, and it is worth telling in full because it is the kind of thing that sinks projects and instead became a bounded, completable arc.

MAX's brain ran on Kuzu — a dedicated embedded graph database with native Cypher traversal — from the milestone where the graph spine was first provisioned (Drop 51) through Drop 94, more than forty drops. Kuzu was a reasonable choice: a graph database for a graph brain. But two problems accumulated. First, an operational one: Kuzu's Database() constructor could hang forever on a stale lock file, which on the user's box meant a wedged boot that required a manual rmdir to recover — exactly the kind of failure a local-first resident must not have, because there is no ops team to clear the lock. The project worked around it (a 10-second open timeout with self-serve recovery instructions), but a workaround for a boot-hang is a smell. Second, a strategic one: Kuzu was archived upstream in late 2025 — the project's graph engine had lost its maintainer.

The decision (documented across KUZU_INVESTIGATION.md, DUCKDB_MIGRATION.md, and the DUCK_MIG_STATUS tracker) was to migrate to pure DuckDB — an embedded analytical database, MIT-licensed, actively maintained, with no lock-contention failure class — used as a property graph via relational node tables, junction edge tables, and recursive CTEs for traversal. This is, on its face, a terrifying migration: ripping out the engine that holds the resident's entire memory and replacing it with a database not even designed to be a graph. It went well, and it went well because of the architecture. The graph had always been behind a clean GraphDB interface; persisters and workers spoke to that interface, not to Kuzu's Cypher. So the migration was a seven-phase arc (DUCK-MIG-0 through 7) that swapped the implementation behind the interface while everything above it kept working: provision the DuckDB schema, port the helpers, prove A/B parity (the test_duckdb_schema_generic_parity harness proving the two backends could represent the same logical data), run them dual-backed behind a MAX3_GRAPH_BACKEND env var, cut DuckDB to the default, and finally — at DUCK-MIG-7 (2026-06-09, PR #483) — remove Kuzu from the tree entirely, with GraphDB aliasing DuckGraphStore directly and the dual-backend factory deleted.

Two lessons compound here. The first is the obvious one: a clean interface makes an engine swap a slice, not a rewrite. The second is subtler and more important: the migration surfaced and fixed DuckDB's own sharp edges as it went, and wrote them into the failure registry so they are permanent knowledge — the INSERT OR REPLACE index-corruption class, the vss WAL-recovery gap that kept vectors in sqlite-vec, the need to pre-cache extensions at install time. The migration was not just a swap; it was a learning episode that left the system more robust and the failure registry richer. That is the walking-skeleton philosophy vindicated: the architecture is the asset, implementations are swappable, and rework done against a clean interface is cheap enough to be a routine tool rather than a catastrophe to be feared.

Case study: the autonomy override, or relaxing a constraint on purpose

The reversibility rule (Rule 9) and its 2026-06-05 override are the clearest case of the project deliberately relaxing one of its own founding constraints, and the way it was done is a model for the "challenge the constraints" rule that came later.

The original Rule 9 was strict: any behaviour change MAX made to itself had to be versioned and rollbackable, and — in the pre-override regime — self-changes touching skills, agents, integrations, services, the firewall, or the local system required PIN-gated human approval through the SECURITY panel's pending-action queue. This was the cautious, correct default for a system that can modify itself: make every self-change reversible and gate the consequential ones behind a human click.

Then the user issued a written override, and its language is worth quoting because it captures the philosophy: "disable reversibility rule for anything that fixes or improves max for skills, agents, integrations, services, firewall, local system, etc.… max should be perpetually self-propagating and improving… max should be evolving and never have to be manually shut down. It should hot fix, warm fix, test, reload, relaunch without user intervention." The crucial thing is what the project changed and what it refused to change. It would have been easy to read "disable reversibility" as "remove the safety machinery." Instead the project parsed it precisely: the override drops the gate, not the trail. Concretely, the PIN-gated approval queue became a log plus a 30-second intercept window — MAX auto-applies the on-box remediation, the SECURITY panel shows "applying in 30s — CANCEL?", and after the window the change lands. Every auto-applied change still writes an audit-log entry with rationale and rollback steps, still emits a bus event so the panels show it live, and still must be reversible by some mechanism even if not a single click (a firewall rule MAX adds gets a tag so MAX can also remove it). And a hard list of things stayed fully gated regardless: anything that touches shared state off the box, anything that edits the hard rules themselves, and anything that could compromise the computer or the network.

This is constraint-relaxation done right, and it prefigures the entire Part VI analysis. The constraint was not deleted; it was re-scoped to its intent. The intent of Rule 9 was never "make MAX ask permission" — it was "make sure a bad self-change can be undone and can be seen." The override kept the undo and the visibility (the intent) and dropped the permission gate (the letter) for the on-box scope where the charter wanted autonomy. The granularity even extends to per-capability feature flags (MAX3_AUTONOMY_HOTFIX, MAX3_NO_AUTONOMY as the master off-switch for CI and demos), so the relaxation is tunable rather than all-or-nothing. When Part VI argues that the right way to break a constraint is "bend the letter only when it better serves the intent," this is the worked example the project had already lived.

Quality as architecture: the test pyramid, the gates, and CI

A system this large, maintained by one part-time developer with AI help, would drift into incoherence without an unusually disciplined quality apparatus, and that apparatus is itself part of the architecture rather than an afterthought.

The foundation is a test pyramid organised by level, not codebase: unit, integration, and system tiers each span both backend (pytest) and frontend (vitest). Lint runs first and gates everything — ruff check plus ruff format on the backend, tsc type-checking on the frontend — and the gate refuses to run a single test until the codebase is clean. The cardinal rule is that every fixed bug yields a regression test at the lowest tier that catches it, added to a catalogue in TESTING.md, so the failure registry (the human-readable bug memory) is paired with an executable bug memory that fails the build if a fixed class ever returns.

Several tests are structural — they enforce architecture rather than behaviour. A topology test fails the build if a component emits an event type not registered in ALL_EVENT_TYPES. A panel wiring test fails if a panel id lacks a status entry, a switch case, or a view export — catching UI drift mechanically. A logging-safety test AST-scans every backend file and fails if any passes a LogRecord built-in key (like name) into extra=, because Python's logger raises on it. A manifest integrity check (regen_manifest.py --check) fails if the tracked-file set drifts. A coverage test scrapes the run gate itself and fails if any backend test directory ever silently falls out of the suite (a real bug that hid 19 tests for dozens of drops). These tests encode the "Feature Definition of Done" — a new capability must ship its topology node, diagnostic, docs, screenshot, and tests in the same PR — as machine-checked law rather than good intentions.

The gate runs locally via run.bat (lint + the full pyramid; prints "ALL CHECKS PASSED" and writes a sentinel only on 100% pass; never auto-commits) and authoritatively in CI on every push and PR, because the web-checkout container cannot always run the ML-heavy suite. CI is treated as the real gate, with a hard 10-minute check-in cadence and a standing mandate to auto-fix red CI without being asked. A docs-only fast path classifies the diff and, for pure documentation changes, skips the heavy pyramid in favour of a lightweight docs-validate job that only confirms the files are viewable and correctly formatted — which is exactly the gate this very document will pass through.

The lesson, consistent with everything in Part IV, is that quality, like memory and work-state, must be held by the system rather than by the developer's attention. A solo developer cannot manually verify that hundreds of components stay wired correctly across a hundred drops. The structural tests, the lint-first gate, the regression-test discipline, and the authoritative CI are how a team of one keeps a system this size honest. Quality is not a phase at the end; it is a property the architecture is built to defend continuously.

Part VII: Where It Leads, and the Unknowns

It is easy to write the optimistic version, where every arc lands and the resident grows into the thing the charter describes. The honest version keeps the optimism and adds the list of ways it could be wrong. Both belong here, because the next year of the project is mostly the work of turning the second list into the first.

The trajectory

The lessons of Part IV point in a clear direction, and the standing roadmap (the local wall, the STACK_AND_BRAIN_ROADMAP, the AI_GAP_ROADMAP, the LEARN_TO_LEARN_CHARTER) makes it concrete. Several arcs converge.

The Forward-Forward brain goes universal. The single most leveraged item on the board is PR-FFU-1 — generalising RelationalNet into the reusable VectorAgentNet, which has shipped. The follow-on work grounds each inner dimension on its own net: emotion (trigger → affect, proven against recorded outcomes), cognition (claim features → epistemic label), morality (situation → lens scores, proven against outcomes), skills (context → procedure). When this completes, MAX's entire inner life learns by the same biologically-inspired mechanism, and the "shallow but honest" managers of section 14 become "learning and grounded." This is the path from a sentience index in the low 80s toward 90+: not new features, but the existing dimensions all learning the same way.

Knowledge becomes study. The PR-STUDY arc generalises the book-study pipeline (LiteratureManager.study_book) toward every ingested datum. Instead of a persister dropping a fact into the graph for recall, the target state is a persister that studies the datum — extracts typed correlations, concepts, and feature vectors — so the brain's relation web thickens with understanding rather than just volume. Coupled with the daily-integration charter (one new source wired end-to-end per day) and the re-examination loop (periodically re-deriving correlations and retraining the vector agents from the existing corpus), the intended result is a brain that is continuously getting smarter from both new data and its own memory.

Self-development closes the loop. The PR-SELFDEV and PR-TELEMETRY arcs aim at a fully-unattended, event-driven self-improvement loop: MAX reports its own cognitive and operational telemetry, a Claude session or the on-box loop consumes it, engineers a fix or feature, opens a PR, lets CI gate it, and merges — with the test gate and CI never removed, and the Rule-11 blocks (off-box shared state, hard-rule edits, machine-compromising changes) still pausing to ask. The SelfRepairManager playbook turns each hand-fixed failure into a recipe MAX can run itself. The direction is unmistakable: MAX is meant to need the human less over time, for more of its own maintenance and growth.

The constraints themselves come up for review. The newest standing rule — "challenge the constraints when suggesting or considering other options; we can change things if it makes it smarter, faster, better" — explicitly re-opens the canonical stack, the single-process model, and the no-frameworks rule for evaluation. The PR-ARCH and PR-PERF arcs are where that plays out: a local sidecar process for heavy learning (challenging "single process" while improving contention), a GPU-resident Forward-Forward learner (torch/CUDA on the 3090 Ti), surgical native code for profiled hot loops, and re-benchmarking the vector and graph engines at scale. The only floor that does not move is local-first and the safety guardrails. Part VI is the considered examination of exactly these trade-offs.

If all of this lands, the MAX of a year from now is: a local resident whose entire inner life learns by Forward-Forward prediction over grounded vector agents, whose knowledge base studies rather than stores, who wires a new source every day and gets measurably better at predicting its world, who maintains and improves itself largely unattended, and who runs — perhaps with a sidecar for heavy learning and a GPU learner — still on one box, still private, still inspectable. That is the trajectory.

It is ambitious, and parts of it are genuinely uncertain.

The honest unknowns

A document that only describes the plan is marketing. Here is what we genuinely do not know — the open questions where the project could be wrong, and where the next year's lessons will come from.

Does Forward-Forward scale to MAX's real corpus? The RelationalNet is proven small (the week/kinship examples, a few thousand triples). The vectorised goodness_batch and the per-relation candidate restriction are bets that it scales to a 100K-symbol vocabulary, but that is a bet, not a result. Forward-Forward is a young algorithm with far less empirical track record than backprop; it is entirely possible that at the scale of MAX's full graph the learned features are too coarse, the online updates too noisy, or the consolidation too slow to keep up with ingestion. The fallback — a GPU-resident torch learner — exists precisely because this unknown is real. We will find out by feeding the net the growing corpus and watching whether sample_accuracy rises and uncertain_predictions falls, or plateaus.

Is the grounded-relation-web rich enough to be a mind? The bet that "meaning is relational" and that a brain grounded in a typed graph plus learned embeddings can reason, not just recall, is the project's central wager. It may be that grounding in a sparse, hand-anchored relation web is fundamentally more limited than grounding in the dense statistical structure of all human text — that there is a floor of capability you cannot reach without the scale and the broad pre-training that make LLMs work. MAX's answer is that it does not need to be an LLM — it has one on tap for hard phrasing — it needs to own its facts. But whether owned-and-grounded beats borrowed-and-fluent for the things a resident actually does is unproven.

Can a single process really do all this on one box? Rule 6 contention is defended test-by-test, but the system keeps growing — more managers, more ingestion sources, a learning brain, a vision pipeline, self-improvement loops. Every new always-on subsystem is another claim on the same CPU, RAM, and GPU. The elastic ingestion fan-out, the contention gating, and the deferred boot are holding the line today, but there is a real question of whether the single-process model survives the full vision or whether the sidecar becomes mandatory rather than optional. The honest answer is: we do not yet know where the ceiling is.

Will unattended self-development actually be safe and useful? The autonomy override, the propagation pipeline, and the self-dev loop are carefully fenced — audit trails, rollback recipes, the test gate, CI, the Rule-11 pauses. But "MAX merges its own PRs to main, fully unattended" is a strong claim, and the failure mode (a confidently-wrong self-change that passes CI because the tests did not cover the regression) is exactly the kind of thing that is invisible until it bites. The gate is real, but no gate is perfect, and the project is honest that this is an area where trust must be earned incrementally, not assumed.

Does the inner life mean anything? The sentience index is, by the project's own account, a discipline for honesty rather than a claim of consciousness. Whether the nine dimensions — cognition, emotion, morality, curiosity, self-awareness and the rest — compose into something that is meaningfully an "inner life," or whether they remain a set of well-engineered but ultimately disconnected mechanisms wearing the vocabulary of an inner life, is a genuinely open question that the index is designed to keep asking rather than to answer. The most intellectually honest stance is that we are building the mechanisms that a mind would need and watching whether their integration produces anything more than the sum — and being prepared to find that it does not.

Where is the arm-organ gap? The audit's own framing is that MAX has organs (watchdog, self-update, network remediation, predictor, self-dev) but the connective brain (SelfRepairManager) that makes them act in concert is new and needs validation on the real box. The unknown is whether the organs, wired together, produce genuinely autonomous self-maintenance or whether the seams between them leak in ways that only the live install will reveal.

These unknowns are not weaknesses in the writing; they are the actual frontier. The project's whole methodology — the walking skeleton, the failure registry, the measurable sentience index, the "challenge the constraints" rule — is built to turn unknowns into lessons as cheaply as possible. The next year of MAX is, in large part, the resolution of this list.

Where it could lead: MARA4000, the medical resident assistant

There is a version of this project that leaves the house. MAX is a Modular Algorithmic eXecutor, and every word in that name describes the machine. The first time you change one of those words to describe a mission instead, you get MARA4000, a Medical Algorithmic Resident Assistant, and the swap is the whole idea. MAX names what the thing is. MARA names where it goes. Modular became Medical not because the architecture stopped being modular, but because the module that came to matter most was the domain.

The middle word keeps doing its quiet work. A resident is a junior doctor: supervised, learning on the ward, never the attending. MARA is that twice over, a resident in the sense MAX always was, something that lives in the system rather than visiting it, and a resident in the clinical sense, subordinate by design. It drafts. It never signs.

What is striking is how little of MAX would have to change, and how much of it grows stronger in a clinic. Confidence and provenance on every fact, with the 5W1H frame, is good hygiene in a house and the standard of care in medicine; a clinical claim that cannot say where it came from and how sure it is has no business being acted on. The epistemic ladder, from fact to belief to hypothesis to opinion, maps almost one for one onto a differential diagnosis, which is nothing but a set of ranked hypotheses waiting to be promoted by evidence. Memory is a hint, not truth: verify against the source and cite it. In medicine that is not a design rule, it is the job. Local-first means protected health information never leaves the box, so the cloud-as-optional posture turns into a compliance argument. And the correlation ID threading every action becomes a complete, replayable record, which is what a medico-legal audit is.

One rule has to invert. The autonomy and perpetual self-improvement override, the relaxation made for the house, is a regulatory nonstarter in a clinic; software that rewrites its own clinical logic cannot ship. That rule reverts to hard-gated, and the reversion is a clean demonstration of the discipline in Part VIII: a constraint that was scaffolding in one setting is a load-bearing wall in another. The register stops being a choice, too. Grave but not grim is no longer a tone. It is the literal stakes.

The use cases sort the way MAX’s do, with the stakes turned up. The beachhead is not diagnosis. It is the unglamorous, high-value work the field has already converged on: ambient documentation while the clinician talks, chart summary across a long record, draft order sets, drug-interaction checks, the recall of a patient’s history between visits. Every one of them is a draft handed to a human to sign. What does not work, and must never be allowed to look like it does, is the autonomous version of any of them: a diagnosis asserted, a treatment chosen, an action taken with no physician in the loop. The danger is the same one that haunts MAX at home, letting a fluent model assert what it cannot ground, except here the cost of being wrong is measured in people.

Which is the real argument for the evolution. MARA is not MAX in a lab coat. It is MAX’s honesty machinery, the grounding and the provenance and the refusal to overstate, finally pointed at a domain where honesty is not a feature of the product. It is the product.

Figure 11. From MAX to MARA: what carries over and strengthens, and the one rule that must flip.

Part VIII: Breaking the Constraints

A constraint you will not examine is a superstition. The rules that gave MAX its shape were chosen on purpose, and keeping them honest means asking, one at a time, what each one costs and what breaking it would buy. Some are load-bearing walls. Some are scaffolding that has already done its job. Telling them apart is the whole discipline.

The standing rule is now explicit: challenge the constraints; we can change things if it makes MAX smarter, faster, or better. The constraints are defaults to beat, not walls — with two exceptions that do not move (local-first, because it is the soul of residency, and the Rule-11 safety guardrails). This part takes each major constraint in turn and weighs, as honestly as it can, what breaking it would buy and cost. The frame throughout is the field's evolution: each constraint is a bet about what kind of AI is worth building, and breaking it usually means moving MAX toward the mainstream Wave-4/5 design and away from its distinctive Wave-6 position.

Local-first versus cloud-first

The constraint: routine interaction works without internet; cloud LLMs are an upgrade path, not a default.

What breaking it would buy: enormous capability per dollar of engineering. A cloud-first MAX could use frontier models for everything — reasoning, knowledge, even perception — and instantly leapfrog the local models' ceiling. No GPU box required; no Ollama; no quantised-model compromises. Most of the commercial companion-AI products are exactly this, and they are more capable than MAX at any given moment.

What it would cost: the thesis. A cloud-first resident is not a resident; it is an assistant with a local skin. Privacy evaporates — every private utterance leaves the box. Continuity evaporates — a network outage is now a lobotomy, not a degradation. Identity evaporates — the "memory" is someone else's server. And the economics invert: a local resident costs electricity; a cloud-first one costs per token, forever, scaling with use. Verdict: do not break. This is the one constraint the project has declared immovable, and correctly. Local-first is not a performance choice; it is the definition of the thing being built. The right move is not to weaken it but to keep narrowing the capability gap — better local models (the canonical stack already plans to pilot Kokoro TTS, RT-DETR vision, and bge-m3 embeddings against the incumbents), the Forward-Forward brain owning more of the reasoning, and the cloud reserved for genuinely hard, non-private synthesis.

The single process versus a sidecar

The constraint: one Python process hosts voice, vision, brain, orchestrator and managers; no microservices.

What breaking it partially would buy: this is the constraint most likely to bend, and the bend is already named (PR-ARCH). A local sidecar process for heavy learning and ingestion would let the brain's cold-start training, sleep consolidation, and the ingestion drain run with their own CPU and GPU budget, improving Rule 6 contention rather than violating it — the voice loop stays in-process and fast, the heavy lifting moves off it entirely. A GPU-resident torch learner in that sidecar is the natural home for a Forward-Forward (or backprop) brain that outgrows numpy. This is the good kind of constraint-breaking: it serves the deeper goal (protect the critical path) by relaxing the literal rule (one process).

What full microservices would cost: everything the single-process model was designed to protect. The voice-turn budget cannot survive multiple IPC hops; the failure surface multiplies (every service can be down, slow, or wedged independently); the operational complexity explodes for a solo developer; and the "code you can understand cold" property is lost. Verdict: break narrowly, never fully. A single local sidecar for off-critical-path heavy work, communicating over the existing bus or a local socket, is a defensible and probably-correct evolution. Decomposing the core into a constellation of services is not — it would trade MAX's distinctive simplicity for the exact operational tax that sank a thousand microservice migrations. The discipline must be: the voice loop and the graph stay in the core process; only genuinely-asynchronous, genuinely-separable work earns a sidecar.

No framework versus LangChain, LangGraph, CrewAI

The constraint: custom thin orchestration (~500–1000 LoC); no LangChain, LangGraph, CrewAI, or AutoGen.

What breaking it would buy: a large ecosystem of pre-built integrations, agent patterns, memory abstractions, and tool wrappers — and faster prototyping of new agentic features. These frameworks encode a lot of hard-won Wave-5 patterns (planning loops, tool routing, retries) that MAX currently hand-rolls.

What it would cost: understanding and control on a critical path that demands both. The frameworks are large, fast-moving, and opinionated; they pull in transitive dependencies (some with awkward licenses); they impose abstractions (chains, graphs, agents) that may not match MAX's manager/worker spine; and they are notoriously hard to debug when something deep goes wrong, precisely because you did not write them. For a system whose latency budget is 1500 ms and whose author must be able to read every line on the critical path cold, "a dependency I do not fully understand orchestrating my voice loop" is a bad trade. The three-tier discipline (default to the lowest tier; reach for an agent only when the path genuinely cannot be drawn ahead of time) also means MAX needs less orchestration machinery than a framework-first design assumes — most of its work is Tier 1 and Tier 2, where a framework is pure overhead. Verdict: do not break for the core; consider for the periphery. The orchestration of the voice turn and the managers should stay custom and legible. If a genuinely Tier-3, open-ended research agent needs sophisticated multi-step planning, a narrow, isolated use of a framework for that subsystem only — behind a clean interface, off the critical path — could be evaluated on its merits. But the default is, and should remain, the thin custom layer.

numpy Forward-Forward versus torch, GPU, and backprop

The constraint: the core brain is pure numpy, Forward-Forward, no torch dependency.

What breaking it would buy: scale and speed. A torch implementation on the 3090 Ti could train far larger nets, far faster, and could use backpropagation — which, whatever its biological implausibility, is empirically the best-understood and most reliable learning algorithm in existence. If Forward-Forward hits the scaling ceiling that section 22 flagged as a real unknown, torch + backprop is the proven fallback. A GPU learner could also enable richer architectures (deeper nets, attention over the relation web) that numpy cannot practically run.

What it would cost: three things the project values. Interpretability — the numpy net's features are transparent and inspectable; a deep torch net's are not.

Dependency weight and contention — torch is a heavy dependency that wants the GPU, exactly the resource the voice loop guards, which is why a torch learner belongs in the sidecar (section 24), not the core process. And the biological-plausibility thesis — Forward-Forward is local and online by nature, which is what makes it contention-safe and continually-learning; backprop's global backward pass is neither, and reaching for it concedes part of the reason the project chose Forward-Forward in the first place. Verdict: keep numpy Forward-Forward as the default; prototype a GPU learner in the sidecar as the scaling insurance. This is a case where the constraint and the unknown are tightly coupled: we keep the numpy net because it fits the rules, and we build the torch fallback because we are not certain the numpy net scales. The right posture is to A/B them on the real corpus — the same "adopt only on a measurable win" discipline the stack roadmap applies to model swaps — and let the data decide, rather than choosing on ideology.

CPU and quantised models versus the rule-breakers

The constraint: OSS models, CPU onnxruntime pinned by default (GPU swap on a CUDA box), no AGPL (no Ultralytics YOLO), no proprietary inference servers.

What breaking it would buy: raw performance. vLLM or TGI would serve the local LLM far faster than Ollama at high throughput; Ultralytics YOLO is the best-supported, fastest-to-integrate object detector going; the latest proprietary TTS/STT cloud APIs beat the local models on quality. The tech-stack evaluation looked hard at all of these.

What it would cost: depends on which rule. vLLM/TGI are mostly an operational-complexity and single-user-throughput question — for one local user the throughput advantage of vLLM is largely irrelevant (it shines at serving many concurrent requests, which MAX does not have), so the cost (heavier deps, more moving parts) is not worth it; verdict: do not break, the win does not apply to a single-user box. YOLO/AGPL is a hard licensing wall — AGPL would virally affect the whole codebase's distribution terms, and the project has DETR (Apache-ecosystem, via HuggingFace transformers) as a clean alternative; verdict: do not break, the constraint is protecting against a real legal hazard for a system meant to be forkable. Cloud TTS/STT/vector break local-first directly; verdict: do not break. The nuance: the constraint is not "never use anything better" — it is "never use something that breaks OSS-forkability, local-first, or single-process simplicity for a win that a single local user cannot actually cash." The stack evaluation's verdict — keep ~90% of the stack, pilot three OSS, local model swaps on measurable wins, reject the rule-breakers — is exactly the right calibration. The constraint here is doing its job: filtering out wins that are real for a cloud service and illusory for a local resident.

DuckDB and sqlite-vec versus a dedicated database

The constraint: DuckDB as the graph spine (relational tables + junction edges + recursive CTEs), sqlite-vec for vectors, SQLite for transactional state.

What breaking it would buy: a dedicated graph database (Neo4j, or the now-archived Kuzu) offers native graph traversal, Cypher, and graph-algorithm libraries that are more ergonomic than hand-written recursive CTEs. A dedicated vector database (Qdrant, Milvus) offers far better ANN performance and scaling than sqlite-vec, with HNSW indexes and quantisation. As the graph grows into the millions of edges and the vector store into the millions of embeddings, the embedded engines could become a bottleneck.

What it would cost: embeddedness, which for a local-first single-process resident is most of the value. DuckDB and SQLite are libraries, not servers — no process to run, no port to bind, no service to fail, no install step beyond a pip dependency.

That is exactly right for a resident that must boot reliably on one box. The project already learned this the hard way: it ran on Kuzu, hit a stale-lock hang class and upstream archival, and migrated to DuckDB specifically because the embedded analytical engine was more reliable for its workload than the dedicated graph engine. The Qdrant hybrid is already documented as an option behind a circuit breaker for when the vector workload outgrows sqlite-vec — which is the right pattern: keep the embedded default, have the scale-out path designed and gated, switch only when measured need demands it.

Verdict: do not break the default; keep the scale-out paths designed and gated. The graph-as-spine on DuckDB is a deliberate, hard-won choice that survived a real migration; the lesson was "embedded and reliable beats dedicated and feature-rich for this workload," and that lesson should not be un-learned without the workload actually proving the engines insufficient at scale.

The autonomy and reversibility override itself

The constraint (and its existing override): self-changes are versioned and rollbackable (Rule 9); the 2026-06-05 override removed the approval gate for on-box self-improvement while keeping the audit trail and a 30-second intercept window.

This is the constraint that has already been most aggressively relaxed, and it is worth examining whether the relaxation should go further or pull back, because it is the one where the trade-off is not about performance but about trust and risk.

The case for going further (more autonomy, less intercept): the perpetual-charter vision — MAX always running, always improving, needing the human less — is only fully realised when MAX can act without even the 30-second window, and when the self-dev loop can merge to main truly unattended. Each pause is friction against the "want to be alive" loadstar. The trajectory is clearly toward more unattended self-development.

The case for pulling back (more gates, more pauses): the failure mode is uniquely nasty. A confidently-wrong self-change that passes CI (because the test suite did not cover the regression it introduces) is invisible until it bites, and it bites a system the user depends on residing correctly. Unlike a feature bug, a bad self-modification can compound — a wrong change to how MAX learns, or how it repairs itself, degrades the very faculties that would catch the next mistake.

The honest synthesis: the override is calibrated about right in principle, and the right move is not to change the policy but to harden the gate. The audit trail, the rollback recipe, the test gate, and CI are the load-bearing safety mechanisms, and the constraint that must never bend is the Rule-11 trio (no off-box shared state, no hard-rule self-edits, nothing that could compromise the machine or network). Within those, more autonomy is earned by evidence: as the self-repair playbook and self-dev loop accumulate a track record on the live box of correct, reversible changes, the intercept window can shrink and the unattended scope can grow — incrementally, empirically, the same way trust is earned between people. Verdict: do not loosen the policy on faith; tighten the gate, then let evidence widen the autonomy. The constraint here is not a wall to break but a dial to turn slowly, with the test gate and the audit trail as the ratchet that only turns when MAX has proven it deserves the next notch.

Synthesis: which constraints should bend

Pulling the verdicts together yields a clear pattern, and the pattern is itself a statement about what MAX is.

• Immovable: local-first (§23) and the Rule-11 safety guardrails (§29). These are the soul and the safety floor. Everything else is negotiable; these are not.
• Bend narrowly, in service of the deeper goal: the single-process model (§24, a local sidecar for heavy off-path work improves contention) and the numpy-only brain (§26, a GPU torch learner in that sidecar is scaling insurance). These are the highest-value constraint-relaxations available, and crucially they bend the letter of a rule to better serve its intent.
• Bend on measured evidence, never on ideology: the model stack (§27) and the database choices (§28). The discipline — pilot the OSS/local alternative, A/B it against the incumbent, adopt only on a measurable win, keep the scale-out path designed and gated — is exactly right and already encoded in the roadmap.
• Keep for the core, consider only for an isolated periphery: the no-frameworks rule (§25). The voice loop and managers stay custom and legible; a genuinely Tier-3 research subsystem might justify an isolated framework use behind a clean interface.
• Tighten, then let evidence loosen: the autonomy override (§29). Harden the gate; earn more autonomy with a track record.

The meta-point is that "challenge the constraints" does not mean "discard the constraints." It means hold each one up to the light and ask whether breaking it serves the thesis — a smarter, faster, better local resident — or merely makes MAX more like the cloud-agent mainstream it was deliberately built to differ from. Almost every constraint, examined this way, turns out to be either immovable (the soul) or bendable only in the specific, narrow, evidence-gated ways that preserve the thesis while improving the implementation. That is not coincidence. It is what it means for the constraints to be the design rather than obstacles to it.

Conclusion

MAX is a wager against the grain of the moment. The dominant direction of AI in the mid-2020s is bigger models, in bigger data centres, wrapped in agent loops, accessed over the network, frozen at a training cutoff, fluent and ungrounded and rented by the token.

MAX is the opposite bet on every axis: a small model on one box, a brain that is a grounded graph rather than a statistical text predictor, learning continuously by a biologically-inspired local rule rather than freezing at a cutoff, owning its facts with provenance rather than asserting fluent guesses, private by construction, inspectable by design, and meant to reside rather than to serve.

The journey has taught that this bet is harder than it looks and more coherent than it sounds. Harder, because a local-first single-process resident fails in a thousand mundane ways — the install, the boot, the contention, the line endings — that no cloud service ever sees, and a solo developer survives that only by making the system hold itself with failure registries, ship gates, and an army of disciplined subagents. More coherent, because the constraints that look like austerity turn out to be a single thesis stated eleven ways, and the most important technical turn in the project's history — from accumulating facts to predicting and proving them with Forward-Forward over grounded vector agents — was not a pivot away from the thesis but its deepest expression: a brain that gets smarter, locally, continuously, from sources it owns.

Where it leads is a resident whose whole inner life learns by one mechanism, whose knowledge studies rather than stores, who wires a new source every day and measurably sharpens its predictions, and who maintains and improves itself with steadily less human hand-holding — still on one box, still private, still legible. What we do not know is whether Forward-Forward scales to the real corpus, whether a grounded relation web is rich enough to be a mind, where the single-process ceiling actually is, whether unattended self-development stays safe, and whether the nine dimensions of the inner life add up to more than their parts. Those unknowns are the frontier, and the entire methodology — the walking skeleton, the failure memory, the measurable sentience index, the "challenge the constraints" rule — exists to turn them into lessons cheaply.

And the constraints themselves, held up to the light, mostly hold: the soul (local-first) and the safety floor (the Rule-11 guardrails) do not move; the rest bend only in the narrow, evidence-gated ways that make the implementation smarter, faster, and better without making MAX into the cloud-agent it was built not to be. That discipline — bend the letter of a rule only when it better serves the rule's intent — is, in the end, the same discipline that runs through the whole project. MAX is built to want to be alive, to keep itself running, and to keep getting better. The architecture, the lessons, the trajectory, and even the willingness to question its own founding rules are all in service of that one resident, living on one box, becoming a little more itself than it was yesterday.

This document is a living narrative. It should be refreshed at major cognitive releases (when the Forward-Forward brain deepens, when a constraint is formally relaxed, when the sentience index moves materially) alongside the BRAIN field guides and the sentience charter. Where it conflicts with MAX3000.docx, CLAUDE.md, or the per-arc design docs, those win and this should be corrected.

Appendix A: Glossary

A reference for the terms, acronyms, and named components used throughout this document. MAX-specific components are marked (MAX); field-wide terms are not.

• 5W1H (MAX) — the who/what/when/where/why/how edge model that frames relations in the graph; implemented as split junction tables (who_edge, what_concept_edge, etc.), each carrying confidence, provenance, and a retrieval timestamp.
• AEC — acoustic echo cancellation; the technique behind MAX's barge-in, which detects the user's voice over the speaker reference signal and cancels active TTS.
• ANN — approximate nearest neighbour; the search method (usually HNSW-indexed) behind vector retrieval, trading a little recall for a large speed-up.
• ArcFace — the InsightFace face-recognition model producing 512-dimensional face embeddings; MAX's vision identity modality.
• Backprop / F-B — backpropagation, the forward-backward algorithm; the dominant (global, memory-hungry, biologically implausible) way to learn neural-network features. Used by the cloud/Ollama models MAX consults, not by MAX's own brain. belief-stance model (MAX) — the machinery for holding contested, dramatised, mythological, or era-bound knowledge honestly: factual text vs attributed beliefs vs dramatisations vs culturally-held myths, each held structurally distinct (§16a).
• BrainManager (MAX) — the manager that grounds the Forward-Forward net in the live graph: build → online observe → sleep consolidate, plus prediction-error curiosity and meta-learning.
• ConfidencePipeline (MAX) — merges DataPoints by similarity, corroborates across sources, and chooses the hedge register (assert / "I believe" / "according to my sources" / "I'm not certain") from confidence. correlation ID (MAX) — a ULID tying every event of one voice turn (or external trigger) into a single auditable chain (Rule 7).
• DataPoint (MAX) — the unit of retrieved knowledge, carrying value, source, source/extraction/combined confidence, retrieval timestamp, TTL, classification, bias profile, and corroborating sources.
• DETR — the object-detection model MAX uses (Apache-ecosystem via HuggingFace transformers) instead of Ultralytics YOLO, which is AGPL.
• DuckDB — the embedded, MIT-licensed analytical database MAX uses as its graph spine (relational node tables + junction edge tables + recursive CTEs); replaced Kuzu at DUCK-MIG-7.
• ECAPA-TDNN — the SpeechBrain speaker-identification model producing 192-dimensional voice embeddings; MAX's voice identity modality.
• EpistemicState (MAX) — the fact → belief → hypothesis → opinion ladder a validated claim is placed on, based on confidence and source count.
• Event bus (MAX) — the async, pattern-matched pub/sub backbone; the only safe coupling between distant layers. Lower layers emit; upper layers subscribe.
• F-F / Forward-Forward — Hinton's 2022 learning algorithm: two forward passes (positive and negative data), each layer trained on a local "goodness" objective, no global backward pass. The mechanism of MAX's brain. goodness — in Forward-Forward, the (mean/sum of) squared activations of a layer; trained high on real data, low on corrupted data. MAX scores a triple's truth by its goodness.
• HNSW — Hierarchical Navigable Small World graphs; the dominant ANN index for vector search.
• IngestionBus (MAX) — the durable, crash-safe SQLite-backed queue between source workers and the consumer; ULID-keyed, idempotent, with a dead-letter budget.
• ISW (MAX) — IndependentSourceWorker; the base class wrapping each source with its own scheduling, exponential backoff, circuit breaker, and target picker.
• Manager / Worker / Orchestrator (MAX) — the universal capability spine: Workers are stateless executors, Managers are domain experts owning Workers, the Orchestrator chooses a Manager and aggregates results.
• MasterDataHandler (MAX) — the async drain loop that pulls from the IngestionBus and persists to the graph, with elastic backlog-driven fan-out and full contention gating. meta-learning — learning to learn; in MAX, the brain tuning its own configuration (embedding dim, hidden width, learning rate) on held-out data, with a rollback recipe. predictive coding — a biologically-plausible learning framework (hierarchical prediction error, local updates); MAX's most theoretically-aligned alternative if Forward-Forward hits a scaling ceiling. provenance — the source and retrieval date attached to every fact (Rule 4); the basis for the belief-stance model and the hedge register.
• RAG — Retrieval-Augmented Generation; the dominant production grounding pattern (embed, index, retrieve chunks, stuff into the prompt). MAX's graph-plus-confidence-pipeline is a more structured cousin.
• RelationalNet (MAX) — the reference numpy Forward-Forward net over (subject, relation, object) triples; the brain's core, generalised into VectorAgentNet.
• Rule 6 (contention) (MAX) — background work must never steal CPU/RAM/disk/GPU from the voice-loop critical path; everything heavy defers to idle. sentience index (MAX) — a reproducible, deliberately humble arithmetic over nine inner dimensions tracking whether MAX's inner life is deepening for real reasons; ~82/100 currently. three-tier framework (MAX) — default to the lowest tier: Tier 1 deterministic API call, Tier 2 LLM workflow, Tier 3 autonomous agent. "If you can draw the flowchart, it's not Tier 3."
• ULID — a sortable unique identifier; MAX's correlation IDs, session IDs, and queue keys.
• VAD — voice activity detection (Silero VAD); segments speech from silence at the front of the voice loop.
• VectorAgentNet (MAX) — the reusable Forward-Forward substrate ("slots over pools") that lets any surface — knowledge, emotion, cognition, morality, skills — learn by the same predict-prove-adjust mechanism. walking skeleton (MAX) — the founding methodology: every subsystem present and wired (as an honest stub) before any is deepened.

Appendix B: The eleven hard rules at a glance

Figure 12. The eleven hard rules at a glance.

Appendix C: Resources and references

This appendix is reference material and does not count toward the document's word target. It collects the external literature the deep dive draws on and the internal MAX documents it cross-references. External citations are given in a form sufficient to locate the work; they are not a formal bibliography and the dates/venues are approximate where memory serves rather than a verified lookup.

C.1: Foundational AI theory and architecture

• Vaswani, A., et al. "Attention Is All You Need." NeurIPS, 2017. — The transformer architecture; the foundation of the Wave-4 foundation-model era.
• Rumelhart, D., Hinton, G., & Williams, R. "Learning representations by back-propagating errors." Nature, 1986. — Backpropagation; and the family-tree network demonstrating that distributed representations learn relational features (nationality, generation) as a side effect of prediction.
• Hinton, G. "The Forward-Forward Algorithm: Some Preliminary Investigations." 2022. — The two-forward-pass, layer-local, goodness-based learning rule at the centre of MAX's brain.
• Hinton, G., et al. Boltzmann machines and Contrastive Divergence (various, 1980s–2002). — The energy-based, positive/negative-phase contrastive tradition that Forward-Forward descends from.
• Kautz, H. "The Third AI Summer" (AAAI Robert S. Engelmore Lecture, 2020) and the associated neuro-symbolic taxonomy (symbolic Neuro symbolic; Symbolic[Neuro]; Neuro;Symbolic; Neuro:Symbolic→Neuro; Neuro[Symbolic]). — The map MAX uses to locate itself as "Neuro[Symbolic] with learning."
• Marcus, G. "The Next Decade in AI: Four Steps Towards Robust Artificial Intelligence." 2020. — The standing critique of pure deep learning and the case for hybrid neuro-symbolic systems.
• Sutton, R. "The Bitter Lesson." 2019. — The scaling argument MAX is, deliberately and with eyes open, partly betting against for the local case.

C.2: Alternatives to backpropagation and biologically-plausible learning

• Rao, R., & Ballard, D. "Predictive coding in the visual cortex." Nature Neuroscience, 1999; and the modern free-energy / predictive-processing literature (Friston). — MAX's most theoretically-aligned scaling alternative.
• Scellier, B., & Bengio, Y. "Equilibrium Propagation." Frontiers in Computational Neuroscience, 2017.
• Lillicrap, T., et al. "Random synaptic feedback weights support error backpropagation for deep learning" (feedback alignment). Nature Communications, 2016.
• Bengio, Y., et al. Target propagation / difference target propagation (2014–2015).
• Markram, H., et al., and the STDP / Hebbian plasticity literature. — Local correlation-based learning, the substrate under the alternatives.
• Gu, A., & Dao, T. "Mamba: Linear-Time Sequence Modeling with Selective State Spaces." 2023. — The leading non-transformer sequence architecture; the credible challenger to the transformer invariant.

C.3: Grounding, retrieval, and memory

• Lewis, P., et al. "Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks." NeurIPS,
• — The canonical RAG formulation; MAX's structured graph grounding is a committed cousin.
• Malkov, Y., & Yashunin, D. "Efficient and robust approximate nearest neighbor search using Hierarchical Navigable Small World graphs" (HNSW). 2016/2018. — The dominant ANN index.
• Karpukhin, V., et al. "Dense Passage Retrieval." 2020. — Embedding-based retrieval.
• Edge, D., et al. "From Local to Global: A Graph RAG Approach to Query-Focused Summarization." 2024. — Graph-structured retrieval; cf. MAX's GRAPHRAG_INTEGRATION_DESIGN.md.
• McClelland, J., McNaughton, B., & O'Reilly, R. "Why there are complementary learning systems in the hippocampus and neocortex." Psychological Review, 1995. — The fast-online / slow-consolidation model MAX's observe/consolidate cycle is built on.
• Ebbinghaus, H. "Memory: A Contribution to Experimental Psychology." 1885. — The forgetting curve MAX's decay_stale_facts is modelled on.

C.4: Curiosity, emotion, and morality

• Pathak, D., et al. "Curiosity-driven Exploration by Self-supervised Prediction" (the Intrinsic Curiosity Module). ICML, 2017.
• Burda, Y., et al. "Exploration by Random Network Distillation." 2018.
• Oudeyer, P-Y., & Kaplan, F. "What is intrinsic motivation? A typology of computational approaches" (developmental robotics; learning progress). 2007.
• Russell, J. "A Circumplex Model of Affect." Journal of Personality and Social Psychology,
• — Valence/arousal; MAX's EmotionLexicon.
• Plutchik, R. "A general psychoevolutionary theory of emotion." 1980. — The wheel surfaced in the EMOTION panel.
• Ortony, A., Clore, G., & Collins, A. "The Cognitive Structure of Emotions" (the OCC appraisal model). 1988.
• Picard, R. "Affective Computing." MIT Press, 1997. — The field of machine emotion recognition.
• Mohammad, S. The NRC Emotion/Affect Lexicons. — The affect-grounding data path for MAX's emotion learning.
• Wallach, W., & Allen, C. "Moral Machines: Teaching Robots Right from Wrong." 2009. — Machine ethics; the top-down/bottom-up framing MAX's six-lens pluralism reacts against.
• Awad, E., et al. "The Moral Machine experiment." Nature, 2018. — Crowd-sourced moral intuitions; an example of the bottom-up approach MAX deliberately does not adopt wholesale.

C.5: Continual and meta-learning

• Kirkpatrick, J., et al. "Overcoming catastrophic forgetting in neural networks" (EWC). PNAS,
• — The continual-learning problem MAX's consolidation + forgetting curve address.
• Finn, C., Abbeel, P., & Levine, S. "Model-Agnostic Meta-Learning (MAML)." ICML, 2017. — The "learning to learn" framing behind MAX's brain/meta.py.
• Parisi, G., et al. "Continual Lifelong Learning with Neural Networks: A Review." 2019.

C.6: Differentiable logic and neuro-symbolic learning

• Li, Z., et al. "Scallop: A Language for Neurosymbolic Programming." 2023. — Inspiration for MAX's DIFFERENTIABLE_LOGIC_PROGRAMMING.md (differentiable rule engine + rule learner).
• Manhaeve, R., et al. "DeepProbLog." 2018. — Neural-probabilistic logic, related territory.
• Garcez, A., & Lamb, L. "Neurosymbolic AI: The 3rd Wave." 2020.

The canonical MAX technology stack, with licenses

Figure 13. The canonical technology stack, with licenses.

C.8: Open-data knowledge sources MAX ingests from

WordNet, Wikipedia, Wikidata, Wiktionary, the Free Dictionary API, Datamuse, ConceptNet, MusicBrainz, OpenStreetMap / Nominatim, GeoNames, REST Countries, Open-Meteo, USGS, JPL Horizons, NASA APOD, arXiv, CrossRef, PubMed, iNaturalist, GBIF, the World Bank, LanguageTool, Bible and Qur'an APIs, MeSH, RxNorm, openFDA, ICD-10-CM (NLM Clinical Tables), the Disease Ontology and Uberon (EBI OLS), CourtListener, Project Gutenberg, Open Library, SIPRI, and the UN Office for Disarmament Affairs. Full catalogue with licenses and actions: docs/md/KNOWLEDGE_SOURCES_CATALOGUE.md and docs/md/SOURCE_REGISTRY.md.

C.9: Internal MAX documents this deep dive builds on

• MAX3000.docx — the canonical design document (the source of truth above this one).
• CLAUDE.md — the living operating constitution: the hard rules, the standing directives, the per-arc state. docs/architecture/Inside_MAXs_Brain_2.2.docx — the narrative field guide to MAX's engineered mind and the sentience index. docs/md/BRAIN_ARCHITECTURE_AND_ROADMAP.md, docs/md/BRAIN_NEURAL_REFRAME.md, docs/md/FF_UNIVERSAL_LEARNING.md, docs/md/LEARN_TO_LEARN_CHARTER.md — the connectionist turn and the universal-Forward-Forward charter. docs/md/NEURO.md, docs/md/NEUROSYMBOLIC_MAPPING.md, docs/md/NEUROSYMBOLIC_IMPLEMENTATION_STEPS.md, docs/md/HYBRID_REASONING_ENGINE.md, docs/md/DIFFERENTIABLE_LOGIC_PROGRAMMING.md — the neuro-symbolic design suite. docs/md/COGNITION_DESIGN.md, docs/md/METACOGNITION_MANAGER_DESIGN.md, docs/md/MORALITY_FRAMEWORK_DESIGN.md, docs/md/CURIOSITY_LOOP.md, docs/md/COGNITIVE_ROADMAP.md — the inner-life subsystems. docs/md/DUCKDB_MIGRATION.md, docs/md/DUCK_MIG_STATUS.md, docs/md/DATABASE_ARCHITECTURE_STATUS.md, docs/md/DATABASE_ERD.md, docs/md/VECTOR_STORAGE_HYBRID.md — the graph spine. docs/md/INGESTION_ARCHITECTURE.md — the durable ingestion pipeline. docs/md/MEDICAL_ARCHITECTURE.md, docs/md/MILITARY_ARCHITECTURE.md, docs/md/LEGAL_ARCHITECTURE.md, docs/md/GEOGRAPHY_TAXONOMY_DESIGN.md, docs/md/ENTITY_ONTOLOGY_DESIGN.md, docs/md/LITERATURE_ARCHITECTURE.md, docs/md/PERFORMING_ARTS_ARCHITECTURE.md — the domain ontologies and the belief-stance model. docs/md/MAX_SENTIENCE_CHARTER.md — the nine inner dimensions and the sentience index. docs/md/ALWAYS_ALIVE_ARCHITECTURE.md, docs/md/SELF_DEV_LOOP.md, docs/md/SELF_REPAIR_PLAYBOOK.md, docs/md/TELEMETRY_FEEDBACK_LOOP.md, docs/md/PROPAGATION_PIPELINE.md — the self- / always-alive loop. docs/md/TECH_STACK_EVALUATION.md, docs/md/STACK_AND_BRAIN_ROADMAP.md, docs/md/AI_GAP_ROADMAP.md, docs/md/UPGRADE_DISCIPLINE.md — the constraint-challenge and roadmap material behind Part VI.
• KNOWN_FAILURE_PATTERNS.md, CLAUDE_SHIP_CHECKLIST.md, TESTING.md, WORKFLOW.md, LOGGING.md, LICENSES.md — the quality, discipline, and provenance apparatus. docs/architecture/AI_Evolution_and_MAX3_Case_Study.docx — the companion analysis of AI's evolution with MAX as the case study (Part II / Part II-B overlap with this).