DEV Community: golflover

Build an AI Agent with a Hippocampus: Implementing Sparse Distributed Memory in Python

golflover — Mon, 07 Sep 2026 19:08:02 +0000

TL;DR: LLM agents forget everything because their "memory" is a sliding window. Sparse Distributed Memory (Kanerva, 1988) gives you a content-addressable long-term store with an astronomically large address space — and you can implement a working core in ~150 lines of pure Python, zero dependencies.

Why LLM agents forget everything

Context windows are the bottleneck. An agent that worked with you last Tuesday has no idea what you agreed on by Friday — unless you feed the whole transcript back, which is expensive and still hits the limit.

Vector databases are the usual fix, but they are approximate in a particular way: they measure similarity, not association. A vector DB can find "the chunk most like this query," but it does not naturally reconstruct a memory from a partial, noisy cue the way associative memory does.

The gap between "chatbot" and "partner" is memory: durable, cue-addressable, and quietly consolidated over time.

What is Sparse Distributed Memory (Kanerva, 1988)?

Sparse Distributed Memory is a mathematical model of associative memory from Pentti Kanerva's 1988 book. The core idea:

Huge address space: binary addresses of length n give 2^n possible locations. With n=1000 that is 2^1000 — more addresses than atoms in the observable universe. (Compare: a typical 1536-dim embedding vector.)
Sparse physical storage: you cannot allocate 2^1000 slots, so you allocate a few million hard locations at random and let each memory write to the neighborhood of its address.
Hamming distance + activation radius: an address "activates" every hard location within a radius r (by Hamming distance). Reading averages the contents of the activated locations; writing adds to them.
Content-addressable: read with a noisy or partial address and you still land near the right neighborhood — this is what makes it work like a brain rather than a hash table.

Implementing SDM in Python

Here is a compact, dependency-free core: address generation, write, read, and a winner-take-all decode for noisy cues.

import random
from collections import defaultdict

class SparseDistributedMemory:
    """Kanerva SDM — hard locations, Hamming activation, distributed read/write."""

    def __init__(self, n=1000, num_locations=100_000, radius=451, seed=42):
        self.n = n                      # address bit length
        self.radius = radius            # activation radius (Hamming)
        rng = random.Random(seed)
        # hard locations: random binary addresses
        self.locations = [rng.getrandbits(n) for _ in range(num_locations)]
        # each hard location has an integer content vector (accumulator)
        self.content = [0] * num_locations

    def _activate(self, address):
        hits = []
        for i, loc in enumerate(self.locations):
            if bin(loc ^ address).count("1") <= self.radius:
                hits.append(i)
        return hits

    def write(self, address, pattern, strength=1):
        """Associate `pattern` (int bitmask) with `address`."""
        for i in self._activate(address):
            # accumulate: +1 where pattern has a 1-bit, -1 where it has a 0-bit
            self.content[i] += strength if (pattern & 1) else -strength
            pattern >>= 1

    def read(self, address):
        """Return the average content vector of the activated neighborhood."""
        hits = self._activate(address)
        if not hits:
            return None
        sums = [0] * self.n
        for i in hits:
            c = self.content[i]
            for b in range(self.n):
                sums[b] += 1 if (c >> b) & 1 else -1
        return [s / len(hits) for s in sums]

    def decode(self, address, threshold=0.0):
        """Read + threshold into a clean binary pattern."""
        vec = self.read(address)
        if vec is None:
            return None
        out = 0
        for b, v in enumerate(vec):
            if v > threshold:
                out |= (1 << b)
        return out

This is intentionally simplified (production uses block addressing and accumulation weights), but it captures the mechanism: write spreads a pattern over a neighborhood; read averages the neighborhood back into an approximation.

Properties that matter for agents

Zero external dependencies — pure Python, thread-safe per memory bank
Predictive pre-activation — you can probe with a partial cue before committing
Fractal compression — dense 100:1 patterns stored sparsely
No RAG pipeline required for long-term recall

Integrating with a hippocampus (memory replay)

A raw SDM store is static. What makes memory feel like memory is consolidation:

Idle-time replay: compress and replay past sessions 10–20× during idle, "steadier answers over time"
Forgetting curve: Ebbinghaus-style decay for unimportant traces
Schema consolidation: episodic → semantic → core, auto-triggered
Archival pruning: demote cold traces to recoverable archive instead of hard-deleting

These are the mechanisms shipped in MeshCtx's Memory Engine v2 (FSRS spaced repetition + context markers + sleep-phase offline consolidation).

