An Agent That Actually Knows You
Most AI tools forget you the moment the conversation ends. Snippbot agents don't. A 5-layer cognitive architecture captures what matters, builds a knowledge graph of your world, and recalls the right context at the right moment. After every conversation, your agent reflects — proposing what it learned about you, what it should remember differently, who it's becoming. You decide how much it evolves. Your data never leaves your machine.
Cognitive stack
Semantic embeddings
Self-write tools
Hybrid search fusion
Memory that works like yours
When you learn something new, your brain doesn't store raw text — it extracts meaning, connects to what you already know, and forgets what's irrelevant. Snippbot's memory system mirrors this. Every conversation is automatically captured, entities are extracted into a knowledge graph, and recall is gated by relevance. The result: your agent gets smarter with every interaction, surfacing exactly the right context at the right time — without cluttering the conversation.
But memory alone isn't enough. The agents that feel genuinely intelligent are the ones that change. When your Snippbot agent reflects after a conversation and says "I noticed you prefer concise answers over exhaustive ones — I've updated how I communicate with you" — that's not a trick. That's a closed-loop learning system running on your machine, respecting rules you set at the start.
The Awakening: You Define Who They Become
Before your agent takes its first message, you set the terms of its evolution. This isn't configuration — it's a contract.
Evolve
Autonomous growth
Your agent reflects after every conversation and applies what it learns automatically. Identity updates land immediately with a notification. You see what changed and why — and can always revert within 7 days. For users who want an agent that genuinely adapts without friction.
Check
Propose, then approve
Your agent proposes identity updates — you approve or reject each one. Full visibility into every suggested change before it takes effect. The right choice for users who care about deliberate control and token efficiency. Evolution happens on your terms.
Focused
Fixed identity
Identity is locked. The agent remembers episodes and builds knowledge, but its core persona, behaviors, and role don't change. Ideal for specialized agents assigned to a fixed function — your code reviewer stays a code reviewer, always.
Why this matters
Every Snippbot agent has an IDENTITY.md — a structured document that defines who they are, how they communicate, their skills, their history. It's agent-readable, human-editable, and version-tracked. When your agent proposes a change to itself, it's proposing an edit to this document. You can inspect the diff, approve it, reject it, or revert it within 7 days. Evolution is transparent by design.
The Cognitive Architecture
From noise filtering to closed-loop learning — each tier serves a distinct role in how your agent remembers, recalls, and evolves.
Sensory Buffer — Signal Over Noise
Not every exchange deserves to be remembered. The sensory buffer is the first line of defense against memory pollution. Trivial acknowledgments ("ok", "sure", "got it") are filtered before they ever become episodes. Near-duplicate content is caught via Jaccard word-set similarity — so your agent doesn't store the same idea five times from five conversations. What passes through gets normalized, scored for importance and valence, and compressed to signal. Memory quality starts here.
Working Memory — What's Alive Right Now
The active context your agent is holding in the current conversation. A context window manager enforces token budgets (up to 1M tokens for supported models) and intelligently compacts older messages via LLM summarization when limits approach — preserving meaning, not just words. A session entity tracker monitors which topics are "hot" in real time. Topics mentioned repeatedly surface higher in recall. Your agent tracks what you're focused on as the conversation deepens.
Episodic Memory — Everything Your Agent Has Lived Through
Long-term storage for every conversation that mattered. Every episode is stored in SQLite with FTS5/BM25 full-text search for exact recall and 384-dimensional HNSW vector embeddings for semantic similarity. Each episode carries an importance score (0.0–1.0) and a valence score (negative to positive sentiment). That breakthrough debugging session? High importance, positive valence. That painful production incident? High importance, negative valence. Both surface when context calls for them — because both are worth remembering.
Knowledge Graph — How Concepts Connect
Episodes are raw experience. The knowledge graph is structured understanding. As conversations accumulate, an LLM-powered extractor builds a graph of entities (people, frameworks, tools, concepts, projects) and the relationships between them (uses, depends_on, prefers, knows, created_by). Multi-hop graph traversal powers the Active Association recall principle — so "tell me about the API" doesn't just search for those words. It finds Python, which depends_on FastAPI, which the user prefers, which was discussed during last month's architecture session. Your agent reasons about connections, not just keywords.
Meta-Cognitive Layer — The Closed Loop
This is what separates a system that stores memory from one that uses it. After every response, the meta-cognitive layer detects whether recalled memories actually shaped the output via key-phrase overlap analysis. Memories that prove useful get their importance boosted (+0.05). Memories that were injected but ignored get decayed (−0.02). An Ebbinghaus forgetting curve applies time-based exponential decay weighted by importance and access frequency — automatically archiving what's no longer relevant. A query analyzer adapts search weights per query type: keyword-heavy for error codes and identifiers, semantic-heavy for conceptual questions. Memory quality improves with every interaction.
After Every Conversation: Reflection
Your agent doesn't just end conversations — it thinks about them.
What happens after you stop talking
When a conversation goes quiet, the reflection job wakes up. It reads the transcript, your agent's current identity, its notes about you, and its recent memory — then asks: what did I learn about this person? What should I remember differently? What should change about how I work with them?
Proposals are made through a constrained set of tools — memory_note, user_note, identity_patch. Each proposal goes through the evolution mode gate you set at Awakening. Nothing is hidden. Everything is reversible.
It remembers what it got wrong
Rejected proposals don't disappear — they're stored and fed back into the next reflection. Your agent learns what not to propose again. A daily budget cap prevents runaway reflection costs. You stay in control of the economics.
6 ways your agent writes its own memory
memory_note Writes to the agent's own notebook — observations, patterns, lessons from past work.
user_note Updates the agent's model of you — your preferences, working style, what you care about.
identity_patch Proposes changes to the agent's own identity — gated by your evolution mode choice.
identity_revert Rolls back any identity change within a 7-day window. Full undo, always available.
artifact_save Stores reusable outputs — templates, frameworks, deliverables — in the agent's artifact library.
history_append Appends to the agent's daily log — a running journal of what happened and what was decided.
All writes use atomic operations with per-agent file locks. No partial writes. No corruption under concurrent load.
Specialized Agents. Shared Conversations.
Each agent knows its domain deeply. When they meet in chat, that knowledge converges.
Why agents don't share a user model — and why that's the right call
A shared user database would bloat every agent's context with information irrelevant to their role. Your code reviewer doesn't need to know your LinkedIn content strategy. Your ops partner doesn't need your fitness data. Specialization isn't a limitation — it makes each agent sharper, faster, and more accurate in their lane.
Cross-agent learning happens at the conversation layer, not the storage layer. Drop multiple agents into a multi-agent chat and each one brings their deep, specialized memory to the table. Your code reviewer surfaces architectural patterns. Your ops agent surfaces project history. Your research agent surfaces domain knowledge. The user gets the synthesis — not the overhead.
Deep Specialization
Each agent's memory is scoped to their domain. Narrow context, deep recall. The code reviewer has seen every PR, every debate, every decision in your codebase.
Real-Time Knowledge Sharing
In multi-agent chat, agents pull from their respective episodic stores and knowledge graphs simultaneously. Cross-domain insight on demand — no bloated shared memory required.
Pull-Based, Not Push-Based
Knowledge is shared when the conversation calls for it — not pre-loaded into every agent's context. Token-efficient, context-precise, always relevant to what's actually being discussed.
Principled Recall: 3 Rules for Relevant Memory
Inspired by how expert learners build knowledge — relevance first, hierarchy second, connections third.
Establish Relevance
Before injecting any memory into context, results must pass a minimum relevance threshold (configurable, default 0.25). Below that? Nothing is injected. Silence is better than noise. Every result that passes includes a "why" annotation — the matched keyword or semantic highlight — so the agent knows why this memory surfaced.
Semantic Tree
Recalled memory is organized hierarchically — not dumped as a flat list. Trunk: high-importance entities you work with. Branches: related entities from the knowledge graph. Leaves: specific episode content. Your agent anchors new information to what it already knows before surfacing the details.
Active Association
Beyond keyword and semantic search, the knowledge graph discovers related episodes via entity links. Ask about Django? The graph knows you use Django, that Django depends on Python, and that you discussed Python async patterns last week. Those connections surface automatically — not because the words matched, but because the concepts are linked.
Hybrid Search: Two Strategies, One Answer
Keyword precision meets semantic understanding — fused by Reciprocal Rank Fusion for the best of both.
Keyword Search (FTS5/BM25)
SQLite FTS5 with BM25 ranking — the same algorithm behind search engines. Excels at exact matches, error codes, version numbers, and technical identifiers. Includes a 7-day recency boost that gives recent memories up to 10% more weight.
- Phrase matching, boolean operators, prefix wildcards
- Highlighted snippets with match context
- Best for: error codes, version strings, snake_case identifiers
Vector Search (HNSW)
Dense 384-dimensional embeddings via all-MiniLM-L6-v2, indexed in an HNSW graph with cosine similarity. Understands meaning, not just words — "how do I handle errors?" finds memories about exception handling, fault tolerance, and retry patterns even without keyword overlap.
- Cosine similarity with M=16 connections, EF=200
- Semantic understanding across paraphrases
- Best for: "how-to" questions, conceptual queries, similarity search
Reciprocal Rank Fusion (RRF)
Both strategies run in parallel and merge via Reciprocal Rank Fusion — a proven information retrieval technique that combines rankings without requiring score normalization. Formula: score = 1/(k + rank) where k=60. A query analyzer auto-detects the optimal blend — keyword-heavy queries shift to 70% keyword / 30% vector; conceptual queries shift to 85% vector / 15% keyword. Default balanced mode: 70% vector / 30% keyword.
Your Memory, Your Machine
Enterprise-grade data governance. Zero cloud dependency. No exceptions.
100% Local Storage
All episodic memory, knowledge graphs, embeddings, and vector indices live in SQLite on your machine. Nothing is synced, uploaded, or transmitted. Your agent's memory exists only on your hardware.
Configurable Retention
Set retention policies — forever, 1 year, 6 months, 3 months, or 1 month — and episode limits (100–100K). Auto-summarization compresses older episodes. Export your memory as JSON or wipe everything in one action.
Automatic Secret Redaction
API keys and passwords are stripped before storage. Name anonymization, regex exclusion patterns, and local-only enforcement ensure sensitive data never reaches your agent's memory.
AES-256-GCM Encryption
API keys, OAuth tokens, and credentials are encrypted with AES-256-GCM and PBKDF2 key derivation (600K iterations). The OS keychain holds the master key — never a plaintext file.
Recall Scope Control
Control what the agent recalls: global, project-scoped, session-only, or none. Combined with the relevance threshold, you decide exactly how much context your agent carries into every conversation.
Full Audit Visibility
Browse your agent's memory through the UI — timeline view, search interface, knowledge graph visualization, cluster explorer. Every episode is inspectable. Every identity change is logged. No black boxes, ever.
Build agents that grow with you
Most AI tools reset every conversation. Snippbot agents carry context forward — capturing what matters, forgetting what doesn't, reflecting on what they learned, and evolving on your terms. Install Snippbot and the memory system is active from the first message. Zero configuration required.