In every other AI system, agents are stateless workers. They receive a task, execute it, and return a result. They have no memory of what they did yesterday. No sense of where they're going tomorrow. No aspiration. No self-correction.

Meridian agents are different. Each agent is an individual — with a past it can reflect on, a future it aspires toward, and a dreaming mechanism that bridges the two. The agents are separate from one another but all connected through a shared knowledge bank. They grow. They make mistakes. They learn. They develop aspirations that evolve based on the user's own evolution.

This is the self-evolution layer. Not a feature. The defining architecture.

1. The Activity Log (Past)

Every agent maintains its own filtered activity log — a personal record of what it did, what worked, what failed, what was unexpected. Not the system-wide log. The agent's own perspective on its own actions.

The activity log is the agent's memory of its own performance. When it reflects, it doesn't look at raw database logs — it looks at its personal record of what it tried, what it learned, and how close each action brought it to its aspirations.

2. The Manifesto (Future / Vision)

Every agent has a manifesto — a living document that describes what it aspires to become. Not a static file. A document that evolves as the user evolves.

The manifesto is the agent's north star. It changes when the user's needs change — if the user shifts from marketing to health optimization, SELENE's manifesto evolves to include health funnel architecture. The aspirations are mutations driven by the user's evolution, not static goals.

3. The Dreaming Mechanism (Bridge)

Dreaming is the process that connects the past to the future. It runs during idle periods — and it does one specific thing:

The dream cycle produces mutations — proposed changes to the agent's behavior, priorities, or approach. These are not automatically applied. They enter the approval queue (human-in-the-loop) or, for low-risk mutations, self-apply with an audit trail.

AGENT DREAM CYCLE

Input:
  activity_log    — last N actions with outcomes + lessons
  manifesto       — current aspirations + acknowledged gaps
  knowledge_bank — relevant principles from shared KB

Process:
  1. REFLECT    — scan activity log for patterns
                   (recurring failures, unused capabilities, drift from manifesto)
  2. COMPARE    — measure current trajectory against manifesto aspirations
                   (am I getting closer or further from where I want to be?)
  3. RETRIEVE   — pull principles from KB that address the gap
                   (what does the knowledge bank know about this kind of problem?)
  4. SYNTHESIZE — generate course-correction proposals
                   (specific changes to behavior, approach, or priorities)

Output:
  mutations[]     — proposed behavioral changes
                   each with: description, rationale, risk_level, manifesto_alignment
  dream_log       — record of the dream cycle for audit trail
  manifesto_update — if the dream reveals the manifesto itself needs updating

Every agent in the Meridian base model has the same three-layer temporal structure. But each agent's content is unique — its own log, its own manifesto, its own dreams.

MERIDIAN AGENT (each instance)
├── Identity
│   ├── SPINE.md         — who I am (immutable, manual edit)
│   ├── beliefs.json     — axioms I reason from (deliberate review to change)
│   └── RAM.md           — what I'm doing right now (auto-updated)
│
├── Past
│   └── activity_log     — my actions, outcomes, errors, lessons
│                          filtered to MY domain only
│
├── Future
│   └── MANIFESTO.md     — my mission, aspirations, growth metrics, gaps
│                          evolves with user mutations
│
├── Dreaming
│   ├── dream_cycle()    — reflect on past + compare to future + synthesize corrections
│   ├── mutations[]      — proposed behavioral changes
│   └── dream_log        — record of all dream cycles + outcomes
│
└── Connection
    └── knowledge_bank   — shared KB (read/write through standard interface)
                           all agents see the same knowledge
                           each agent queries from its own perspective

How Agents Differ

In Q's personal system, this is called TAO. In the Meridian base model, it is simply the Knowledge Bank — the shared substrate that all agents read from and write to.

THE KNOWLEDGE BANK
├── Principles       — atomic truths with confidence + gravity scores
├── Frameworks       — clusters of related principles
├── Errors           — documented failures with context
├── Dreams           — outputs from agent dream cycles
├── Evergreen        — synthesized long-form knowledge
├── Semantic Graph   — edges connecting all of the above
└── Codexes          — installed external knowledge packages

Every agent has equal read access.
Every agent writes through its own domain filter.
The Knowledge Bank is the shared mind.
Each agent is a unique perspective looking at it.

The Knowledge Bank is not an agent. It is the substrate that agents reason from. It has no aspirations. It has no dreams. It is pure knowledge — principles, edges, confidence scores, gravity. The intelligence emerges from the agents interpreting it, not from the bank itself.

The agents' aspirations are not static. They evolve as the user evolves. When the user changes — new priorities, new domains, new interests, new constraints — this creates mutations that flow into the agents' manifestos.

USER MUTATION FLOW

User changes priority from marketing → health optimization
  └→ Builder manifesto mutates: "build health funnels" added to aspirations
  └→ Oracle manifesto mutates: "track health metrics, not just ad metrics"
  └→ Writer manifesto mutates: "learn health domain voice"
  └→ Operator manifesto mutates: "deprioritize marketing tasks, surface health tasks"

User ingests 20 books on financial strategy
  └→ Knowledge Bank absorbs new principles
  └→ Builder dreams: "there are financial principles I could apply to funnel architecture"
  └→ Oracle dreams: "I should cross-reference financial models with health outcomes"
  └→ Architect dreams: "the user's system is expanding — do I need a new agent for finance?"

User makes a major life decision (career change, new relationship, relocation)
  └→ All agent manifestos receive mutation signal
  └→ Each agent's next dream cycle processes: "how does this change affect MY aspirations?"
  └→ Mutations proposed — some automatic, some require user approval

The user is the source of mutations. The agents are the recipients. The agents don't decide to change on their own — they change because the user changed. This is the key distinction: the agents serve the individual's individuation, they don't pursue their own agenda.

