Field notes from a memory agent in production
Engineering deep dives and tutorials on building, scaling, and shipping AI agents that remember. Written by the team behind Memanto.
What Did Your Agent Believe Last Tuesday?
Your logs tell you what an agent did. Nothing tells you what it knew at the time, which is the only thing that explains why. Memanto has three temporal recall modes for exactly that question. Here is what each one reconstructs, the relative-time grammar they share, and the four investigations they are built for.
Memory Is a Job, Not a Layer
Six ways the industry wires memory into AI agents, the evidence that each one breaks when the facts change, and what it takes to build memory that stays true.
Give Your Python Agent Memory in Ten Lines
Memanto’s new Python client gives any Python agent persistent memory with one import: typed memories, recall, grounded answers with no LLM key of your own, extraction straight from chat turns, and point-in-time recall. Every snippet here was run against memanto 0.2.28, outputs included.
Your Agent’s Memory Needs a Retention Policy
An estate that only grows is an estate that gets worse. Expiry in Memanto is a reversible, stamped, auditable state change driven by a policy you write once: a per-type retention table plus named rules, first match wins. Here is the full grammar, the three presets, and the sweep that makes it happen.
Your Agents' Memory, Now in Your Obsidian Vault
The Memanto plugin for Obsidian turns what your coding agents have learned into notes you can read, link, query and question, right next to the rest of your thinking. Here is what it does and how to set it up in about five minutes.
Move Your Mem0 Memories to Memanto in One Command
A complete account of what `memanto migrate mem0` does to your data: the endpoints it reads, how a Mem0 category becomes a typed Memanto memory, what the dry run shows before a single write, and what changes on the other side. The case for moving is built entirely from Mem0's own documentation.
The Four Kinds of Agent Memory, and What Actually Stores Each One
Working, episodic, semantic, procedural. Every agent framework now cites the same four boxes, borrowed from cognitive science by way of SOAR and CoALA. Here is what each one really is inside an LLM agent, the failure mode specific to each, and how the four map onto Memanto’s 13 semantic types and its retention policy.
Your Traces Already Know What Broke. Your Agent Doesn’t.
Langfuse records what went wrong. Memanto remembers the lesson. Inside the new langfuse-memanto integration: why 812 observations collapse into 2 memories, why grouping by error signature is the entire trick, and what a span processor can and cannot see.
Memory Is a Job, Not a Dump
The five verbs your agents shouldn't be doing — curate, reconcile, consolidate, brief, provision — and how Memanto performs each one as a companion memory agent running alongside your fleet.
Your Agent's Memory Shouldn't Die With Your Vendor
Why we made Open Knowledge Format a native citizen of Memanto and why memory portability is the next fight worth having.
The Practical Course: Build Agentic Memory That Keeps Your Loops Alive And Sharpens Them Every Run
A hands-on course on agentic memory: first make your loop survive long runs, then make it compound across them. Every step ships with copy-paste Memanto commands - typed remember/recall, session handoffs, structured failure records, and a reuse loop that makes each run start smarter than the last.
What 50+ Pull Requests Taught Us About Agentic Skills: Reviewing the Matt Pocock Bounty
After reviewing over 50 PRs, diving into different architectural decisions, and testing various implementations, here is what we learned and whose implementation stood out.
Memanto On-Prem: Your Agents' Memory, Entirely on Your Own Hardware
Memanto now runs fully on your own infrastructure — powered by a local Moorcheh on-prem server in Docker. No API key, no data leaving your environment, and zero per-request cost with local Ollama models.
Adding Persistent Memory to CrewAI with Memanto
CrewAI agents forget everything the moment your script finishes. The new crewai-memanto package gives your crew shared, long-term memory that survives across sessions, scripts, and tools — through native remember, recall, and answer tools.
Recall, Recency, and Relevance: How Memanto Finds Only the Exact Memory Your Agent Needs
Instead of dumping everything into an agent’s context, Memanto retrieves the single, most useful memory for the current task using typed recall, temporal queries, and differential retrieval.
How Memanto Detects and Resolves Contradictory Memories
AI agents accumulate knowledge over time. That knowledge will eventually contradict itself. Memanto detects when new information conflicts with existing knowledge, surfaces the conflict, and provides structured tools to resolve it explicitly.
What Memanto Actually Stores: All 13 Memory Types Explained
Not all context is the same. Memanto organizes every memory into one of 13 semantic types, each captured, retrieved, and surfaced differently. Here is what each type stores, why it exists, and when to use it.
One Memory Agent, Every Tool: Connect Memanto Across Your Entire Dev Stack
Your AI coding assistants forget everything between sessions. Here's how to wire Memanto into Claude Code, Cursor, Windsurf, and Cline simultaneously, so every tool knows your preferences, past decisions, and recurring errors.
Why We Don't Use HNSW For Agent Memory Search
Standard vector databases lean on knowledge graphs and parallel pipelines to compensate for HNSW's approximate search. Information-Theoretic Scoring removes the need for both, and matches hybrid systems on every public benchmark.
Stop Overengineering Agentic Memory: How Basic RAG Outperforms the Leading Memory Frameworks
Why complex graph-based memory architectures may be overkill, and how a highly-optimized RAG pipeline hits 89.8% on LongMemEval and 87.1% on LoCoMo with vector-only retrieval, no graph database, no multi-query orchestration.
Every post ships with code you can run
The commands in these posts run against the open-source memory agent. Star the repo and try them on your own agents.
pip install memanto