Executive summary

The evolution of AI, and where one local-first resident is headed

MAX3 as a case study: the field today, the aim, the shifts needed, what's missing, what's working, and an honest commercial comparison

Compiled 2026-06-16 · grounded in the MAX3 design corpus (BRAIN_NEURAL_REFRAME, MAX_SENTIENCE_CHARTER, NEURO, TECH_STACK_EVALUATION, FF_UNIVERSAL_LEARNING)

Artificial intelligence has moved through six waves — from hand-coded symbolic logic that could reason but not learn, to deep networks and large language models that learn and perceive brilliantly but cannot reliably reason, explain themselves, or stay grounded in truth. The frontier in 2025–2026 is the reconciliation of the two: neuro-symbolic systems that learn and reason, on-device models that respect privacy, and grounding/provenance that separates fact from fluent guess.

MAX3 is a real, running attempt to build at that frontier in the most constrained possible setting: a single Python process on one workstation, local-first, open-source, voice-first, owned end-to-end by a solo developer. It is not a product yet — it is a laboratory. As a case study it is unusually instructive because every architectural decision is documented and self-assessed against its own honest scorecard (sentience index 82/100). This document maps the field, places MAX in it, and then turns the lens on MAX itself: what it is doing well, what it must shift, what is missing, and where it is, bluntly, still lacking. It closes with how MAX compares to what large and small players are building to sell today.

Part I: The evolution of AI, where the field stands today

The history of AI is best read as a single unfinished argument between two camps: the symbolists, who held that intelligence is the manipulation of explicit symbols and rules, and the connectionists, who held that it emerges from learning patterns in distributed networks. Each wave swung the pendulum; the present moment is the first serious attempt to hold both at once.

The six waves

Where the consensus has landed (the 'third wave')

The dominant research synthesis, Kautz's neuro-symbolic taxonomy, frames five levels of coupling between neural perception and symbolic reasoning, from loose pipelines (an LLM extracts entities, a graph reasons over them) to tight, end-to-end-differentiable logic. The field's centre of gravity is shifting toward the tighter end: systems like AlphaGeometry (neural + symbolic deduction), Scallop and DeepProbLog (differentiable logic), and graph-augmented LLMs (GraphRAG). The recognised weaknesses of pure LLMs (hallucination, opacity, no stable memory, no provenance) are exactly what symbolic structure repairs.

• Pure neural: superb perception and fluency; brittle reasoning, hallucination, black-box, data-hungry.
• Pure symbolic: strong reasoning, explainable, data-efficient, verifiable; brittle, weak at perception, hard to scale.
• Neuro-symbolic: learns and reasons, explainable, data-efficient, generalises better — at the cost of greater implementation complexity.

