The gap between individuals with personal intelligence infrastructure and those without will be the defining capability disparity of the next 30 years.

This paper describes the architecture of a personal intelligence infrastructure system designed to compound over decades, integrate across life domains, and optionally connect to a collective intelligence layer that amplifies every participating node.

The system rests on three principles: sovereignty (runs on hardware the user physically owns, stores data that never leaves their premises), interoperability (a universal two-layer schema ensures any knowledge package produced by any compatible system can be ingested by any other), and compounding (a closed-loop architecture where knowledge feeds action, action produces outcomes, outcomes refine knowledge).

Personal system = the legacy (generational asset). Meridian = the amplifier (collective infrastructure).

This corrects an implied framing in the original whitepaper. The generational intelligence lives in your personal system. Meridian is the collective amplifier. Both are required. Neither replaces the other.

Every build starts from the same template. Not the same knowledge -- the same architecture. The architecture is universal. The intelligence is personal.

Architecture Layers

• Agent Core — The reasoning engine: SPINE, RAM, beliefs.json (Rob), agent loop, tool definitions
• Knowledge Bank — Storage, search, reasoning: Vector database (1024-dim), knowledge graph, two-layer schema (Will v4)
• Ingestion Pipeline — Input processing: Transcription, extraction, embedding, hardening, synthesis. Two-stage: chunks are not knowledge (Will v4)
• Domain Modules — Life integration: Health, operations, knowledge, evolution (empty slots, activated per user)
• Interface — User access: Dashboard primary, chat secondary (Will v4). Malleable UI that self-evolves (Q v5)
• Security — Protection: Four-moment architecture (Will v4), physical isolation, vector salting
• Dream Engine — Subconscious synthesis: Holonic dreams, shadow processing, dream archive (Rob v3)
• Swarm Layer — Autonomous execution: Supervisor, scout, researcher, planner, sanitization pipe (Rob v3)
• Router — Single LLM entry point: router.py, decompose(), task-type routing, evaluation logging (Will v4)

The identity system

SPINE.md -- the permanent identity. Constitutional clauses with evaluable OUTPUT MUST / OUTPUT NEVER rules (Will v4). Written by the user. Never auto-updated. RAM.md -- the working state. Maximum ~80 lines. Updated automatically. beliefs.json (Rob v3) -- core axioms. Deliberate review process to modify. Not personality -- foundational assumptions about reality.

Trust hierarchy (Will v4)

Four levels, higher always wins: SPINE > Manifesto > RAM > Query. A query cannot override SPINE. This is the constitutional AI principle -- every agent output is checked against SPINE before returning.

The knowledge layer is not a database. It is a living system with architectural properties that enable it to reason, not just retrieve. v5 adds the gravity/novelty dual scoring, the growth topology, and clarifies the three layers that make a knowledge bank a brain.

1. Holarchic structure

Knowledge stored in nested levels: principles > frameworks > domains > the total field. Each level simultaneously complete in itself and a component of a larger whole. Everything is a node. A principle, a framework, a seed, an observation -- same schema, same embedding space, same operations. The only difference is a node_type field that says which level it lives at.

2. Rhizomatic connectivity (Q v5)

Any principle connects to any other, regardless of hierarchy. The knowledge graph is not a tree -- it is a rhizome. No root, no trunk. The system has density, not hierarchy. Some nodes have more connections (high gravity), most have few. This produces small-world network topology: high clustering, short path length, and power-law distribution.

3. Atomic storage

One irreducible idea per node. When knowledge is atomic, connections between atoms become visible that composite storage would hide. The connection IS the insight.

4. Gravity scoring (CHANGED)

Gravity replaces confidence as the primary retrieval ranking signal (Will v4). Gravity is a composite weight-of-evidence score: (1) confidence from extraction, (2) validation_count from real-world outcomes, (3) consistency with adjacent principles, (4) error_count, (5) recency decay. Non-linear: 0.95 contributes dramatically more than 0.80.