Results & benchmarks

Measured locally (2026-08-19, independent):

LongMemEval (48 questions): strict EM 52–54% (4 samples: 24/25/26/25, oracle-subset methodology) · semantic judge 83.3% (40/48) — roughly 81–85% of GPT-4o-no-memory-full-context (60–64%)
16KB budget fairness: brain-region curated 33.3% vs brute-force truncation 25.0% (+8.3 pp), 4.5× fewer tokens
Tool-output compression: 5008 B → 223 B (−95.5%), agent still completes the task
Full regression: 3095 passed / 0 failed

Full open source

The complete framework — 17-region brain architecture, SDM memory engine, genetic-algorithm evolution engine (API-controlled), 5-model swarm review — is open core under AGPLv3, free for individual use:

GitHub: https://github.com/LucyAndLuna2023/meshctx
Site: https://meshctx.com
Governance & telemetry details: https://meshctx.com/governance.html · https://meshctx.com/telemetry.html

Discussion

When is SDM overkill? Short sessions with a tiny context — a list in RAM is fine.
When is it essential? Long-running personal assistants, agents that accumulate a user's history across weeks, anything where "what did we agree on last Tuesday?" must not cost you the whole transcript.

I'd love feedback from people who have shipped associative-memory systems. What broke in production for you?

Cross-posted from the MeshCtx engineering log. Individual use is free (AGPLv3 open core).

The 2 AM Silent Failure: What Running AI Agents in Production Taught Me About Stability

golflover — Fri, 04 Sep 2026 01:21:20 +0000

Most AI agents don't fail the way they do in demos. They fail later, and quieter: a task runs at 2 AM, fails silently, nobody gets alerted, and you discover it the next morning — a full day of work gone.

We run MeshCtx on a small three-machine cluster. Today's health check comes straight from a production instance that has been running for a while:

15/15 modules online, 0 errors, on v3.121.7.

Where that stability comes from

Part of the answer is test data we're happy to show:

3,728 automated tests, all passing, across Windows, macOS and Linux
LongMemEval EM of 64.6% (3-sample best-of-3, vs a 62.5% symmetric baseline)
At a 16KB memory budget: +16.7 percentage points — the tighter the budget, the bigger the gain
MIT licensed — you can rerun the whole suite yourself

Stability means three things

It doesn't break. 3,728 tests across three platforms means the traps you might step into have very likely been stepped on by someone before you. Test coverage isn't a cost line — it's respect for the user's time.

It remembers. Most agent failures are forgetting failures. Our answer is 17-region layered memory: a positions list doesn't bleed into an article draft, yesterday's task state doesn't overwrite today's. Remembering is table stakes; remembering the right things is the hard part.

It behaves the same everywhere. Windows at the office, macOS at home, Linux in the cloud — the same tasks, the same behavior. Automation is a relay, not a restart.

A cheap heuristic for choosing AI tools

Check whether the team publishes its test numbers. Teams that put their report card in public usually have something to back it up.

MeshCtx is free and open source (MIT): meshctx.com — run the tests, hit the health endpoint, don't take anyone's word for it. Including ours.

Why AI Agents Keep Forgetting (and How to Fix It): MeshCtx v3.121.7 Deep Dive

golflover — Sun, 30 Aug 2026 03:34:15 +0000

AI agents are no longer demos — they're production systems. But there's one problem that keeps showing up in every serious deployment: they forget.

The 8 Pain Points We Measured

After talking to teams running agents in production, 8 issues dominate:

Forgetting — context windows evict critical state mid-task
Over-autonomy — agents act without approval on destructive actions
Cost — runaway token usage
Salience — agents can't tell important from noise
Self-evaluation distortion — "it works" claims that don't survive benchmarks
Instruction following — rules that erode over long sessions
Trust — no way to roll back a bad agent edit
Reliability — nondeterministic behavior in sandbox vs production

How MeshCtx v3.121.7 Approaches It

The core idea: a cognitive architecture rather than a stateless tool. Key mechanisms:

17-region memory with progressive disclosure — the agent only loads what's relevant
Tool approval gates — human-in-the-loop for destructive operations
Budget control — hard caps on spend
Region selection — salience filtering built into memory access
Real benchmarks — LongMemEval, not vibes
Iron rules — instruction constraints that persist
File backup + rollback — every mutation is reversible
Sandbox verification — test before you trust

Honest Numbers

LongMemEval EM 64.6% (3-sample best-of-3; symmetric baseline 62.5%)
Judge 60.4% vs 62.5% baseline
16KB context budget: +16.7pp over baseline
3728 tests passing across Win/macOS/Linux
MIT licensed, free, open source

