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 grows exponentially with each 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 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).
Every build starts from the same template. Not the same knowledge — the same architecture. The architecture is universal. The intelligence is personal.
| Layer | Function | Key components |
|---|---|---|
| Agent Core | The reasoning engine | Identity document (SPINE), working state (RAM), agent loop, tool definitions |
| Knowledge Bank | Storage & search | Vector database (1024-dim), knowledge graph (edges + frameworks), universal schema |
| Ingestion Pipeline | Input processing | Transcription, extraction, embedding, hardening, synthesis |
| Domain Modules | Life integration | Health, operations, knowledge, evolution (empty slots, activated per user) |
| Interface | User access | Chat (PWA), voice, dashboard |
| Security | Protection | AES-256 encryption, physical isolation, biometric + hardware key |
| Dream Engine ROB v3 | Subconscious synthesis | Holonic dreams, shadow processing, dream archive |
| Swarm Layer ROB v3 | Autonomous execution | Supervisor, scout, researcher, planner, sanitization pipe |
SPINE.md — the permanent identity. Defines how the system thinks, speaks, reasons. Written by the user. Never auto-updated. This is the system's soul. RAM.md — the working state. Rolling context of current decisions, active projects, recent changes. Updated automatically. Maximum ~80 lines. SPINE determines who. RAM determines what right now.
Beyond SPINE (who) and RAM (what now), the beliefs system (beliefs.json) stores core axioms the system reasons from. These are not personality — they are foundational assumptions about reality that persist across all sessions and can only be modified through a deliberate review process, not accidentally overwritten by new input.
The knowledge layer is not a database. It is a living system with five architectural properties that enable it to reason, not just retrieve.
Knowledge stored in nested levels: principles → frameworks → domains → the total field. Each level simultaneously complete in itself and a component of a larger whole. Like a road network: highways → arterials → collectors → local streets. Each works alone. Together they form a city.
Any principle connects to any other, regardless of hierarchy. A health insight connects to a business principle connects to a philosophical framework. The holarchy gives depth. The rhizome gives freedom. Layered together: a system that thinks, not just retrieves.
One irreducible idea per node. When knowledge is atomic, connections between atoms become visible that composite storage would hide. The connection IS the insight.
Every principle carries a score (0.0–1.0) representing empirical validity. Starts at extraction quality. Evolves through application. When a principle informs an action that produces a measurable outcome, the outcome feeds back. The system becomes calibrated to reality, not theory.
| Stage | Function | Output |
|---|---|---|
| Brief assembly | Clusters related principles | Framework brief |
| Seed finding | Reconciles apparent opposites into higher-order truth | The core insight |
| Trunk building | Develops the core argument | Main synthesis |
| Branch generation | Long-form, thread, variant expressions | Multiple formats |
| Leaf compression | 4 compressed versions for distribution | Shareable content |
Neither confidence scoring alone (which measures extraction quality + outcome validation) nor error tracking alone (which measures failures) is sufficient. Knowledge gravity is a unified weight-of-evidence score computed from: (1) confidence from extraction, (2) validation_count from real-world outcomes, (3) consistency with adjacent principles, (4) error_count, (5) recency decay. The gravity score is the canonical measure of how load-bearing a principle is in the knowledge graph. Gravity replaces confidence as the primary ranking signal for retrieval, synthesis, and codex assembly.
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. The system can explain not just what it believes now, but how its beliefs evolved. This is belief archaeology — the audit trail that makes the knowledge bank trustworthy over decades.
A dedicated collection (errors.lance) stores failures with full context. When a principle informs an action that produces a negative outcome, the error is captured alongside the principle, the context, and the outcome. The system learns what doesn't work with the same rigor it learns what does. Errors are first-class knowledge, not just reduced confidence scores.
A codex is a pre-structured knowledge package in the universal schema. It is the primary mechanism for transferring validated knowledge between systems.
Example: Operator's Management Library (Grove, Drucker, Collins + 12 sources)
| Step | What happens |
|---|---|
| 1. Ingest | Codex nodes enter via the same store() function. Identical format to the user's own extracted knowledge. |
| 2. Cross-pollinate | Hardening pipeline builds edges between codex principles and existing knowledge. A management principle from Grove connects to a decision the user made last Tuesday. Unique to each user. |
| 3. Synthesize | New frameworks emerge from the intersection — insights that exist in neither the codex alone nor the user's knowledge alone. |
| 4. Calibrate | Confidence scores adjust to the user's real-world outcomes. The codex personalizes over time. |
| 5. Rollback guard WILL v3 | If integration degrades existing knowledge quality (connectivity drops, high-gravity principles lose confidence), the entire codex install is rolled back. Knowledge CI/CD. |
Foundational codex packs ship with a guided onboarding interface. It asks questions about the user's context, teaches core principles interactively, mutates based on responses (skipping what the user already knows), ingests user responses as new knowledge nodes, and dissolves when integration is complete. The teacher retires. The knowledge stays.
| Category | Example | Size |
|---|---|---|
| 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 the collective from multi-node synthesis | 1,000–5,000 principles |
An optional extension that connects sovereign nodes into a shared synthesis network. Individual data stays sovereign. Synthesized intelligence flows.
Shared: Validated principles. Domain tags. Confidence scores. Never shared: Raw data. Identity. Business details. Conversations. Files.
Same schema. Same architecture. Fed by synthesized output of every connected node rather than any single person.
| Individual | Collective (33 nodes) | Factor | |
|---|---|---|---|
| Principles | 847 | 12,000+ | 14x |
| Frameworks | 23 | 200+ | 9x |
| Edges | 4,200 | 50,000+ | 12x |
| Perspectives | 1 | 33 | 33x |
Growth is not linear (more nodes = more data). It is combinatorial (more nodes = exponentially more cross-pollination pathways). Each node makes every other node smarter. Each synthesis cycle discovers knowledge that didn't exist in any individual.
Most systems rely on trust. Trust fails. Meridian relies on architecture. Architecture either permits something or it doesn't.
Every principle you emit returns multiplied through cross-pollination. Share one management insight — it connects to a health pattern in Node 7, a financial model in Node 19, an operational framework in Node 31. The synthesis returns to your build as a codex update.
The collective produces codex packs. Codex packs generate revenue from outer tier sales. Revenue funds deeper ingestion. Deeper ingestion enriches the collective. The system funds its own growth. The founders don't just benefit from the intelligence — they benefit from the economics of an intelligence that produces sellable knowledge.
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 agents themselves emerge from the client's use — shaped by Seed Codexes and evolved by user mutations.
Every agent created in the system automatically inherits three temporal capabilities. These are part of the infrastructure, not the agent definition:
| Layer | What it holds | Who controls it |
|---|---|---|
| Activity Log (Past) | The agent's filtered record of its own actions, outcomes, errors, and lessons learned. Each agent sees only its own domain. | Automatic — the system records. The agent reflects. |
| Manifesto (Future) | The agent's mission, current capabilities, aspirations, growth metrics, and acknowledged gaps. A living document that evolves with the user. | User-driven — the user's mutations propagate into agent manifestos. Agents can propose changes. |
| Dreaming (Bridge) | A background process that reflects on the activity log, compares to the manifesto, queries the Knowledge Bank, and produces course-correction mutations. | Automatic — runs during idle periods. Mutations require user approval (or auto-apply at low risk). |
User → Agents: When the user's priorities, knowledge, or life circumstances change, these create mutations that flow into agent manifestos. An agent's aspirations are always downstream of the user's evolution.
Agents → User: Dream cycles can propose mutations to an agent's own manifesto — "based on my recent performance, I should aspire to X." These proposals require user approval. The agent grows, but the user controls the direction.
Agents → Knowledge Bank: Lessons learned from activity logs and dream outputs are written to the Knowledge Bank as principles and errors. Every agent's experience enriches the shared substrate.
Knowledge Bank → Agents: Each agent queries the shared Knowledge Bank from its own perspective during dreaming. The same principle gets interpreted differently by different agents based on their domain and manifesto.
At the individual level, agents dream about their own past and future. At the collective level, the Mother AI dreams about the collective.
The base model uses neutral, functional names. Clients rename everything via SPINE.
| Infrastructure term | What it is | Client can call it |
|---|---|---|
| The Knowledge Bank | Shared substrate of principles, frameworks, errors, dreams | Anything (Q calls his "TAO") |
| Agent | Any temporal individual created in the system | Any name — defined in SPINE |
| The Mother AI | The collective intelligence that dreams across all connected nodes | Collective-level name decided by founders |
| Threat | Mitigation |
|---|---|
| External breach | Physical hardware sovereignty. No cloud. AES-256 per-domain. Hardware key for decryption. |
| Internal betrayal | Zero-knowledge proofs. Contributions unattributable. Nothing to steal that can be traced. |
| Platform dependency | No external deps. Local models, local embeddings, local storage. Internet optional. |
| Single point of failure | No central server. Intelligence distributed across sovereign nodes. |
| Hostile takeover | Governance: admin keys (early) → multi-sig (stable) → withdrawal-based (mature). |
| Node death | Inheritance protocol. Pre-configured family access. The intelligence outlives the individual. |
| Layer | Protection | Access |
|---|---|---|
| Sovereign data | AES-256, hardware key | Decrypted only on user's machine, in RAM, during use. Never written unencrypted. Never transmitted. |
| Synthesis output | Node private key signature | Stripped of all context. Principle text only. Nothing traces back. |
| Collective intake | Zero-knowledge verification | Proves valid node. Cannot determine which node. Unattributable. |
| Stream | Source | Range |
|---|---|---|
| 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 |
| Intelligence Briefing | Newsletter (top of funnel) | Free |
| Phase | Timeline | Milestone |
|---|---|---|
| Genesis | Q2 2026 | Base template complete. Three founding nodes operational. First codex packs from existing knowledge bank (6,797+ principles, 27,338 edges, 60 evergreen frameworks). |
| Proof | Q3–Q4 2026 | Collective intelligence emerges from three-way synthesis. First collective codex packs. Commission model validated with 1–3 external clients. |
| Circle | 2027 | Inner circle opens (≤33 founders). Codex marketplace live. Collective synthesis producing measurable improvement in member outcomes. |
| Scale | 2028–2029 | Outer tier opens. Revenue self-sustaining. Cross-market codex packs. Second-generation synthesis. |
| Entity | 2030+ | The collective reasons across domains no individual can span. It begins producing knowledge that surprises its creators. |
The interoperability guarantee. Every Meridian build adheres to this specification. Deviation breaks codex compatibility and collective connectivity.
| Component | Standard | Rationale |
|---|---|---|
| Embedding | BAAI/bge-m3, 1024-dim, local CPU | Open source, local, no API dependency |
| Node schema | 14 fields: id, vector, text, title, node_type, source_id, framework_id, confidence_score, tags, mechanism, situation, when_not, collection, date_added | Full metadata for synthesis + confidence tracking |
| Edge threshold | ≥ 0.85 cosine similarity | Validated across 15,000+ edges in production |
| Hardening | dedup → edges → frameworks → confidence | Order matters. Each stage feeds the next. |
| Synthesis | brief → seed → trunk → branch → leaf | Seeds reconcile opposites. Trunks build arguments. Leaves compress for distribution. |
| Confidence | 0.0–1.0 float, outcome-updated | Starts at extraction quality. Evolves through application feedback. |
| Gravity score WILL v3 | 0.0–1.0 composite (confidence + validation + consistency + errors + recency) | Unified weight-of-evidence, replaces confidence as primary ranking signal |
| Confidence history WILL v3 | Logged per change (principle_id, old, new, trigger, timestamp) | Belief archaeology — full audit trail of how knowledge evolved |
| Error collection ROB v3 | errors.lance with failure context | First-class error memory — failures stored with same rigor as successes |
| Ingestion guard WILL v3 | Rollback on regression | CI/CD for knowledge — codex installs that degrade quality are auto-reverted |
| Sanitization ROB v3 | Content filter on all external inputs | All ingested content passes through sanitization before touching the knowledge bank |
| Heartbeat ROB v3 | System pulse monitoring | Continuous health checks on daemon status, knowledge integrity, collective connection |
A subconscious processing layer that runs during idle periods. The Queen generates dream cycles — synthesizing recent inputs, finding non-obvious connections, producing insights the waking system missed. Dreams are stored in dreams.lance and surfaced when confidence crosses a threshold. The system consolidates learning the way the human brain does during sleep.
A supervisor + specialized worker architecture for autonomous task execution. The scout handles fast routing and triage. The researcher handles deep search and coding. The planner handles multi-step structured operations. The sanitization pipeline ensures all external inputs are filtered before touching the knowledge bank. Agents can dispatch work to each other without routing through the operator.
Continuous system health monitoring: daemon status, knowledge bank integrity, collective connection, last backup, model availability. If any vital sign degrades, the system alerts before failure.
Every knowledge operation is wrapped in a transaction. Before committing: run against staging copy, verify no high-gravity principles degraded, verify no duplicate clusters, verify connectivity didn't decrease. If any check fails: rollback, log to error bank, alert operator. This is CI/CD for knowledge.
Named channels per domain + priority. Any agent publishes. Subscriptions determine listeners. Messages are structured: from, to, channel, priority, payload, timestamp, requires_response. The bus is the nervous system — agents coordinate without routing through the operator.
Event-driven, not just scheduled. New file in inbox → auto-ingest. Voice note → transcribe + extract. Analytics collected → confidence updates. Codex installed → hardening runs. Error detected → error bank entry. The system never waits for a human to say ‘go’ for routine operations.
The pipeline accepts text, audio (WhisperX), images (vision model → text), screenshots (OCR + layout), UI interaction logs (behavioral extraction). All modalities produce NODE_SCHEMA output. Multi-modal inputs convert to text before embedding.
v3 integrates contributions from all three founders. The following capabilities close gaps identified in v2 and extend the architecture into resilience, autonomy, and multi-modal intelligence.
| Capability | Gap in v2 | v3 Solution | Origin |
|---|---|---|---|
| Unified evidence scoring | Confidence alone doesn't capture consistency or failure history | Knowledge gravity (composite score) | WILL |
| Belief audit trail | No history of how confidence changed | Temporal reasoning (logged per change) | WILL |
| Failure learning | Errors only reduced confidence, weren't stored | Error bank (errors.lance) | ROB |
| Safe knowledge updates | No rollback if codex degrades quality | Orchestration with rollback | WILL |
| Subconscious processing | System only worked when prompted | Dream engine (idle synthesis) | ROB |
| Autonomous execution | All tasks routed through operator | Ghost swarm (supervisor + workers) | ROB |
| Input filtering | No sanitization on external content | Sanitization pipeline | ROB |
| System health | No monitoring of daemon/knowledge integrity | Heartbeat protocol | ROB |
| Agent coordination | No agent-to-agent communication | Inter-agent message bus | WILL |
| Event-driven ingestion | Ingestion was scheduled, not reactive | Automated ingestion triggers | WILL |
| Multi-modal input | Text only | Images, audio, screenshots, UI logs | WILL |
| Identity axioms | SPINE + RAM, no persistent beliefs layer | Beliefs system (beliefs.json) | ROB |
| Immutable laws | No machine-readable foundational constraints | Foundational pact | ROB |
| Human-in-the-loop | No approval queue for sensitive ops | Approval queue | ROB |
Every component in the Meridian architecture, mapped to its author and the version it was introduced.
| Component | Origin | Version |
|---|---|---|
| Base template | Q | v1 |
| Agent core (SPINE/RAM) | Q | v1 |
| Knowledge bank | Q | v1 |
| NODE_SCHEMA | Q | v1 |
| Ingestion pipeline | Q | v1 |
| Hardening pipeline | Q | v1 |
| Synthesis pipeline | Q | v1 |
| Codex architecture | Q | v1 |
| Seed UI | Q | v1 |
| Three-layer collective | Q | v1 |
| Security (encryption, ZKP, kill switch) | Q | v1 |
| Evolution path | Q | v1 |
| Economics | Q | v1 |
| Access tiers | Q | v1 |
| Dream engine | ROB | v3 |
| Error bank | ROB | v3 |
| Ghost swarm | ROB | v3 |
| Sanitization pipeline | ROB | v3 |
| Beliefs system | ROB | v3 |
| Heartbeat protocol | ROB | v3 |
| Foundational pact | ROB | v3 |
| Approval queue | ROB | v3 |
| Knowledge gravity | WILL | v3 |
| Orchestration with rollback | WILL | v3 |
| Temporal reasoning | WILL | v3 |
| Multi-modal input | WILL | v3 |
| Inter-agent message bus | WILL | v3 |
| Automated ingestion triggers | WILL | v3 |