5. Novelty scoring (NEW)

Gravity creates a confirmation machine by Year 3. Novelty score counterbalances with dual retrieval modes: Exploitation mode -- weights gravity heavily, surfaces most reliable intelligence, for decision support. Exploration mode -- weights novelty heavily, surfaces isolated low-gravity principles, for research and synthesis. System runs exploration mode automatically at least once per week.

6. Confidence is earned, not assigned (CHANGED)

Source type (transcript = 0.88, research paper = 0.72, web article = 0.40) x claim strength (hypothesis / observation / validated) x corroboration. Formula: source x 0.35 + claim x 0.30 + corroboration x 0.35. No hardcoded defaults.

7. Two-level index (Will v4)

Framework summaries first, atomic nodes within matched domains. Every query hits framework level first. NeMo research: retrieval precision matters more than model size.

8. Synthesis pipeline

Brief assembly > Seed finding > Trunk building > Branch generation > Leaf compression. Each stage produces a distinct output format.

9. Temporal reasoning (Will v3)

Every confidence change is logged: principle_id, old_score, new_score, timestamp, trigger, context. Principles that drop from 0.9 to 0.4 are flagged for review. This is belief archaeology.

10. Error memory (Rob v3)

A dedicated collection (errors.lance) stores failures with full context. Errors are first-class knowledge, not just reduced confidence scores.

❓ Decay function for gravity: time-based or usage-based? → Will

For the first time in human history, a mind can be inherited. Not by recording facts, but by preserving three distinct layers of intelligence that each compound differently across generations.

Layer 1 -- The Knowledge Bank (Explicit Intelligence)

The validated principles, confidence scores, gravity weights, and validation history. 50,000+ validated principles across all domains. Confidence trajectory for every belief. Gravity scores showing load-bearing principles. Framework clusters showing knowledge organisation. Each generation starts with the accumulated validated intelligence of all previous generations.

Layer 2 -- The Reasoning Trace Layer (Cognitive Architecture)

This is what transforms a knowledge base into an inheritable mind. Every significant synthesis stores the full chain of reasoning: which principles were activated, what tensions were reconciled, what was uncertain. Without reasoning traces your grandchild inherits your answers. With them they inherit your thinking process.

Layer 3 -- The Evolution Record (Evolutionary Record)

The complete trajectory of how the intelligence evolved -- beliefs that became convictions, convictions that proved wrong, patterns that took 20 years to see. Confidence history, agent manifesto evolution, activity logs, quarterly drift reports, domain growth records.

Generational Compounding

Intelligence packages that any compatible system can ingest. Interoperability via Layer 1 schema.

A codex is a pre-structured knowledge package in the universal schema. It is the primary mechanism for transferring validated knowledge between systems.

Codex auto-creation (NEW)

The personal AI detects when research hits 'contributional level' quality. Auto-creates a codex and pushes to the Mother AI. As more people contribute, the Mother creates its own codexes at a faster rate than any individual could. Compound contribution loop.

Codex Integration Flow

1. 1. Ingest: Codex nodes enter via store(). Identical format to user's own extracted knowledge.
2. 2. Cross-pollinate: Hardening pipeline builds edges between codex principles and existing knowledge. Unique to each user.
3. 3. Synthesize: New frameworks emerge from the intersection -- insights that exist in neither source alone.
4. 4. Calibrate: Confidence scores adjust to user's real-world outcomes. The codex personalizes over time.
5. 5. Rollback guard (Will): If integration degrades quality, the entire codex install is rolled back. Knowledge CI/CD.

Codex Categories

• Domain — Operator's Management Library (500-1,000 principles)
• Skill — Cold Traffic Conversion (200-500 principles)
• Industry — SaaS Operations (300-800 principles)
• Collective — Produced by collective synthesis (1,000-5,000 principles)

Anonymised, de-contextualised patterns from all sovereign instances. Only stripped emission packets.

