Keep our memory stack. Do not install agentsmemory.

🔴 The decision (top priority)

Why, in one honest paragraph. As a central notebook that many AI agents read and write at the same time, MPRO's engine sits on Postgres - a database built for many writers at once (called MVCC: everyone can write together without stepping on each other) - plus a fast approximate vector search (HNSW) and a live change-broadcast bus (pg_notify). agentsmemory's durable store is a single SQLite file with no "wait-your-turn" setting configured, and its own code comments admit its locks do not coordinate across copies - so the exact thing it is designed for (many agents, many server copies) meets a single-file write bottleneck. So the foundation is ours to keep. Ours was "broken" only by a few hours of configuration drift (see the Live hard-proof tab); theirs is an unproven early skeleton whose concurrency limit is baked into the architecture. [multiagent lens; head-to-head lens]

The two designs, side by side

When would a SWAP actually win?

To be fair to their design: a swap to their self-hosted server would win ONLY if all five of these became true - and none is true today:

1. MPRO must serve multiple untrusted tenants (external customers, not one company) - so their per-team physical vault earns its keep.
2. We accept AGPL-3.0 network-copyleft on an externally-exposed service.
3. We accept standing up + operating Qdrant + Ollama bge-m3 + a Go service as new infrastructure.
4. agentsmemory proves stable under many concurrent agents (needs WAL + database advisory locks + a stress test - unproven, 0 production users).
5. We accept losing MVCC concurrency, the pg_notify realtime bus, HNSW-by-default, session lifecycle, and decay - features theirs simply does not have.

Until those flip, (A) is the grounded call. The one idea worth banking from a swap for the far future is their bearer-token + stateless-HTTP tenant boundary - adopt it only IF/WHEN MPRO ever exposes memory to untrusted external tenants across machines. That is a business decision for later, not a technical one for now. [multiagent lens - recommendation section]