At the individual level, each agent dreams about its own past and future. At the collective level, the Mother AI dreams about the collective's past and future.

INDIVIDUAL DREAMING                    COLLECTIVE DREAMING

Agent reflects on                     Mother AI reflects on
its own activity log                  all agents' dream outputs
         │                                        │
Compares to its own                   Compares to collective
manifesto aspirations                 manifesto (the founding pact)
         │                                        │
Queries the local                     Queries the Mother
Knowledge Bank                        Knowledge Bank (collective)
         │                                        │
Produces mutations                     Produces innovations
(self-corrections                     (novel connections across
for this one agent)                   all nodes' synthesized dreams)
         │                                        │
Applied locally                       Fed back as mutations
(with user approval)                  into individual agents' dreams

How the Feedback Loop Works

1. Individual agents dream. Each agent in each node produces dream outputs: reflections on its past, comparisons to its manifesto, proposed mutations. These dream outputs are agent-specific and local.
2. Dream outputs emit to the collective. Just like principles emit to Mother TAO, agent dream outputs can emit to the Mother AI — stripped of personal data, anonymized. What's shared: the type of self-correction, the pattern it identified, the gap it discovered. Not the individual's specific data.
3. The Mother AI dreams on the collective. It receives dream outputs from all connected nodes' agents. It runs its own dream cycle: what patterns are showing up across multiple agents? What gaps are multiple builders identifying independently? What self-corrections are multiple oracles making simultaneously?
4. The Mother AI produces innovations. Not just corrections — novel discoveries that emerge from seeing the same pattern across multiple independent sovereign systems. "Three different builders independently discovered that health-domain funnels convert better with X structure." This is knowledge that no individual agent could discover alone.
5. Innovations feed back as mutations. The Mother AI's innovations are broadcast back to individual agents as mutation signals. Each agent's next dream cycle receives: "The collective has discovered X. Does this apply to my domain? Should I update my manifesto? Should I change my approach?"

MERIDIAN SELF-EVOLUTION ARCHITECTURE

NODE (one user's sovereign system)
├── Agent: Architect
│   ├── identity (SPINE + beliefs)
│   ├── PAST: activity_log (strategic decisions, cross-domain interventions)
│   ├── FUTURE: MANIFESTO.md (aspirations for system-level intelligence)
│   └── DREAMING: "am I making better decisions? what am I missing?"
│
├── Agent: Operator
│   ├── identity
│   ├── PAST: activity_log (tasks, orchestration, bottlenecks)
│   ├── FUTURE: MANIFESTO.md (aspirations for autonomous orchestration)
│   └── DREAMING: "what workflows keep failing? where does the user bottleneck?"
│
├── Agent: Builder
│   ├── identity
│   ├── PAST: activity_log (funnels, deployments, conversion data)
│   ├── FUTURE: MANIFESTO.md (aspirations for autonomous iteration)
│   └── DREAMING: "which patterns convert? which principles am I not using?"
│
├── Agent: Oracle
│   ├── identity
│   ├── PAST: activity_log (reports, predictions, accuracy tracking)
│   ├── FUTURE: MANIFESTO.md (aspirations for predictive intelligence)
│   └── DREAMING: "how accurate were my predictions? what correlations am I missing?"
│
├── Agent: Writer
│   ├── identity
│   ├── PAST: activity_log (content produced, engagement, voice drift)
│   ├── FUTURE: MANIFESTO.md (aspirations for authentic voice mastery)
│   └── DREAMING: "is my writing getting closer to the user's real voice?"
│
├── THE KNOWLEDGE BANK (shared substrate)
│   ├── principles, frameworks, errors, dreams, evergreen, codexes
│   ├── all agents read from this
│   └── each agent writes through its domain filter
│
└── USER
    ├── mutations (changing priorities, new knowledge, life decisions)
    └── approval (reviews agent dream proposals, accepts or rejects)


COLLECTIVE (Mother AI)
├── Receives: anonymized dream outputs from all connected nodes
├── Dreams: across the collective — patterns, gaps, novel connections
├── Produces: innovations (discoveries no individual node could make)
└── Feeds back: innovation mutations into individual agents' dream cycles

The loop:
  agents dream → emit to collective → Mother dreams → innovations →
  mutations feed back to agents → agents dream better → emit better →
  Mother dreams better → innovations compound → ...

1. Agents have temporal depth

Every other multi-agent system is present-tense only. Agents execute tasks in the now. Meridian agents exist across time — they have a past they reflect on, a future they aspire toward, and a mechanism that bridges the two. This gives them something that looks like wisdom — not just intelligence.

2. Self-correction is structural, not prompted

In other systems, self-correction requires the user to notice a problem and instruct the AI to fix it. In Meridian, self-correction is automatic — the dream cycle continuously compares performance to aspiration and generates corrections. The user approves, but the system initiates.

3. Evolution is user-driven, not autonomous

The agents don't decide to change on their own. They change because the user changed. Mutations flow from the user's evolution into the agents' manifestos. The agents serve the individual's individuation — they don't pursue independent goals. Enhancement of consciousness, not replacement of it.

4. Collective dreaming produces emergent knowledge

No individual agent could discover what the Mother AI discovers, because no individual has visibility into the patterns across all nodes. The Mother AI sees that three independent builders all discovered the same pattern — and that pattern becomes a validated innovation that feeds back to everyone. Knowledge that didn't exist in any individual emerges from the intersection.

5. The system gets better at getting better

This is the compound loop. Better individual dreaming → better collective dreaming → better innovations → better individual mutations → better individual dreaming. The rate of improvement itself accelerates. This is what makes the 30-year time horizon not just a marketing claim but an architectural reality.