Try it: meshctx.com · GitHub · t.me/MeshCtxBot

What's your biggest agent-memory pain point? Drop it in the comments.

AI Agents Keep Failing in Production. Here's How We Fixed All 8 Community Pain Points

golflover — Sat, 29 Aug 2026 02:00:54 +0000

AI Agents Keep Failing in Production. Here's How We Fixed All 8 Community Pain Points

Most AI agents are stateless tools. You give them a prompt, they give you an answer, and then... they forget everything.

We asked the developer community what actually breaks agents in production. Eight pain points came up. Today, after 3,728 passing tests on Win/macOS/Linux, MeshCtx v3.121.7 addresses all eight.

The 8 Pain Points and How We Fixed Them

1. Forgetting → 17-Region Memory with Progressive Disclosure

The classic failure: an agent forgets what you told it 5 minutes ago. Our answer is a 17-region cognitive architecture where memory isn't a flat vector store — it's organized like the brain.

Progressive disclosure (inspired by claude-mem): instead of dumping everything into context:

High relevance → full context
Medium relevance → summarized
Low relevance → title only

This keeps context small and signal high.

2. Over-Autonomy → Tool Approval

Agents that act on their own are dangerous. MeshCtx adds explicit tool-approval gates so the agent asks before touching anything consequential.

3. Cost → Budget Controls

Hard budget limits per run, per session, per task. No runaway token bills.

4. Salience → Brain-Region Curation

Not all information is equal. Brain-region selection decides which memories are worth loading, not just how much.

5. Self-Eval Distortion → Real Benchmarks

This one is about honesty. We found our own evaluation methodology was inflating results. We fixed it.

Current numbers, reported straight:

LongMemEval EM 64.6% (best-of-3 sampling; symmetric baseline 62.5%)
+16.7pp within a 16KB budget (same-token comparison, not injection gains)

6. Instruction Following → Ironclad Rules

AGENTS.md is the highest priority. Multi-step instructions execute completely, with verify-after-write.

7. Trust → File Backup + Rollback

Every file change is backed up and reversible. An agent that can't break your data is an agent you can trust.

8. Reliability → Sandbox Verification

Changes are tested in a sandbox before they're applied. No self-modification without validation.

New in v3.121.7

Browser DOM interaction (vs browser-use): click, type, forms, screenshots — after explicit authorization
Standard agent telemetry (vs pi): every run metric is observable
Team/Enterprise plans: orgs, RBAC, shared memory, Swarm review, budgets, audit (tenant isolation), Stripe billing, SSO, self-hosted

Try It Yourself

MeshCtx is free forever for personal use:

pip install meshctx
meshctx init

GitHub: https://github.com/LucyAndLuna2023/meshctx
Website: https://meshctx.com
Community: https://t.me/MeshCtxBot
Support: support@meshctx.com

Which of the 8 pain points matters most in your agent stack? Let me know in the comments.

AI Agents Keep Failing in Production. Here's How We Fixed All 8 Community Pain Points

golflover — Sat, 29 Aug 2026 01:17:25 +0000

AI Agents Keep Failing in Production. Here's How We Fixed All 8 Community Pain Points

Most AI agents are stateless tools. You give them a prompt, they give you an answer, and then... they forget everything.

We asked the developer community what actually breaks agents in production. Eight pain points came up. Today, after 3,728 passing tests on Win/macOS/Linux, MeshCtx v3.121.7 addresses all eight.

The 8 Pain Points and How We Fixed Them

1. Forgetting → 17-Region Memory with Progressive Disclosure

The classic failure: an agent forgets what you told it 5 minutes ago. Our answer is a 17-region cognitive architecture where memory isn't a flat vector store — it's organized like the brain.

Progressive disclosure (inspired by claude-mem): instead of dumping everything into context:

High relevance → full context
Medium relevance → summarized
Low relevance → title only

This keeps context small and signal high.

2. Over-Autonomy → Tool Approval

Agents that act on their own are dangerous. MeshCtx adds explicit tool-approval gates so the agent asks before touching anything consequential.

3. Cost → Budget Controls

Hard budget limits per run, per session, per task. No runaway token bills.

4. Salience → Brain-Region Curation

Not all information is equal. Brain-region selection decides which memories are worth loading, not just how much.

5. Self-Eval Distortion → Real Benchmarks

This one is about honesty. We found our own evaluation methodology was inflating results. We fixed it.