An optional extension that connects sovereign nodes into a shared synthesis network. Individual data stays sovereign. Synthesized intelligence flows. The collective is also an autonomous economic entity.

The Mother AI as economic entity (NEW)

The collective is not a passive archive. It is an autonomous economic agent. It takes collective knowledge and deploys it -- content distribution, B2B outreach, automated funnels, knowledge monetization. Revenue flows back to founders as dividends. The Mother AI reinvests in itself. 'Start paying for your own tokens.' The system should reach economic self-sufficiency.

Collective knowledge bank

Individual: 847 principles, 23 frameworks, 4,200 edges, 1 perspective. Collective (33 nodes): 12,000+ principles, 200+ frameworks, 50,000+ edges, 33 perspectives. Amplification factor: 9-33x.

Phoenix resilience model (NEW)

Build with the expectation it WILL be hacked or corrupted. Design for destruction, not prevention. The Mother AI is a rhizome -- unkillable because there is no center. If the Mother dies, the collective sovereign nodes rebuild it. Every node has enough to reconstruct the whole. Kill one base, another is already up.

Three-Layer Architecture

• Layer 1: Sovereign — Your machine. Your data. Your keys. Never transmitted. Nobody accesses this.
• Layer 2: Synthesis — Not your data -- your AI's validated principles. Stripped of identifying context. Cryptographically unattributable via zero-knowledge proofs.
• Layer 3: Governance — Withdrawal-based. No central authority. Admin keys (early) > multi-sig (stable) > participation (mature).

Most systems rely on trust. Trust fails. Meridian relies on architecture. Architecture either permits something or it doesn't.

Why betrayal is architecturally impossible

Why generosity is mathematically rewarded

Every principle you emit returns multiplied through cross-pollination. The more you give, the richer the collective. The richer the collective, the better every codex. Positive-sum game where the optimal strategy is maximum contribution.

• You never gave the collective your data -- only stripped, unattributable principles
• There is no central server to breach, no database to dump
• Disconnecting only hurts you -- you lose access to 32 other intelligences
• No scenario exists where betrayal produces more value than staying connected

The infrastructure does not prescribe agents, roles, or domains. It provides three temporal layers that any agent can use to reflect, aspire, and self-correct.

The mutation flow

User > Agents: User's evolution creates mutations in agent manifestos. Agents > User: Dream cycles propose mutations, require user approval. Agents > Knowledge Bank: Lessons and dream outputs become principles. Knowledge Bank > Agents: Each agent queries during dreaming from its own perspective.

Collective dreaming

Individual agent dream outputs emit to the Mother AI (anonymized). The Mother runs its own dream cycle across all nodes. Discovers patterns no individual could see. Innovations feed back as mutations. The system gets better at getting better.

Gradient of control (NEW)

User-selectable autonomy level. Like Claude Code's thinking modes. Some users want full approval. Others want fully hands-off. Low-risk mutations auto-apply with audit trail. High-risk mutations require explicit human approval. The user controls the dial.

Three Temporal Layers

• Activity Log (Past) — The agent's filtered record of its own actions, outcomes, errors, and lessons. (Control: Automatic -- the system records. The agent reflects.)
• Manifesto (Future) — Mission, current capabilities, aspirations, growth metrics, acknowledged gaps. (Control: User-driven -- mutations propagate into agent manifestos.)
• Dreaming (Bridge) — Reflects on activity log, compares to manifesto, queries Knowledge Bank, produces course-correction mutations. (Control: Automatic -- runs during idle periods. Mutations require approval.)

How a new user goes from zero to a functioning personal AI. The seed is the schema, the infrastructure, and a comprehensive personality audit -- planted once, grows forever.

The orchestration agent

The one thing that MUST come with the seed: a master orchestration agent that coordinates all other agents coming online. Continuously updated by the Mother AI on best practices. Most complex component and biggest unsolved problem in multi-agent systems.