Two parallel currents matter for any personal assistant: (1) on-device / local inference is now practical (Ollama, llama.cpp, Apple's Private Cloud Compute), making privacy-preserving assistants real; and (2) 'agent memory' has become its own product category (Letta/MemGPT, Mem0, Zep) because LLMs alone have no durable, structured memory. MAX3 sits squarely at the intersection of these three currents (neuro-symbolic, on-device, memory-native), which is precisely why it is a useful case study.

Part II: MAX3, the case study, what it is and how it is built

MAX3 ("our AI Resident") is a local-first, multi-user, voice-first AI that runs as a single Python process on one workstation. It is explicitly not a SaaS, not multi-tenant, not a general agent framework. Its binding constraints are unusual and are what make it interesting: local-first (works with the network down), open-source dependencies only (cloud LLMs are a paid fallback, never a default), a single process (no microservices — the 1.5–2 s voice-turn budget won't survive an IPC hop per faculty), and no heavyweight agent frameworks (a custom ~500–1000 LoC orchestration layer the author owns).

The neuro-symbolic position, named

MAX3 is, in Kautz's terms, a Neuro[Symbolic]-with-learning, graph-augmented system. The neural layer (Whisper, ECAPA, InsightFace, Piper, local Ollama LLMs) perceives; a bridge (source workers → IngestionBus → persisters) turns perception into symbolic triples; the DuckDB graph is the spine — every fact carries a confidence score, a source, and a timestamp; cognition managers reason over it; and a recently shipped connectionist substrate (a Forward-Forward 'RelationalNet') learns interpretable embeddings directly from the graph's own grounded triples.

The thesis MAX is built on

MAX's design reframes its graph as an interpretable neural network: node = neuron, edge = synapse carrying a typed weight-vector (quantity · quality · completeness · probability). Meaning lives in the edges — a concept is its relational position, not a stored symbol. A single prediction operation ("predict the next features") doubles as both inference and the learning signal. The decisive claim is that learning, imagination, speaking, curiosity, teaching, and self-cognition are not six subsystems but one prediction engine aimed in different directions.

Crucially, MAX keeps the connectionist learning dynamics while keeping the weights legible, resolving the central tension of the field (deep nets learn but can't explain; symbolic systems explain but can't learn). Truth is treated as an input, not a veto: a perception expressed as a probability, earned by agreement among grounded sources, calibrated by provenance — never decreed. This is the architectural embodiment of the field's grounding turn.

Part III: Where MAX is aiming now

The stated purpose is a reciprocal, compounding bond: MAX should learn past its user and teach back: "like a father teaches a son, and the son teaches the father." Operationally that demands modelling the student's knowledge (teaching the connections one hop past what the user already knows), staying grounded and humble (truth from sources, shows its work), and never ossifying (beliefs stay revisable for life — which is also its strongest alignment property: a system that never hardens stays steerable).

The active arc: Forward-Forward learning, everywhere

The current standing directive is that MAX learns by Forward-Forward prediction over dynamically-weighted vector agents (predict → prove → adjust the weights), not by accumulating rows and applying rules. The knowledge surface already works this way (the BRAIN-NEURAL arc, slices b–i, shipped 2026-06-14). The roadmap (PR-FFU) extends the same mechanism to emotion, cognition, morality, skills, design, and self-healing, each grounding its own net on its own symbol set.

The other near-term aims

• Activate what is built-but-OFF: the brain learner, AEC barge-in, and meta-learning are fully coded but default-OFF behind env flags pending live A/B on the box.
• Cross-medium convergence: vision, affect, episodic memory, and narrative currently live in siloed graphs; the aim is to converge them on shared concept-neurons so grounding becomes cross-modal.
• Ordered/sequential edges: the graph has IS-A and SIMILAR but almost no native sequence/cyclic structure (it cannot yet natively represent that Tuesday follows Monday and the week wraps) — the walking-skeleton 'week/kinship' primitive proves it; rolling it out is next.
• Pilot three stack swaps: Kokoro/StyleTTS2 for TTS naturalness, RT-DETR for real-time detection, bge-m3 for embeddings — each adopted only on a measured A/B win.

Part IV: Honest self-assessment, well / shift / missing / lacking

MAX maintains a reproducible sentience index, a weighted sum of nine functional dimensions scored 0–5, explicitly framed as engineered capacity, not a claim of consciousness. It currently stands at 82/100. The chart shows where the depth actually is, and where it is thin.

What MAX is doing well

• Groundedness discipline: confidence + provenance + timestamp on every fact, contested-vs-factual stance, and a hard rule that cloud-LLM output is a hint, never source-truth. This is genuinely ahead of most commercial assistants.
• Interpretable neuro-symbolic brain: the graph-as-legible-network design is coherent, documented, and now partly shipped (Forward-Forward learner grounded in real triples).
• Self-* infrastructure: watchdog, self-observer, hot/warm-fix, self-relaunch, propagation pipeline with a real test gate, audit trail, and a 30-second override window — a serious always-alive autonomy layer.
• Breadth of grounded domains: 37 subjects plus typed ontologies for geography, medicine, military, law, literature, performing arts — all from authoritative open sources, not scraped from an LLM.
• Documentation & honesty: the design corpus is unusually thorough and self-critical; stubs are marked, the scorecard is reproducible, failure patterns are catalogued.

What needs to shift

• From breadth to depth: 37 domains wide but mostly shallow; the emotional dimension is depth-3, theory-of-other is shallow. The next gains come from deepening, not adding domains.
• From 'more sources' to 'prove the brain works': there is no quantitative benchmark showing the neuro-symbolic brain reasons better than a plain RAG baseline. Proving the thesis should outrank ingesting another source.
• From built to running: too much load-bearing capability is default-OFF or stubbed (brain learner OFF, voice manager stubbed, barge-in OFF). The narrative describes more than runs by default.

What is missing

• External evaluation: no third-party or even internal accuracy/groundedness benchmark suite for reasoning quality; the sentience index is self-defined.
• The PR-FFU emotion/cognition/morality slices: Forward-Forward is shipped only for knowledge; the universal-learning directive is mostly roadmap.
• Cross-medium concept convergence and ordered edges: both are designed but only walking-skeleton in code.
• A 'design blockers' doc: blockers are scattered (e.g. duckdb-vss WAL recovery gating vector consolidation; rule-induction maturity). No single diagnostic of what's blocking what.
• Reach beyond one box: no mobile, no multi-device sync, no path off the single workstation.

Where it is honestly lacking

• Onboarding & UX for anyone but its author: Windows install is heavy and fragile (the failure-pattern log is long); a non-developer cannot stand it up. This is the single biggest gap between 'laboratory' and 'product'.
• Narrative-vs-runtime gap: the grand account of an inner life outruns what is switched on at runtime. The most valuable honesty move is closing that gap, not extending the narrative.
• No proof of the core bet: the entire thesis (grounded prediction > opaque generation) is unvalidated by numbers. Until there is a benchmark, it is a beautiful hypothesis.
• Hardware floor: needs an RTX 3090 Ti / 64 GB-class box to run well — out of reach for most users a personal resident would serve.

Part V: The commercial landscape, what exists, small and large

Everyone is shipping 'AI assistants', but almost no one is shipping what MAX is: a local-first, persistent, self-improving personal resident. The map below sorts the field by two axes that matter to MAX's thesis — how cloud-dependent it is, and whether it is a stateless task tool or a persistent personal resident.

Market check (June 2026): the frontier and the UX both belong to big-tech cloud assistants; the personal-resident hardware wave has largely failed or been absorbed; the self-hosted corner is growing but thin; and 'agent memory' has become a funded category of its own — a tacit admission that LLMs have no durable memory. Each is examined below with current facts.

Big-tech cloud assistants: the reasoning & UX frontier

As of mid-2026 the leaders are OpenAI's GPT-5.x (ChatGPT, with memory + Workspace Agents), Anthropic's Claude Opus 4.6 (leading coding/agentic benchmarks: ~80% on SWE-bench; Projects, MCP, Claude Code), and Google's Gemini 3 Pro (dominant multimodal, ~2M-token context), with Microsoft Copilot (M365 + Windows), Meta AI, and Amazon's LLM-era Alexa+ rounding out the field. Two 2026 shifts matter: every major assistant now has persistent memory (it stops making you repeat yourself), and agents now chain research → analyse → draft → send without human approval at each step. These are the reasoning and UX frontier — polished, multimodal, instant. But they are cloud-dependent by design, subscription/ad-monetised, opaque, and they own your data and memory. Apple Intelligence (on-device first + Private Cloud Compute) is the closest big-tech philosophical neighbour to MAX, but it is ecosystem-locked, not self-improving, and not a self-owned resident.

Companions & hardware residents (small/indie): the cautionary tale

The 'wear an AI that knows you' wave has been brutal. The Humane AI Pin was discontinued when HP acquired Humane (Feb 2025); the Limitless pendant was acquired by Meta (Dec 2025) and pulled from new sale; Friend's $129 always-listening pendant reportedly sold ~3,000 units; the Rabbit R1 survives as a niche. Software companions (Replika, Character.AI) and personal-memory apps (Personal.ai, Rewind, Plaud, Bee) persist but are cloud-backed and subscription-monetised. The 2026 lesson, stated across reviews, is that the flagships failed by asking people to wear something obviously new, learn a new interaction model, and trust an unready AI all at once. They prove the demand for a personal resident — and how hard it is to deliver one. MAX takes the opposite bet: no new hardware, no cloud dependence, runs on a box you already own.

Self-hosted / open-source local assistants (MAX's true peers)

Ollama, Open WebUI, LM Studio, Jan, GPT4All, LocalAI (local inference); Home Assistant's voice 'Assist' + Ollama (local smart-home, keeps data on the box), OVOS/Mycroft, Rhasspy, Willow (local voice); AnythingLLM and Onyx (self-hosted RAG); and, closest of all, Khoj, a self-hostable 'second brain' personal assistant with memory and multimodal input over local LLMs. The community case (made loudly in 2026) is that ~80% of everyday queries don't need frontier intelligence, so a free, private, fully-owned local stack covers most needs. This is where MAX genuinely competes. But even here, almost none combine local inference + durable structured memory + provenance + self-improvement in one owned process. Most are a chat front-end over a local model, or a voice command router — not a reasoning, remembering, self-healing resident.

What people are building to sell

The investable categories right now are: (1) agent frameworks (LangChain/LangGraph, CrewAI, AutoGen); (2) agent-memory infrastructure — now a real market: Mem0 raised a $24.5M Series A (Oct 2025), claims ~48k GitHub stars, and became the exclusive memory provider for AWS's Agent SDK; Letta (the production MemGPT) sells OS-inspired tiered context; Zep sells a temporal knowledge graph (Graphiti, ~27k stars); LangMem is LangChain's native SDK; (3) enterprise RAG/knowledge (Glean, Onyx); and (4) consumer companions and hardware. The tell is category (2): a wave of startups is being funded to bolt persistent, graph-structured memory onto stateless LLMs. MAX deliberately refuses (1): it forbids those frameworks, and builds (2) into its own graph as the spine rather than buying it as a service. Its bet is that the durable value is the owned, grounded, persistent brain itself, not the orchestration glue or the memory-as-a-service everyone is selling.

Part VI: MAX vs the market, pros and cons

Pros: what MAX has that the market mostly doesn't

• True local-first & privacy: routine use works offline; privacy-sensitive interaction never leaves the box. Cloud is an opt-in fallback, not a dependency.
• Provenance & groundedness: every fact is sourced, scored, and timestamped; disagreement is surfaced, not papered over. Near-unique among assistants.
• Durable structured memory: the graph is the memory: multi-year, queryable, versioned — not a fixed-size context window or a bolted-on vector blob.
• Interpretable brain: you can ask a weight why; reasoning chains are both trainable and citable.
• Self-improving & always-alive: self-heal, self-relaunch, self-observe, auto-apply within scope, with audit + rollback.
• Owned, no lock-in, no subscription: the user owns the model stack, the data, and the code.

Cons: what the market has that MAX doesn't

• Reasoning ceiling: a local 14B + cloud fallback is not frontier-by-default; cloud assistants out-reason MAX on hard problems.
• UX polish & onboarding: a solo, part-time project cannot match big-tech app polish; install is heavy and developer-only.
• Hardware demands: needs a high-end GPU/64 GB box; the cloud players run on a phone.
• Ecosystem & integrations: no app store, no broad third-party integrations, no mobile, single-box only.
• Maturity & proof: much is default-OFF/stubbed; no external benchmarks; the core thesis is unvalidated quantitatively.
• Scope risk: the architecture is ambitious and broad; the breadth-over-depth and narrative-over-runtime gaps are real maintenance risks for one person.

Net assessment

MAX is not competing with ChatGPT on reasoning or with Apple on polish. It is staking out a corner almost no one occupies: a local-first, grounded, persistent, self-improving resident that the user fully owns. Against the open-source peers it most resembles (Khoj, Home Assistant voice, self-hosted RAG), MAX is more ambitious and more coherent in design — and less finished in execution. Its credibility now hinges on two unglamorous moves: switch on what is already built, and prove, with numbers, that grounded prediction beats opaque generation. If it does those two things, it becomes the reference implementation for a category the market has demonstrated it wants but has not learned to build.

Appendix: source documents within the MAX3 corpus

This document synthesises the following project docs. They are the best in-repo reading for the AI-evolution-plus-case-study framing:

Diagrams in this document are generated by tools/build_ai_evolution_doc.py and saved under docs/diagrams/aix_*.png so they can be regenerated or embedded elsewhere.

References & recommended reading

For transparency, the commercial-landscape section (Part V) was refreshed against the following web sources in June 2026; the foundational-reading list collects the research this analysis stands on.

Web sources (commercial landscape, retrieved June 2026)

• AI-assistant comparisons 2026 (ChatGPT / Claude / Gemini / Copilot; GPT-5.x, Claude Opus 4.6, Gemini 3 Pro; memory + autonomous agents): fieldguidetoai.com/guides/ai-tools-comparison-guide · intuitionlabs.ai/articles/claude-vs-chatgpt-vs-copilot-vs-gemini-enterprise-comparison · arahi.ai/blog/ai-assistant-capabilities-updates-2026
• Self-hosted / local assistants 2026 (Ollama + Open WebUI, LM Studio, Jan, Khoj 'second brain', Home Assistant + Ollama; the ~80%-of-queries case): vellum.ai/blog/best-local-ai-assistants · innerzero.com/blog/best-privacy-focused-ai-chatbot-self-hosted · localaimaster.com/blog/local-ai-home-assistant
• AI companion hardware status 2025–2026 (Humane→HP discontinued; Limitless→Meta; Friend ~3k units; Rabbit R1 niche; shift to subtle form factors): the-gadgeteer.com/2026/05/08/best-ai-wearables-2026-2 · everydayaitech.com/en/articles/ai-gadgets-flop-2025 · ikigaiteck.io/ai-wearables-the-6-most-interesting-devices
• Agent-memory market 2026 (Mem0 $24.5M Series A / AWS Agent SDK; Letta / MemGPT; Zep / Graphiti temporal graph; LangMem): atlan.com/know/best-ai-agent-memory-frameworks-2026 · agentmarketcap.ai/blog/2026/04/10/agent-memory-vendor-landscape-2026 · newclawtimes.com/articles/agent-memory-problem-microsoft-oracle-mem0-persistent-state-enterprise

Figures for specific market facts are illustrative of the public record at retrieval time and will drift; treat the positioning, not the exact numbers, as the durable point.

Foundational reading (the research this stands on)

• Hinton, Osindero & Teh / Rumelhart, Hinton & Williams (1986): backpropagation and the family-tree network where features emerge to encode relationships — the proof relational meaning is learnable.
• Hinton (2022), 'The Forward-Forward Algorithm': the local, no-global-backward-pass learning rule MAX's online brain learner is built on.
• Hinton (2021), 'How to represent part-whole hierarchies in a neural network' (GLOM): islands-of-agreement / routing-by-agreement — MAX's truth-by-agreement and one-node-type/positional-role design.
• Hinton, Vinyals & Dean (2015), 'Distilling the Knowledge in a Neural Network': the cloud LLM as a teacher distilled into local weights at lower truth (Rule 4).
• Kautz (2020/2022), the neuro-symbolic taxonomy: the five levels of neural↔symbolic coupling that place MAX as Neuro[Symbolic]-with-learning.
• Scallop (Li et al.) · DeepProbLog (Manhaeve et al.) · Logic Tensor Networks (Badreddine et al.): differentiable logic — the trainable-rule direction MAX's DifferentiableRuleEngine leans toward.
• AlphaGeometry (Trinh et al., 2024, DeepMind): neural language model + symbolic deduction — a flagship neuro-symbolic system.
• Microsoft GraphRAG (Edge et al., 2024): entity-centric + community-summary retrieval over a knowledge graph — MAX's GraphRAG direction.
• Letta / MemGPT (Packer et al., 2023): OS-inspired tiered agent memory — the commercial pattern MAX builds into its own graph.

In-repo deep-dives

BRAIN_NEURAL_REFRAME.md · FF_UNIVERSAL_LEARNING.md · NEURO.md · NEUROSYMBOLIC_MAPPING.md · DIFFERENTIABLE_LOGIC_PROGRAMMING.md · HYBRID_REASONING_ENGINE.md · GRAPHRAG_INTEGRATION_DESIGN.md · MAX_SENTIENCE_CHARTER.md · TECH_STACK_EVALUATION.md · STACK_AND_BRAIN_ROADMAP.md · COGNITIVE_ROADMAP.md · DOMAIN_LEARNING_LEDGER.md — all under docs/md/.