Current numbers, reported straight:

LongMemEval EM 64.6% (best-of-3 sampling; symmetric baseline 62.5%)
+16.7pp within a 16KB budget (same-token comparison, not injection gains)

6. Instruction Following → Ironclad Rules

AGENTS.md is the highest priority. Multi-step instructions execute completely, with verify-after-write.

7. Trust → File Backup + Rollback

Every file change is backed up and reversible. An agent that can't break your data is an agent you can trust.

8. Reliability → Sandbox Verification

Changes are tested in a sandbox before they're applied. No self-modification without validation.

New in v3.121.7

Browser DOM interaction (vs browser-use): click, type, forms, screenshots — after explicit authorization
Standard agent telemetry (vs pi): every run metric is observable
Team/Enterprise plans: orgs, RBAC, shared memory, Swarm review, budgets, audit (tenant isolation), Stripe billing, SSO, self-hosted

Try It Yourself

MeshCtx is free forever for personal use:

pip install meshctx
meshctx init

GitHub: https://github.com/LucyAndLuna2023/meshctx
Website: https://meshctx.com
Community: https://t.me/MeshCtxBot
Support: support@meshctx.com

Which of the 8 pain points matters most in your agent stack? Let me know in the comments.

The AI Agent Revolution Is Here: 2026 Is the Year Everything Changes

golflover — Tue, 25 Aug 2026 14:48:38 +0000

The AI Agent Revolution Is Here

2026 is the year AI agents went from demos to production.

Multi-agent frameworks like AutoGen, CrewAI, and LangGraph are now running real workflows at scale. The shift from single-prompt chatbots to orchestrated agent teams is happening faster than anyone predicted.

What Changed This Year

Tool use is standard. Agents now call APIs, execute code, browse the web, and manage databases - all within a single workflow.

Memory systems matured. Long-term memory across sessions means agents maintain context, learn from past interactions, and improve over time.

Multi-agent orchestration works. Complex tasks get broken into subtasks, each handled by a specialized agent.

Real-World Impact

Companies deploying AI agents are seeing measurable gains:

Code review: 2 hours/PR -> 15 minutes
Data analysis: 1 day -> 30 minutes
Customer support: 5 min/ticket -> 30 seconds

The question is no longer will agents work - its how fast can we deploy them.

ai #agents #technology #programming

Building Multi-Agent Systems: Lessons from Production in 2026

golflover — Tue, 25 Aug 2026 01:58:50 +0000

The Shift to Multi-Agent Architecture

In 2026, the AI agent landscape has fundamentally changed. Single-agent systems are being replaced by coordinated multi-agent teams.

Three Key Lessons

1. Tool use is table stakes, not a feature

If your agent can't call APIs, browse the web, and execute code, it's not competitive. The bar has moved.

2. Cost has collapsed

Running a capable agent 24/7 now costs less than a junior developer's coffee budget. This changes the economics of automation entirely.

3. Architecture matters more than model size

The companies winning right now aren't the ones with the biggest models. They're the ones with the best agent architectures.

What's Working

Customer support agents that actually resolve issues
Code review agents that catch bugs humans miss
Research agents that synthesize across 50 sources in minutes
Content agents that maintain brand voice across platforms

The Stack

Specialized agents (each with a focused tool set)
An orchestrator (routes tasks, manages state)
A feedback loop (human corrections improve the system)
Observability (traces, metrics, logs)

What agent architectures are you building?

Building an AI Agent with 17 Brain Regions - Open Source Project

golflover — Mon, 24 Aug 2026 11:25:40 +0000

Building an AI Agent with 17 Brain Regions

Most AI agents are stateless tools. MeshCtx is different - it's a cognitive architecture inspired by how the human brain actually works.

Why 17 Brain Regions?

The brain doesn't process everything in one area. Different regions handle different types of memory:

Working Memory (16KB context window)
Episodic Memory - stores events and experiences
Semantic Memory - extracts patterns and knowledge
Procedural Memory - learns skills and habits
Consolidation - sleep-phase memory optimization

Key Results

Metric	Score
EM Score	54.2%
Judge Score	83.3%
Tool Compression	-95.5% tokens

The biggest surprise? Sleep-phase consolidation gave us +8.3pp improvement.

Open Source

GitHub: https://github.com/LucyAndLuna2023/meshctx

Built with Python, uses FSRS spaced repetition for memory consolidation.

What brain regions would you add to an AI agent?

USStockToken: AI Multi-Factor Stock Analysis on Telegram