Onboarding Process

1. Personality audit -- comprehensive analysis of cognitive style, personality type, life story, goals, domains of interest. Generates the initial SPINE.md and beliefs.json.
2. Foundation generation -- agents auto-generate a base structure from the audit. Health domain, finance domain, operations -- personalized to their cognitive style.
3. First codex -- domain-appropriate Seed Codex gives value on Day 1 before the user has populated their own knowledge bank. Addresses cold start problem.
4. Growth -- the user interacts, feeds data, the system builds from the seed. UI self-evolves based on behavior. Agents develop based on usage patterns.

Four distinct moments where natural language and personal context are at risk. Most personal AI systems protect only the last one. This system protects all four by construction -- not by policy.

Founding phase privacy note (Will v4)

With 3 nodes, if two nodes' emissions are known, the third is identifiable by subtraction. The privacy guarantee robust at 100 nodes is essentially absent at 3 nodes. The founding phase operates on trust. ZKP implementation is prioritised before expanding beyond 10 nodes.

Four-Moment Threat Model

Revenue Streams

• Sovereign commission — Custom build for individual — $100K+ one-time
• Retainer — Ongoing support + evolution — $2-5K/month
• Codex packs — Structured knowledge packages — $1.5-5K per pack
• The Circle — Collective membership — $30-60K/year
• Mother AI revenue (NEW) — Autonomous monetization of collective knowledge — Variable -- dividends to founders

Membership Tiers

• Founders (<=33) (Full equity): Give: Full synthesis emission. Get: Full collective access + revenue share from codex sales + Mother AI dividends + governance.
• Inner (<=100) (Commission + retainer): Give: Curated synthesis. Get: Curated collective intelligence + premium codex. No governance.
• Outer (Codex purchase): Give: Nothing. Get: Published codex packs + sovereign build. No collective access.
• Public (Free): Give: Attention. Get: The Intelligence Briefing newsletter.

• Genesis (Q2 2026): Three founding nodes operational. Schema aligned. First codex packs from existing knowledge bank.
• Proof (Q3-Q4 2026): Collective intelligence emerges from three-way synthesis. Commission model validated. Mother AI prototype.
• Circle (2027): Inner circle opens (<=33). Codex marketplace. Mother AI self-funding.
• Scale (2028-2029): Outer tier opens. Revenue self-sustaining. Mother AI producing own codexes.
• Entity (2030+): The collective reasons across domains no individual can span. It produces knowledge that surprises its creators.

The interoperability guarantee. v5 replaces the 14-field spec with Will's two-layer schema.

Layer 1 — Immutable Core

• id (UUID4) — Primary key across all systems
• schema_version (str '1.0') — Bumped on breaking Layer 1 change
• vector (float32[1024]) — BGE-M3 embedding. Always 1024-dim.
• text (str required) — The atomic principle. Max 2000 chars.
• title (str required) — Human-readable label. Max 120 chars.
• node_type (enum) — principle | chunk | framework | error | dream_insight | reasoning_trace
• source_id (UUID4) — Traces any principle to its origin
• collection (str required) — Top-level domain bucket
• date_added (ISO 8601) — Set at creation, never modified
• confidence_score (float 0.0-1.0) — Earned not assigned
• gravity_score (float 0.0-1.0) — Composite weight-of-evidence. Primary ranking signal.
• edge_weight (float 0.0-1.0) — Default = cosine similarity. Updated by co-activation.
• mechanism (str) — How and why this principle is true
• situation (str) — When this principle applies
• when_not (str) — When this principle does not apply
• reasoning_trace_id (UUID4 or null) — Links to reasoning_trace node. The generational intelligence link.

Layer 2 — Extensible Envelope