🛡️ The live hard-proof - ours was silently broken, then fixed (don't trust paper)

1. BEFORE - the probe caught it red-handed

Source of truth: live-proof.json (a real read-only probe of the live DB this session).

2. THE FIX - commit 23cdd44ba

• Re-aligned the agent_memory.embedding column to vector(768) to match the live model.
• Applied the value_tsv tsvector migration (the keyword arm) + its GIN index.
• Re-embedded all rows -> 14 / 14 now carry a vector.
• Adopted their normalized fusion as part of the same fix: each arm scaled to a common range before the weighted blend, so keywords actually compete with meaning (their rank.go lesson - see the Full comparison tab).

3. AFTER - proven working, both arms firing

Source of truth: live-proof-after.json.

recalled_key : ollama-bridge-returns-canned-greeting
vector_sim   : 0.675   (meaning match - the semantic arm)
bm25         : 0.0317  (keyword match - the lexical arm)
similarity   : 1.000   (normalized fused score = top rank)
BOTH_ARMS_FIRED: true

Why this matters more than any table below

The comparison tabs weigh two designs. This tab proves the harder point: a beautiful design that is mis-configured is worse than a plain one that runs. Ours was the mis-configured one - now it is the running one. Verify it yourself:

python3 -c "import json;d=json.load(open('/home/darius/MPRO/docs/agentsmemory-eval/live-proof-after.json'));print('cols',d['embedding_coltype'],'| tsv',d['has_tsvector'],'| embedded',d['rows']['emb'],'/',d['rows']['n'],'| both arms',d['hybrid_proof']['BOTH_ARMS_FIRED'])"
# -> cols vector(768) | tsv True | embedded 14 / 14 | both arms True

⚖️ Whole-capability comparison - honest both ways

Every row is grounded in a real function body read on both sides (satya / validate-body-not-title). The "winner" column is called plainly, with the reason. Legend: theirs agentsmemory stronger · ours MPRO stronger · tie / neither.

👀 What you (the CEO) most likely did NOT know

Plain-language, one risk per card. These are the things that change the decision.

🧠 The exciting part - what the sleeping brain does, and what NEITHER tool copies

The five brain mechanisms (each cited to a real paper)

The AI bridge is not new: reinforcement-learning "experience replay" is a literal copy of hippocampal replay (Mnih et al. 2015, Nature - DQN), and Generative Agents (Park et al. 2023, UIST) already score memories by recency × importance × relevance and periodically write higher-level reflections back - a software echo of tagging + gist.

The cognitive-tier map - both tools, five brain functions

The brain-inspired MPRO roadmap (ranked, all pure-JS on our stack)

No Qdrant, no new service, no data migration - Postgres + pgvector + Ollama, using columns we already have.

Caveat (satya): the "sleep-inspired LLM memory" arXiv preprint (2603.14517) was seen in this turn's search listing only - a pointer, not a validated result. The five brain mechanisms above are each cited to a seminal paper AND a current review.

🌟 Part 4 - Can the KB @ 3001 be our long-term brain? YES - it already IS it.

The three brain tiers are not something we need to build - they map onto three MPRO objects we already run. [grounded in SYSREF-004 (Knowledge Base) + SYSREF-001 (Mastermind)]

The KB is more neocortex-like than a plain search box: it is a full RAG stack - a reranker (Ollama cross-encoder) + a CRAG confidence-grader + a HyDE query-expander + a 5-guard hallucination check + graph-community associations. And the load-bearing detail: the KB and agent_memory embed through the SAME RAGGateway (nomic-embed-text), so promoting a memory from Tier-2 to Tier-3 needs no re-embed - rock-solid now the 384->768 dimension fix has landed. Mastermind is the brain's salience filter: only confirmed, generalizable knowledge crystallizes into the KB; raw daily episodics stay in agent_memory or decay away.

🧠 Part 5 - the memory CIRCUIT MPRO already has (write-wire reconnected)

Put together, these three tiers form a real brain circuit - and the write-wire between them was cut since the Windows->Linux migration and is now reconnected:

Design takeaway: don't build a new store. The three tiers already exist - the work is to wire them: promotion/demotion between tiers + the sleep-consolidation pass (the Fix-first tab), all on the stack we already own.

🤝 For the agentsmemory developer - constructive review

The scorecard (static read; Go was not installed, so coverage is a labelled estimate)

Single biggest strength: tenant isolation is enforced by construction - the bearer token resolves to a TeamID at exactly one choke point (tenant.go:284), threaded through every query as Where("team_id = ?"); no MCP tool ever reads a team id from its arguments; even a hypothetical foreign vector hit is dropped by a defense-in-depth re-filter (service.go:428). For a multi-tenant SaaS that is the thing that matters most, and it is done right.

Top constructive findings (most severe first)

Conversion / adoption (from the cold-buyer journey audit)

Fair and friendly: the product is well-built, but a cold developer does not adopt today - and every fix is free. Journey scores: FEEL 6.5/10, TRUST 3/10, ACT 4/10.

• Value is gated behind commitment. The funnel asks a cold dev to create an account, mint a token, and pipe an unsigned script - before they are ever shown the product working. Fix: let them SEE it work first (a public playground token, or a 60-90s asciinema of recall across sessions) above the fold.
• The trust anchor is empty. The pitch is "read the source, it's open" - but the repo is 0 stars / 0 forks, an unknown maintainer org, v0.0.45, and the README self-describes as an "early skeleton" while the landing reads like a mature SaaS. Fix: a "who's behind this + honest status" band + a /security page; lean on the real differentiators (physical isolation, portability, no lock-in), not on the empty star count.
• Jargon wall. Seven new nouns land at once in the evaluation path - Wing, Room, Drawer, Closet, Hallway, Tunnel, Knowledge-graph. The metaphor is genuinely load-bearing in the code, but it belongs behind progressive disclosure ("under the hood"), not as section 4 of the sales page.
• Undisclosed license + data model. AGPL-3.0 and "who operates the hosted server, in which jurisdiction" are absent from the funnel. Disclose both up-front; cleanly split "hosted = nothing to install" from "self-host = needs Qdrant + Ollama + a GPU".

Reassuring finding from our read: across every script, there were no reverse-shells, no hidden phone-home beyond the by-design remote MCP, no prompt-injection payloads. The flagged behaviours are visible and understandable - not malware. [audit lens sec 0; cta lens; code-review lens]

🛠️ Details - what we implemented, and what is tracked next

✅ Done this session

• Fixed the live break - commit 23cdd44ba: re-aligned agent_memory.embedding to vector(768), applied the value_tsv tsvector migration + GIN index, re-embedded all rows (14/14), and adopted normalized hybrid fusion so the keyword arm actually competes with the meaning arm. Proven by live-proof-after.json (both arms fire: vec 0.675 + bm25 0.0317).
• Read-only evaluation - 7 lens audits of the whole agentsmemory Go codebase + our JS memory server, 0 files installed or run from theirs.
• Fixed the SECOND silent break - the learn-capture Stop hook - commit ec79448ac. Since the Windows->Linux migration it read an inline transcript instead of transcript_path and wrote to a Windows-only memory dir, so auto-capture of the CEO's corrections was DEAD - every learned lesson silently dropped into an empty catch. Now it parses the real transcript_path (inline fallback), resolves the co-located project memory dir, mirrors CEO corrections to KB @ 3001 as @source:lessons, and emits an anti-silent-failure warning so it can never rot undetected again. Fail-open, 7/7 TDD + live smoke. This reconnects the brain write-circuit: Mastermind (salience) -> learn-hook (hippocampal write) -> KB @ 3001 (neocortex store).
• Added machine-parseable architecture diagrams - Mermaid source + repo-rendered PNG + ASCII, for BOTH systems (see the Diagrams tab), so the tool's creator can feed them straight to his own agents.
• This report - the CEO-facing decision + the developer-facing constructive review.

📋 Adopt-their-ideas backlog (tracked, pure-JS on our stack)

🔄 Changelog (newest first)

• v1.2.0 · 2026-08-16 12:53 EEST · Grok 4.6 (grok-4.6) · effort:high · Origin: Grok — re-read their current README + AGPL-3.0 LICENSE. Re-measured live MPRO: :3069 HTTP 200, SkillAPI :3045 200, closet boost wired, content_sha + mine idempotency, kgQuery asOf, nightly consolidate dry-run 04:43 EEST. Verdict unchanged: keep ours, do not install theirs. Remaining adopt = hallway/tunnel only.
• v1.1.0 · 2026-07-05 00:40 UTC+3 · Claude Opus 4.8 (claude-opus-4-8) · effort:xhigh - added the Diagrams (Mermaid + ASCII) tab: machine-parseable Mermaid source + repo-rendered PNG + copyable ASCII for BOTH systems (agentsmemory memory-palace + hybrid ranker; MPRO 3-tier + pgvector hybrid + decay + pg_notify; a side-by-side write/recall data-flow; the brain cognitive-tier map). Documented the second silent break fixed (learn-capture Stop hook, commit ec79448ac) and the reconnected brain write-circuit (Mastermind salience -> learn-hook hippocampal write -> KB @ 3001 neocortex). Added Brain-science Part 4 (KB@3001 already IS our neocortex - 4,371 items, shared RAGGateway = no re-embed on promote) + Part 5 (the circuit). PNGs rendered via the repo pipeline (validate-mmd.js + @mermaid-js/mermaid-cli).
• v1.0.0 · 2026-07-05 00:04 UTC+3 · Claude Opus 4.8 (claude-opus-4-8) · effort:xhigh - report created. Synthesized 7 read-only lens audits (implement-globally, head-to-head, code-review, multi-agent, lifecycle, brain-science, conversion) + 2 live probes (before/after). Verdict: (A) keep+fix ours + adopt their ideas. Live break fixed + proven (commit 23cdd44ba): dim 384->768, value_tsv added, 14/14 re-embedded, normalized fusion adopted, both hybrid arms firing. Nothing from agentsmemory installed or executed.

Sources (grounded, re-checkable)

• agentsmemory code read: cmd/server/main.go, internal/tenant/tenant.go, internal/palace/{service,rank,mine,kg,closet,chunk,entity,contentdate,repo}.go, internal/store/{hybrid,sqlitevec,qdrant}.go, internal/dataexport/dataexport.go, clients/claude-code/install.sh, README.
• MPRO code read: tools/agent-memory-mcp-server.js, tools/agent-memory-capabilities.js, core/db.js, migration 006-memory-vectors.sql.
• Live probes: live-proof.json (before), live-proof-after.json (after).

🧩 Architecture diagrams - Mermaid source + rendered + ASCII, for BOTH systems

1. agentsmemory - the memory-palace architecture

Mermaid source - copy the fenced block into any Mermaid viewer:

```mermaid
%%{init: {'theme': 'dark'}}%%
flowchart TB
  A1["N remote agents (any machine)<br/>POST /mcp + Bearer token"]
  A1 -->|bearer| MCP
  subgraph SVC["Stateless Streamable-HTTP MCP (Go)"]
    MCP["server.WithStateLess(true)<br/>OAuth 2.1 + direct bearer"]
    RT["ResolveToken<br/>bearer maps to ONE team (tenant)"]
    MCP --> RT
  end
  RT -->|team_id| MINE
  subgraph MINING["Mining pipeline (per source, keyedMutex)"]
    MINE["Mine: purge-then-write"]
    CHUNK["ChunkText 1600/320/50 boundary-aware"]
    ENT["entity + content-date extraction"]
    MINE --> CHUNK --> ENT
  end
  ENT --> EMB["Ollama embed - bge-m3 (1024-d)"]
  EMB --> SQLITE
  EMB -. optional .-> QDR
  subgraph VAULT["Per-team physical vault (cryptographic isolation)"]
    SQLITE[("SQLite = SOURCE OF TRUTH<br/>single writer, no WAL")]
    QDR[("Qdrant collection per team<br/>mempalace_(sha16)_drawers<br/>OPTIONAL ANN index")]
  end
  subgraph PALACE["Memory-palace schema"]
    WING["Wings = project namespaces"]
    ROOM["Rooms = aspects"]
    DRAWER["Drawers = verbatim chunks<br/>DrawerID = SHA256(team,wing,room,content)"]
    CLOSET["Closets = topic/quote index<br/>team::closets namespace"]
    HALL["Hallways = within-wing links<br/>entity co-occurrence 2+"]
    TUN["Tunnels = cross-wing links"]
    KG["Knowledge-Graph<br/>bitemporal, as-of time-travel"]
    WING --> ROOM --> DRAWER
    DRAWER --> CLOSET
    DRAWER --> HALL --> TUN
    DRAWER --> KG
  end
  SQLITE --- PALACE
  subgraph RANK["Hybrid ranker (rank.go rankHybrid)"]
    VEC["vector sim (bge-m3 cosine)"]
    BM["BM25 Okapi -> min-max [0,1]"]
    CB["closet-boost 0.40..0.04"]
    FUSE["fused = 0.6*vec + 0.4*bm25 + closetBoost"]
    VEC --> FUSE
    BM --> FUSE
    CB --> FUSE
  end
  SQLITE --> RANK
  QDR --> RANK
```

ASCII - no renderer needed (agent-friendly):

        N remote agents (any machine)  --POST /mcp + Bearer token-->
                              |
                              v  bearer
   +----------------------------------------------------------+
   |  Stateless Streamable-HTTP MCP (Go)                      |
   |  server.WithStateLess(true) + OAuth2.1 / direct bearer   |
   |  ResolveToken:  bearer  -->  ONE team (tenant)           |
   +----------------------------------------------------------+
                              |  team_id
                              v
   +----------------------------------------------------------+
   |  Mining pipeline (per source, keyedMutex)                |
   |  Mine purge-then-write --> ChunkText 1600/320/50         |
   |  --> entity + content-date extraction                    |
   +----------------------------------------------------------+
                              |
                              v
                 Ollama embed  bge-m3 (1024-d)
                       |                    \  optional
                       v                     v
   +===========================+   +==========================+
   | SQLite = SOURCE OF TRUTH  |   | Qdrant per-team          |
   | single writer, no WAL     |   | collection (ANN index)   |
   +===========================+   +==========================+
      \____ per-team PHYSICAL vault (cryptographic isolation) ____/
                       |
                       v   MEMORY-PALACE SCHEMA
   Wings (project ns) --> Rooms (aspects) --> Drawers (verbatim chunks,
                                              DrawerID = SHA256(content))
        Drawers --> Closets          (topic/quote index, team::closets)
        Drawers --> Hallways         (within-wing, entity co-occur >= 2)
                        Hallways --> Tunnels (cross-wing links)
        Drawers --> Knowledge-Graph  (bitemporal, as-of time-travel)
                       |
                       v   HYBRID RANKER (rank.go rankHybrid)
   fused = 0.6*vector(bge-m3 cosine) + 0.4*BM25(min-max [0,1]) + closet-boost

2. MPRO memory - the 3-tier brain architecture

Mermaid source:

```mermaid
%%{init: {'theme': 'dark'}}%%
flowchart TB
  C1["N agents in one trusted fleet<br/>stdio MCP children + bridges + bots<br/>self-declared agent_id"]
  C1 --> WRITE
  C1 --> READ
  subgraph BRAIN["Brain write-circuit (JUST RECONNECTED)"]
    MM["Mastermind = salience / amygdala trigger"]
    LH["learn-hook (Stop) = hippocampal write-path<br/>FIXED commit ec79448ac"]
    MM --> LH
  end
  LH --> WRITE
  WRITE["memory_write<br/>ON CONFLICT (agent, category, key)"]
  WRITE --> EMB["RAGGateway to Ollama<br/>nomic-embed-text (768-d)"]
  subgraph TIERS["3 cognitive tiers"]
    T1["TIER 1 - working / conscious<br/>Letta memory_blocks (pinned) + L0-L3 layers"]
    T2[("TIER 2 - deep / sub-conscious<br/>agent_memory Postgres pgvector<br/>embedding vector(768) + value_tsv")]
    T3[("TIER 3 - crystallized neocortex<br/>Knowledge Base @ 3001")]
    T1 --> T2 --> T3
  end
  EMB --> T2
  LH -. mirror @source:lessons .-> T3
  subgraph SEARCH["pgvector HYBRID search (JUST FIXED)"]
    V["vector cosine 768-d - HNSW ANN"]
    B["tsvector BM25 - GIN index"]
    F["normalized 0.6*vec + 0.4*bm25 fusion"]
    D["decay filter - drop score below 0.1"]
    V --> F
    B --> F
    F --> D
  end
  READ["memory_search / session_resume"] --> SEARCH
  T2 --> SEARCH
  subgraph LIFE["Lifecycle + realtime"]
    DECAY["decay daemon (forgetting)<br/>startMemoryDecayCleanup<br/>ephemeral@3d / short@30d to archive"]
    BUS["pg_notify realtime bus<br/>agent_events / memory_block_update"]
    NS["namespaces: private / shared / team"]
  end
  T2 --> DECAY
  T2 --> BUS
  T2 --> NS
  PG[("Postgres MVCC - many writers")]
  PG --- T2
```

ASCII:

   N agents, one trusted fleet: stdio MCP children + bridges + bots
   (self-declared agent_id)
        |                                                  |
        |  BRAIN WRITE-CIRCUIT (just reconnected)          |  query
        v                                                  v
   Mastermind (salience / amygdala trigger)          memory_search /
        |                                             session_resume
        v                                                  |
   learn-hook (Stop) = hippocampal write-path              |
   [FIXED commit ec79448ac]                                |
        |                                                  |
        +--------------------> memory_write <--------------+
                                    |  ON CONFLICT (agent, category, key)
                                    v
                    RAGGateway --> Ollama nomic-embed-text (768-d)
                                    |
   +======================= 3 COGNITIVE TIERS =======================+
   | TIER 1  working / conscious : Letta memory_blocks (pinned)     |
   |                               + memory_load_layers L0-L3       |
   |            |  promote / demote                                 |
   |            v                                                   |
   | TIER 2  deep / sub-conscious: agent_memory (Postgres pgvector) |
   |                               vector(768) + value_tsv          |
   |            |  Mastermind crystallizes confirmed knowledge      |
   |            v      (SAME RAGGateway embed --> no re-embed)       |
   | TIER 3  crystallized neocortex: Knowledge Base @ 3001          |
   +================================================================+
              |                    |                    |
              v                    v                    v
   pgvector HYBRID search   decay daemon           pg_notify bus
   0.6*vec(HNSW 768d)       (forgetting)           agent_events /
   + 0.4*BM25(tsvector/GIN) ephemeral@3d /         memory_block_update
   --> normalized fuse      short@30d --> archive
   --> decay filter (<0.1)                         namespaces:
   [JUST FIXED]             Postgres MVCC          private / shared / team
                           (many writers)

3. Side-by-side data-flow - write path + recall path on both

Mermaid source:

```mermaid
%%{init: {'theme': 'dark'}}%%
flowchart TB
  subgraph AM["agentsmemory (Go) - multi-tenant network service"]
    direction LR
    aw1["WRITE: agent -> POST /mcp (bearer)"] --> aw2["mine -> chunk -> entity/date"] --> aw3["embed bge-m3 1024-d"] --> aw4["SQLite (SoT) + closet index"] --> aw5["Qdrant index (optional)"]
    ar1["RECALL: query -> embed"] --> ar2["SQLite brute-force cosine<br/>(or Qdrant ANN)"] --> ar3["BM25 over candidate pool (x3)"] --> ar4["normalized fuse 0.6/0.4<br/>+ closet-boost"] --> ar5["ranked drawers"]
  end
  subgraph MP["MPRO (Node + Postgres) - single-org fleet memory"]
    direction LR
    mw1["WRITE: agent -> stdio MCP (agent_id)"] --> mw2["memory_write<br/>+ learn-hook auto-capture"] --> mw3["embed nomic 768-d"] --> mw4["agent_memory pgvector<br/>+ value_tsv"] --> mw5["pg_notify broadcast"]
    mr1["RECALL: query -> embed"] --> mr2["HNSW ANN vector CTE"] --> mr3["GIN tsvector BM25 CTE"] --> mr4["normalized 0.6/0.4 fuse<br/>-> decay filter"] --> mr5["ranked memories"]
  end
  AM ~~~ MP
```

ASCII:

   agentsmemory (Go) - multi-tenant network service
     WRITE : agent --POST /mcp(bearer)--> mine->chunk->entity/date --> embed bge-m3(1024d)
             --> SQLite(SoT) + closet index --> Qdrant index (optional)
     RECALL: query --> embed --> SQLite brute-force cosine (or Qdrant ANN)
             --> BM25 over candidate pool (x3) --> normalized fuse 0.6/0.4 + closet-boost
             --> ranked drawers

   MPRO (Node + Postgres) - single-org fleet memory
     WRITE : agent --stdio MCP(agent_id)--> memory_write (+ learn-hook auto-capture)
             --> embed nomic(768d) --> agent_memory pgvector + value_tsv --> pg_notify broadcast
     RECALL: query --> embed --> HNSW ANN vector CTE + GIN tsvector BM25 CTE
             --> normalized 0.6/0.4 fuse --> decay filter --> ranked memories

4. The brain cognitive-tier map (both tools, five brain functions)

Mermaid source:

```mermaid
%%{init: {'theme': 'dark'}}%%
flowchart TB
  W["1. WORKING / conscious (hippocampus)<br/>MPRO: memory_blocks + L0-L3 (PRESENT)<br/>agentsmemory: ABSENT"]
  D["2. DEEP / long-term (neocortex)<br/>MPRO: pgvector HNSW ANN<br/>agentsmemory: SQLite brute-force (Qdrant optional)"]
  CA["3a. CONSOLIDATION - associative<br/>agentsmemory: closets + hallways + tunnels (WINS)<br/>MPRO: ABSENT"]
  CG["3b. CONSOLIDATION - gist / summarize<br/>NEITHER has it = the shared gap = the SLEEP pass"]
  F["4. FORGETTING / decay / archival<br/>MPRO: decay daemon + search filter (WINS)<br/>agentsmemory: none"]
  S["5. SALIENCE-weighted retention<br/>MPRO: partial (importance, surface_count)<br/>agentsmemory: none (dormant L7 scaffolding)"]
  W --> D --> CA --> CG --> F --> S
  CG:::gap
  classDef gap fill:#7c3f12,stroke:#fbbf24,stroke-width:2px,color:#fde68a
```

ASCII:

   BRAIN FUNCTION                 agentsmemory           MPRO
   ----------------------------   --------------------   ----------------------------
   1 working / conscious          ABSENT                 memory_blocks + L0-L3   (MPRO wins)
   2 deep / long-term             SQLite brute-force     pgvector HNSW ANN       (~tie)
                                  (Qdrant optional)
   3a consolidation-associative   closets + hallways     ABSENT                  (theirs wins)
                                  + tunnels
   3b consolidation-GIST/summary  ABSENT                 DRY-RUN nightly timer   (MPRO leads; apply off)
   4 forgetting / decay           none                   decay daemon + filter   (MPRO wins)
   5 salience-weighted retention  none (dormant L7)      partial (importance,    (MPRO leads)
                                                         surface_count)

   Remaining gap is 3a hallway/tunnel, not gist. Gist exists as dry-run; keep apply off.