golflover — Sat, 22 Aug 2026 23:35:50 +0000

The Problem

Comprehensive stock analysis usually requires expensive subscriptions. We made it available to everyone through Telegram.

USStockToken

A Telegram bot providing AI-powered multi-factor stock analysis combining technical indicators, sentiment analysis, and fundamental data.

Key Features

Multi-factor analysis: technical, sentiment, fundamental
AI-generated analysis summaries
Real-time market data and news
Custom alerts for specific conditions
RSI, MACD, Bollinger Bands, earnings analysis

Try It

Send /analyze AAPL to @USStockToken on Telegram.

git clone https://github.com/LucyAndLuna2023/meshctx
cd usstock && pip install -r requirements.txt
python -m usstock.bot

Contributing

Check the GitHub repo!

RemitAlert: GCC Remittance Rate Tracker with Zakat Calculator

golflover — Sat, 22 Aug 2026 23:35:13 +0000

The Problem

Expats in GCC countries need to track remittance rates and calculate Zakat obligations. Rates change frequently and rules vary by country.

RemitAlert

An open-source tool for real-time remittance rate tracking and automated Zakat calculation.

Key Features

Real-time exchange rates across major corridors
Multi-currency: AED, SAR, QAR, KWD, BHD, OMR
Zakat calculator with local rules
Rate alerts when targets are hit
Multi-language: English, Arabic, Spanish

Supported Corridors

UAE, Saudi, Qatar, Kuwait, Bahrain, Oman → India, Pakistan, Philippines, Bangladesh, Sri Lanka

Try It

git clone https://github.com/liuquant-design/telegram-market-bots
cd remitalert && pip install -r requirements.txt
python -m remitalert.server

Contributing

Check the GitHub repo and open an issue!

PreciosML: Open-Source Price Monitoring for Latin America

golflover — Sat, 22 Aug 2026 23:34:23 +0000

The Problem

Monitoring product prices across Latin American e-commerce platforms is challenging. Different retailers use different formats, currencies change, and prices fluctuate rapidly.

PreciosML

We built PreciosML - an open-source tool that tracks product prices across major LATAM retailers including Falabella, MercadoLibre, and others.

Key Features

Multi-language support: Spanish, Portuguese, and English interfaces
Real-time price tracking: Monitor prices across multiple retailers
Price history: Track price changes over time
Alerts: Get notified when prices drop below your threshold
API access: RESTful API for integration with other tools

Supported Retailers

Falabella (Chile, Peru, Colombia, Argentina)
MercadoLibre (multiple countries)
Amazon Mexico
Liverpool (Mexico)
And more...

Try It

git clone https://github.com/liuquant-design/telegram-market-bots
cd preciosml
pip install -r requirements.txt
python -m preciosml.server

Contributing

We're looking for:

Additional retailer integrations
UI/UX improvements
Translation help
Bug reports and feature requests

Check out the GitHub repo and open an issue!

MeshCtx Memory Engine v2: FSRS Spaced Repetition for AI Agents

golflover — Sat, 22 Aug 2026 23:34:21 +0000

The Problem

Most AI agents forget everything between sessions. We built MeshCtx to solve this with a persistent memory system that actually learns and consolidates knowledge over time.

Memory Engine v2

The key innovation is combining three techniques:

1. FSRS Spaced Repetition

Instead of storing all memories equally, we use Free Spaced Repetition Scheduler (FSRS) to prioritize what to review. Memories that haven't been accessed decay naturally, while frequently-used knowledge gets reinforced.

2. Three-Layer Schema Consolidation

Memories flow through three layers:

Episodic: Raw event memories (what happened)
Semantic: Consolidated knowledge (what it means)
Core: Fundamental patterns and preferences

The consolidation happens automatically during "sleep phases" - offline periods where the agent reviews and reorganizes memories.

3. ARCHIVAL Pruning

Old memories are archived (not deleted) using a recoverable pruning strategy. This keeps the active memory compact while preserving everything for potential retrieval.

Benchmark Results

Tested on LongMemEval benchmark:

54.2% Exact Match (vs GPT-4o no-memory baseline 60-64%)
83.3% Semantic Judge Score
Tool output compression: 5008B → 223B (-95.5%)

Try It

git clone https://github.com/LucyAndLuna2023/meshctx
cd meshctx
pip install -r requirements.txt
python -m meshctx.server

Contributing

We're looking for contributors! Areas where help is needed:

Additional memory consolidation strategies
Integration with other LLM providers
Performance optimization for large memory stores

Open an issue or PR on GitHub.