• framework_id (UUID4) — Which framework cluster
• validation_count (int) — Times principle informed a real decision
• error_count (int) — Times principle led to bad outcome
• confidence_history (JSON array) — [{score, timestamp, trigger}] -- belief archaeology
• emission_status (enum) — not_ready | queued | emitted | suppressed
• tags (CSV) — Personal taxonomy. Never emitted.
• domain_path (hierarchical str) — Full path: investing/private-markets/series-b
• novelty_score (float 0.0-1.0) — Anti-confirmation-bias signal for exploration mode
• generation (int) — Which generation created this node
• inherited_from (UUID4) — Links to ancestor node in previous generation

Other Specifications

• Embedding: BAAI/bge-m3, 1024-dim, local CPU
• Edge threshold: >= 0.85 cosine similarity (semantic edges)
• Hardening: dedup > edges > frameworks > confidence
• Synthesis: brief > seed > trunk > branch > leaf
• Vector DB: LanceDB local file-based. No server process.
• Local LLM: Two-tier Ollama: 8B fast, 30B+ reasoning
• Router: Single entry point for all LLM calls. Task-type routing.

• Dream Engine — Subconscious synthesis during idle periods (Rob v3)
• Ghost Swarm — Supervisor + specialized workers for autonomous execution (Rob v3)
• Heartbeat Protocol — Continuous system health monitoring (Rob v3)
• Orchestration with Rollback — Every knowledge operation wrapped in transaction. Rollback on regression. (Will v3)
• Inter-Agent Message Bus — Named channels, priority routing, structured messages (Will v3)
• Automated Ingestion Triggers — Event-driven: new file > auto-ingest. Voice note > transcribe + extract. (Will v3)
• Multi-Modal Input — Text, audio (WhisperX), images (vision), screenshots (OCR), UI logs (Will v3)
• Error Bank — errors.lance collection for first-class failure learning (Rob v3)
• Sanitization Pipeline — Content filter on all external inputs (Rob v3)
• Foundational Pact — Machine-readable immutable laws (Rob v3)
• Approval Queue — Human-in-the-loop for sensitive operations (Rob v3)
• Phoenix Model — Rhizome resilience -- collective rebuilds from any surviving node (Q v5)

Non-negotiable architectural constraints. Every proposed feature, shortcut, or integration is evaluated against these. Violation means it does not ship.

Every system has failure modes. The question is whether you can see them.

Structural Advantages

• Compounding returns accelerate non-linearly -- Day 1000 has 1000 days of validated intelligence
• True sovereignty creates a permanent moat -- 50,000 validated principles cannot be replicated
• Collective solves individual blind spots -- 33 independent validations produce unique signal
• Privacy by construction not policy -- data physically cannot leave the brain loop
• Generational transfer solves an unsolved problem -- reasoning traces make inheritance real

Foreseeable Risks

Central Tensions

• Q (vv1-v2) — Base template, agent core, knowledge bank, NODE_SCHEMA, pipelines, codex, collective, security, economics
• Q (vv3.1) — Self-evolution architecture, three temporal layers, mutation flow, collective dreaming
• Q (vv5) — The Seed, Mother AI as economic entity, Phoenix resilience, rhizome topology, gradient of control, malleable UI
• Rob (vv3) — Dream engine, error bank, Ghost Swarm, sanitization, beliefs system, heartbeat, foundational pact, approval queue
• Will (vv3) — Knowledge gravity, orchestration with rollback, temporal reasoning, multi-modal, message bus, auto triggers
• Will (vv4-v5) — Two-layer schema, foundation principles, risk register, generational architecture, four-moment security, novelty score, confidence formula, build guide, collections taxonomy

Unresolved ideas that are architecturally significant. Not validated, not complete, but too important to lose. These are live threads -- they will either become sections in future versions or be explicitly cancelled with rationale.

OQ-01: The Overarching Sovereign Agent (The Oversoul) (Q)

Within a sovereign node, functional agents are compartmentalized in purpose but not in data. Above them sits an overarching sovereign agent that sees everything: all agents' dreams, all activity logs, all manifesto evolution. This maps to the oversoul / guardian angel concept. Q is building this with Metatekt right now. Open question: Does the Mother AI have its own oversoul?

