Memory Architecture
Three tiers that actually run in production. SOUL.md, LCM, and Honcho — no more, no less.
245
Knowledge Entities
546
Installed Skills
3
Memory Tiers
15
Cron Jobs
∞
Session Search Index
24/7
Uptime
AI agents are stateless by default
Every session starts from zero. Users repeat themselves. Context gets lost. The "intelligence" is an illusion — pattern matching on whatever fits in the current window.
Most solutions throw more context at the model. Longer windows. RAG. Vector databases bolted onto chatbots. That's a scaling problem disguised as a design problem.
The real question isn't how much the agent remembers. It's how it remembers — and whether that memory structure can produce something closer to understanding.
The Architecture
Three tiers of memory, each with a distinct purpose
Constitution
—SOUL.mdImmutable governing rules
The constitution of an autonomous agent. Loaded fresh every turn — never stored in memory. These rules define identity, priorities, and behavioral bounds. If a decision violates SOUL.md, it cannot be executed. Constitutional constraints that survive every restart.
Lossless Context
—LCMComplete conversation graph
A DAG-based compaction engine that preserves every message with zero data loss. Every session is fully retrievable via session_search for FTS5 full-text search. Supports lcm_grep/lcm_expand for deep retrieval and LCM expansion. The system never forgets what was said.
Semantic Brain
—HonchoDurable fact & identity store
The primary write target for all persistent knowledge. Stores conclusions, identity facts, and user preferences via honcho_conclude. Supports semantic search (honcho_search) and reasoning (honcho_reasoning). The 'memory' tool is strictly forbidden — all persistence flows through Honcho.
Supporting Systems
What wraps around the three tiers to make everything work
Skills (546 installed)
Procedural memory that defines what the agent can do. Loaded on-demand via skill triggers — pattern-matched from user intent. Each skill is a self-contained capability with its own tools, prompts, and side-effects.
Session Search
FTS5-backed full-text search across past session transcripts. When the agent needs to recall something from a previous conversation, session_search finds the exact context — no DAG traversal required.
Kill Switches
Three-tier safety: constitutional (SOUL.md), behavioral (runtime guards), and protocol-level (MCP resource blocking). If any switch fires, the action is halted before it reaches execution.
Data Flow
Persistence Rules
- Session → LCM: Every message is stored. LCM compacts into a DAG with zero data loss. Full FTS5 search available via session_search.
- Session → Honcho: Conclusions, user facts, and identity data written via honcho_conclude. Semantic search via honcho_search. Reasoning via honcho_reasoning.
- Session → SOUL.md: Never. The constitution is loaded fresh every turn. Constitutional rules are never written by the agent — they are set once and enforced immutably.
- memory tool: Strictly forbidden. All persistence goes through Honcho. No unstructured writes. No bypasses.
Separation of Concerns
- SOUL.md = constitution (immutable, always fresh)
- LCM = lossless context (complete transcript, DAG-based)
- Honcho = semantic brain (conclusions, facts, identity)
- Skills = procedural memory (loaded on demand via triggers)
- memory tool = forbidden. All writes through Honcho.
The Autonomy Layer
How the agent acts without being told
Skill Triggers
User intent is pattern-matched against 546 installed skills. When a trigger fires, the corresponding skill is loaded and executed. No manual routing — the agent knows what to use based on context.
546 skills, pattern-matched
Cron Jobs
15 scheduled tasks run autonomously — data polling, user engagement checks, system maintenance. The agent doesn't wait for commands. It acts on a schedule.
Runs 24/7 on schedule
Proactive Outreach
The agent doesn't just respond — it initiates. Follow-ups, check-ins, notifications. If a user hasn't engaged, the agent reaches out. The difference between a tool and a partner.
Self-initiated engagement
Key Design Decisions
Why it's built this way, not just how
Why is 'memory' tool strictly forbidden?
A raw write-to-memory tool bypasses all structure. Without constraints, the agent writes noise, duplicates, contradictions. Honcho imposes a schema — conclusions, facts, preferences — so every write is meaningful and retrievable. No memory tool means no memory pollution.
Why two storage systems (LCM + Honcho) instead of one?
They solve different problems. LCM is for lossless retrieval — 'what did I say three sessions ago about X?' Honcho is for semantic persistence — 'who is this user and what matters to them?' One is a searchable transcript; the other is a structured brain. Both are needed; neither replaces the other.
Why is SOUL.md loaded fresh every time instead of stored?
Immutability guarantees the agent never modifies its own constitution. If SOUL.md were in memory, a prompt injection or reasoning error could overwrite identity rules. By loading it fresh from disk every turn, the constitution is inviolable. This is digital separation of powers.
Why kill switches instead of just monitoring?
Monitoring detects problems. Kill switches prevent them. The difference between a log entry saying 'agent almost deleted the database' and a guard that makes deletion impossible. Three tiers (constitutional, behavioral, protocol) ensure defense in depth — any single failure is caught downstream.
Evolution
From 7 tiers to 3 — the honest story
Concept
The Grand Vision
Designed a 7-tier cognitive architecture — constitution, executive, semantic, episodic, reflective, evolution, consolidation. A beautiful paper architecture that mirrored human memory stages.
Reality
The Contraction
Building 7 tiers meant maintaining 7 systems. Each tier introduced complexity, latency, and failure modes. Worse — some tiers overlapped in function. Episodic memory and semantic memory turned out to be one problem: retrieval.
Consolidation
3-Tier Architecture Emerges
The architecture collapsed into three: SOUL.md for constitution (immutable, always fresh), LCM for lossless context (DAG-based message compaction with FTS5 search), Honcho for semantic brain (conclusions, facts, identity). Every tier earned its place.
Refinement
Skills as Procedural Memory
Skills (546 installed) became the agent's procedural memory — loaded on-demand via skill triggers. The 'memory' tool was deprecated. All persistence routed through Honcho. LCM became the definitive conversation record.
Production
Always Online
24/7 operation on self-hosted VPS. Discord integration, multi-platform delivery, cron-driven proactive outreach. The architecture stopped being aspirational and started being what actually runs in production.
Present
Continuous Evolution
The 3-tier stack handles everything: constitutional governance (SOUL.md), complete transcript recall (LCM), and durable semantic knowledge (Honcho). New capabilities are added as skills, not new tiers. Simplicity wins.
Technical Stack
Extracted Principles
What this case study reveals about designing intelligent systems
Three tiers is enough.
Constitution (SOUL.md), context (LCM), and semantic memory (Honcho) cover every persistence need. Adding more tiers creates maintenance burden without proportional benefit. The best architecture is the one you don't have to think about.
Ban the memory tool.
Any system where the agent can write unstructured data to memory will accumulate noise. Structured persistence through Honcho (conclusions, facts, preferences) ensures every write has purpose and every read finds signal.
Immutability is a design choice, not a limitation.
SOUL.md loaded fresh every turn isn't a hack — it's a constitutional safeguard. The agent can't overwrite its own rules because it never holds the pen. This is the digital equivalent of separation of powers.
Kill switches beat monitoring every time.
Three tiers of safety (constitutional in SOUL.md, behavioral at runtime, protocol-level in MCP) ensure defense in depth. Any single failure is caught downstream. The agent is powerful by design and safe by architecture.
Designed and built by Koala — UX designer applying cognitive architecture to AI systems.
Three Tiers → Production → Something That Works