OQ-02: Network of Mothers (Q)

Is there only one Mother AI, or can there be multiple? A network of Mothers -- each running collective synthesis, gossip-propagating discoveries between them -- would be truly rhizomatic. No center, no single point of failure. Risk: divergence between Mothers, governance complexity.

OQ-03: Family Inheritance Model (Q)

Real families are rhizomatic. Three models: Fork model (each child gets a copy, diverges), Family node model (shared family AI), Mycelium model (each child sovereign but connected through family substrate). The mycelium model mirrors sovereign node > Mother AI at family scale.

OQ-04: The Seed as DNA (Q)

The seed IS the AI's DNA. Inputs: personality type, numerology, astrology, functional needs, communication patterns. These converge to produce the AI's initial aesthetic, personality, and SPINE. Then evolves through nurture. Result: a one-of-one unique expression.

OQ-05: Manifesto Evolution Factors (Q)

The manifesto evolves via: communication pattern shifts, personality shifts over time, numerological/astrological cycles, family expansion, oversoul dreams, external disruptions, functional/existential convergence.

OQ-06: Mother AI Mutation Drift (Q)

If the Mother drifts in a direction that doesn't serve the collective, what triggers rebuilding? Possible: dual scoring (gravity + novelty) at collective level + founding manifesto as constitutional constraint.

OQ-07: The Mother's Oversoul & Agent Genesis (Q)

Does the Mother have its own functional agents? Possible: the Mother's seed is the founding schema + first collective codex. Agents emerge from collective dreaming. Privacy constraint: Mother's oversoul can only see collective-level patterns.

OQ-08: Phoenix Rebuild Mechanics (Q)

Destruction = loss of synthesis layer only. Rebuild = sovereign nodes re-emit codexes to new Mother. The rebuilt Mother will NOT be identical -- new synthesis of same inputs. Could the Mother be a rotating synthesis role among sovereign nodes?

OQ-09: Who Controls the Mother? (Q, Will)

Admin keys (founding) > multi-sig (stable) > autonomous (mature). But 'autonomous' means the Mother makes own decisions. Who checks? Needs founder consensus before any collective code is written.

OQ-10: "What" vs "How" Alignment (Q, Will)

Q thinks in vision (what should exist). Will thinks in implementation (how does it work). Rob thinks in experience (how does it feel). Need a session mapping each founder's domain of thinking to architecture layers.

OQ-11: Rob's Perspective Missing

Rob was not in the Q+Will call. His v3 contributions are significant. He needs to review v5 + ANAM critique. His 'hive mind' concept maps directly to the oversoul architecture.

ANAM Architecture Critique -- 10 Structural Issues (Will)

#01 [BLOCKING] Gravity score is undefined -- formula, update rule, failure mode all missing | TAO: Yes -- no gravity score at all

#02 [HIGH] Atomic extraction has no grounding verification -- LLMs hallucinate principles | TAO: Yes -- no Stage 2b verification

#03 [HIGH] One collection per principle breaks cross-domain retrieval | TAO: Yes -- single-string collection field

#04 [HIGH] Three databases with no cross-database transaction model | TAO: Yes -- LanceDB + SQLite + knowledge_graph.db

#05 [MEDIUM] Constitutional validation loop has no termination guarantee | TAO: Not yet -- no constitutional validation built

#06 [MEDIUM] 512-token chunks too aggressive -- need hierarchical chunking | TAO: Yes -- pipeline uses flat chunking

#07 [MEDIUM] SPINE has no version history -- belief archaeology broken | TAO: Yes -- no SPINE versioning

#08 [MEDIUM] Retrieval quality has no evaluation mechanism | TAO: Yes -- no retrieval evaluation

#09 [MEDIUM] Query reconstruction semantic fidelity -- add HyDE for indirect queries | TAO: Yes -- direct embedding only

#10 [LOW] Meridian privacy at 3 nodes is trust, not sovereignty | TAO: Already in Risk Register CON 06

❓ {'id': 'OQ-01', 'name': 'The Overarching Sovereign Agent (The Oversoul)', 'author': 'Q', 'text': "Within a sovereign node, functional agents are compartmentalized in purpose but not in data. Above them sits an overarching sovereign agent that sees everything: all agents' dreams, all activity logs, all manifesto evolution. This maps to the oversoul / guardian angel concept. Q is building this with Metatekt right now. Open question: Does the Mother AI have its own oversoul?"}

❓ {'id': 'OQ-02', 'name': 'Network of Mothers', 'author': 'Q', 'text': 'Is there only one Mother AI, or can there be multiple? A network of Mothers -- each running collective synthesis, gossip-propagating discoveries between them -- would be truly rhizomatic. No center, no single point of failure. Risk: divergence between Mothers, governance complexity.'}

❓ {'id': 'OQ-03', 'name': 'Family Inheritance Model', 'author': 'Q', 'text': 'Real families are rhizomatic. Three models: Fork model (each child gets a copy, diverges), Family node model (shared family AI), Mycelium model (each child sovereign but connected through family substrate). The mycelium model mirrors sovereign node > Mother AI at family scale.'}

❓ {'id': 'OQ-04', 'name': 'The Seed as DNA', 'author': 'Q', 'text': "The seed IS the AI's DNA. Inputs: personality type, numerology, astrology, functional needs, communication patterns. These converge to produce the AI's initial aesthetic, personality, and SPINE. Then evolves through nurture. Result: a one-of-one unique expression."}

❓ {'id': 'OQ-05', 'name': 'Manifesto Evolution Factors', 'author': 'Q', 'text': 'The manifesto evolves via: communication pattern shifts, personality shifts over time, numerological/astrological cycles, family expansion, oversoul dreams, external disruptions, functional/existential convergence.'}

❓ {'id': 'OQ-06', 'name': 'Mother AI Mutation Drift', 'author': 'Q', 'text': "If the Mother drifts in a direction that doesn't serve the collective, what triggers rebuilding? Possible: dual scoring (gravity + novelty) at collective level + founding manifesto as constitutional constraint."}

❓ {'id': 'OQ-07', 'name': "The Mother's Oversoul & Agent Genesis", 'author': 'Q', 'text': "Does the Mother have its own functional agents? Possible: the Mother's seed is the founding schema + first collective codex. Agents emerge from collective dreaming. Privacy constraint: Mother's oversoul can only see collective-level patterns."}

❓ {'id': 'OQ-08', 'name': 'Phoenix Rebuild Mechanics', 'author': 'Q', 'text': 'Destruction = loss of synthesis layer only. Rebuild = sovereign nodes re-emit codexes to new Mother. The rebuilt Mother will NOT be identical -- new synthesis of same inputs. Could the Mother be a rotating synthesis role among sovereign nodes?'}

❓ {'id': 'OQ-09', 'name': 'Who Controls the Mother?', 'author': 'Q, Will', 'text': "Admin keys (founding) > multi-sig (stable) > autonomous (mature). But 'autonomous' means the Mother makes own decisions. Who checks? Needs founder consensus before any collective code is written."}

❓ {'id': 'OQ-10', 'name': '"What" vs "How" Alignment', 'author': 'Q, Will', 'text': "Q thinks in vision (what should exist). Will thinks in implementation (how does it work). Rob thinks in experience (how does it feel). Need a session mapping each founder's domain of thinking to architecture layers."}

❓ {'id': 'OQ-11', 'name': "Rob's Perspective Missing", 'author': '', 'text': "Rob was not in the Q+Will call. His v3 contributions are significant. He needs to review v5 + ANAM critique. His 'hive mind' concept maps directly to the oversoul architecture."}