Your Agents Don’t Need Another Memory API. They Need a Memory Agent.

What changes when memory stops being a place your agent drops text and starts being something that works for it. A user’s-eye tour of Memanto, and fifteen reasons to try it on your next agent.

You have probably met this bug. It never throws an exception, and no test catches it.

Your coding agent agreed on Monday to use Postgres for the new service. On Thursday it scaffolds MongoDB. Your support agent learned last month that a customer moved from the finance team to marketing, and today it routes her ticket to finance anyway. Your Cursor session has no idea what Claude Code decided an hour ago in the next terminal.

None of these are model failures. The model did exactly what its context told it to. The failure is in what it was told: a memory that holds text but does nothing with it.

Most agent memory today is a memory API. You call add, you call search, and everything between those two calls is your problem. Which memory is stale? Which two contradict each other? Which one came from a guess rather than something the user actually said, and which tool wrote it?

Memanto takes a different position. It is a memory agent: a companion that does the work of keeping your agents’ memory true, so your agents can spend their context on the task in front of them.

Full disclosure: I’m the CTO of the team that builds Memanto, and it is open source under the MIT license. I’ll try to earn your attention the honest way. Every claim below points to behavior you can check in the docs or reproduce in an afternoon, and near the end I’ll tell you where it is still young.

From memory API to memory agent

The difference is where the work happens. With a memory API, your agent writes and reads, and the memory sits still in between. With a memory agent, a second, specialized agent works on the memory between those moments, the way a good chief of staff works on the briefing book between meetings.

Memanto’s work comes down to five verbs:

• Curate. Every memory arrives typed, scored for confidence, and labeled with where it came from and which tool wrote it.
• Reconcile. When two memories disagree, Memanto surfaces the conflict and lets you, or a rule you wrote, decide. Nothing is quietly overwritten.
• Consolidate. On a schedule, it summarizes the day, scans for contradictions, and retires what your policy says is stale, reversibly.
• Brief. When an agent asks, it gets a grounded answer or a short sourced brief, not a pile of loosely related snippets.
• Provision. The right memories reach every tool you work in, from Claude Code and Cursor to CrewAI and a voice agent.

Everything else in this article hangs off those five verbs. The short version is the line we put on the box: Your agents focus. Memanto remembers.

Two minutes to a first memory

Before the differences, here is how small the starting surface is. Install it, create an agent, and talk to its memory:

pip install memanto
memanto                         # one-time setup: free cloud key, or a fully local backend
memanto agent create my-project
memanto remember "We use PostgreSQL 16 as the primary database" --type decision
memanto recall "what database are we on?"
memanto answer "What have we decided about the data stack?"

The same install gives you a Python client that runs in-process, with no server to start:

import time
from memanto import Memanto

memanto = Memanto(agent_id="my-project")
memanto.remember("Alex prefers oat milk.", type="preference")
time.sleep(1)  # new memories become searchable in under a second
print(memanto.recall("what does Alex drink?")["memories"])

There is also an official TypeScript SDK on npm, a REST server (memanto serve), an MCP server and a Docker image. The installation guide covers each one.

Curate: memory that knows what it is

1. Every memory has a type, and the type does work

Memanto has 13 memory types: fact, preference, decision, commitment, goal, event, instruction, relationship, context, learning, observation, error and artifact. You can filter recall by them, but the bigger point is that the system acts on them.

Under every built-in expiry preset, preferences, instructions and relationships never expire on their own, while transient context ages out. Only instructions, preferences and goals get synced into your coding agent’s CLAUDE.md or AGENTS.md. A crash in your traces is filed as an error, a failed eval as a learning. A decision is not a passing observation, and memory that can't tell them apart forces your agent to treat both the same way.

2. Every memory says how sure it is, where it came from, and who wrote it

Each memory carries a confidence score from 0 to 1 (default 0.8), a provenance label and a source. Provenance records how the memory came to exist: an explicit statement, an inference, a correction, a validation, an observation, or an import from another system. Source records the writer: the user, an agent, or a named tool such as Cursor or Claude Code.

This matters the first time your agent acts on something a user never said. With provenance on every memory, memanto recall "..." --min-confidence 0.8 is a flag, and a policy rule that expires inferred memories under 0.6 confidence after 30 days is three lines of YAML.

Attribution is careful by design. Memanto identifies the calling tool from an explicit flag or header, the MCP handshake, or environment markers, and otherwise labels the call unidentified rather than guessing. The docs’ reasoning is simple: a wrong label on a dashboard is worse than no label.

3. It can pull memories out of a conversation, and you look first

Give Memanto a chat transcript of up to 200 messages and it extracts typed, de-duplicated, confidence-scored candidates. Add --dry-run to see them before anything is saved. Secrets, API keys and tokens are excluded, and every extracted memory is tagged so you can review or expire the batch later.

memanto remember --from-conversation chat.json --dry-run

Reconcile: contradictions get a hearing, not a coin flip

4. Conflicts are surfaced, not silently decided

Every long-lived memory eventually holds two things that can’t both be true. “Customer is in the finance team.” A week later: “Customer moved to the marketing team.”

The field has tried two answers. One resolves at write time: an LLM compares each new fact with old ones and emits add, update or delete. That keeps things tidy, but a developer writing in August 2026 showed how such a resolver (Mem0’s, in his example) can quietly delete a preference that was still true in a different context (DEV Community). The other appends everything and lets retrieval ranking sort it out at read time. Mem0’s v3 platform takes that road: nothing is overwritten or deleted, and old and new facts both persist (Mem0 docs). That is lossless, but the contradiction is still sitting there, and your agent meets it mid-task. Graph-based systems such as Zep invalidate the older fact automatically and keep its validity window (Zep docs), which is a thoughtful middle ground, but the system still makes the call for you.

Memanto takes a third road. A conflict-detection pass reads a day’s memories, finds the pairs that disagree, and writes a report. You resolve each conflict from the CLI, the web dashboard or the API: keep the old one, keep the new one, keep both, remove both, write a merged replacement, or expire either or both. Memanto recommends the newer memory when that is the likely answer, but the decision is yours.

memanto detect-conflicts
memanto conflicts

The docs recommend expiring the losing memory rather than deleting it, because expired memories keep their history. Which brings us to forgetting.

5. Forgetting is reversible, and it leaves a paper trail

Memanto’s lifecycle has exactly two states: active and expired. Expiring a memory keeps its content and timestamps and stamps it with when and why it was retired: a named policy rule, a retention entry, a manual action or a conflict resolution. Restoring it clears the stamp. Recall returns both states by default, each clearly labeled.

Your forgetting rules live in a per-agent YAML policy: a retention table by memory type, plus ordered rules that match on type, tags, source, provenance and confidence. Here is the rule from earlier, expiring weak inferences after a month:

- name: stale-inferences
  match: { provenance: [inferred], confidence_below: 0.6 }
  expire_after: 30d

Three presets (conservative, balanced and aggressive) get you started, and all of them leave preferences, instructions, relationships and anything tagged pinned alone. Editing a memory resets its clock, because an edit is evidence it is still alive. Preview any sweep before it runs:

memanto policy apply-preset balanced
memanto policy apply --dry-run

Permanent deletion is a separate, explicit step that is off by default. If you have ever had to explain to a reviewer why your agent “forgot” something, you will appreciate the difference between expired and gone.

6. You can ask what the agent knew last Tuesday

Recall works across time, not only meaning. --as-of reconstructs memory as it stood at a moment, so a memory expired since then still shows as active, the way it was. --changed-since returns what was created or updated after a date, each labeled as created or updated. --recent lists the newest first. Plain phrases such as yesterday and last 3 days work too.

memanto recall --as-of 2026-09-15
memanto recall --changed-since "last week" --type decision

Temporal awareness is not unique to Memanto: Zep tracks validity windows, and Mem0 added time-aware ranking this year. What Memanto adds is time travel as an explicit query. When an agent makes a bad call, you can see exactly what it could have known when it made it.

Consolidate: a nightly routine for your memory estate

7. Memory gets tended while you sleep

memanto schedule enable sets up one nightly job that runs three steps in order: a written summary of the day's memories, a conflict-detection pass, then an expiry sweep under each agent's policy. Permanent deletion is never part of it.

The summary lands as a Markdown file per agent per day. The conflict report waits for you in the CLI and the dashboard. You start the morning with a memory estate that was reviewed overnight, instead of one that quietly grew.

8. Production failures become lessons, once

If you run agents in production, this is the feature I would point you to first. Memanto can read your Langfuse traces and turn what went wrong into durable memory. Errors become error memories, latency and cost outliers become observations, and failed or passed evals become learnings.

It groups failures by signature, stripping volatile details such as IDs, numbers, emails and paths, so a thousand copies of one failure become one memory. In the docs’ own example, 812 observations collapsed into 2 memories.

Confidence grows with recurrence: one occurrence scores 0.60 and a hundred score 0.90. Re-running the sync never duplicates, and a recurring failure updates its existing memory in place. You can sync from the CLI, or attach a live handler with two lines of Python that runs off your hot path and never throws into your app.

Your traces record what went wrong. Memanto keeps the lesson where your agent will find it next time.

Brief: answers, not dumps

9. Agents get a brief, not a pile of snippets

Memanto is built on a principle the docs call “queryable, not injectable”: agents ask memory for what they need, when they need it, instead of hauling a pre-assembled block of context into every turn.

memanto answer returns a written answer grounded in the agent's memories. In Claude Code, a memory-scout subagent runs several recalls in parallel and returns a short, sourced brief, and it surfaces contradictions instead of quietly picking a winner. The same integration tells the agent never to claim it lacks context without checking memory first. And memanto agent bootstrap produces a snapshot of what an agent knows, organized by type, which is handy for onboarding a teammate or running an audit.

Where an up-front briefing does make sense, such as the start of a voice call, it is small and bounded. The Vapi integration hands the assistant at most 10 recent and 10 relevant memories per section, capped at 4,000 characters.

10. A memory is recallable the moment it’s written, and recall is repeatable

Writes become searchable in under a second, with no indexing step to wait out. That sounds like a detail until two agents are working side by side and one needs what the other just learned.

Recall is also exact rather than approximate: the same query over the same memories returns the same result every time. When you are debugging an agent, rerunning a recall and getting the same answer is the difference between a reproducible bug and a ghost.

Provision: one memory estate, every tool

11. Your tools stop keeping separate notebooks

Most developers now use more than one agent in a day. Memanto connects to 14 coding agents with one command each: Claude Code, Cursor, Codex CLI, Windsurf, Gemini CLI, GitHub Copilot, Cline, Continue, Goose, Roo Code, OpenCode, Antigravity, Augment and Pi.

memanto connect claude-code
memanto connect multi        # pick several tools at once

memanto memory sync writes an agent's standing instructions, preferences and goals into each tool's own instruction file, such as CLAUDE.md or AGENTS.md, between marker comments, so a rule you set once reaches every tool. Only active memories with confidence of 0.8 or higher make the cut, and nothing outside the markers is touched.

Beyond coding tools, there is an MCP server with seven memory tools, a VS Code extension, and integrations for LangChain, LangGraph, LlamaIndex, CrewAI, AG2, Google ADK, Amazon Bedrock AgentCore, Pydantic AI, n8n, the Vercel AI SDK, Mastra, VoltAgent, the OpenAI SDK, Hermes and Vapi voice agents. The integrations overview has the full list.

12. You can see who touched memory, and what it holds

Memanto ships a local web dashboard (memanto ui). The Connections view shows which tools touched memory in the last few minutes, plus a per-session timeline of every read and write by tool. The activity log behind it records the tool, the operation and a count, never memory content.

The rest of the dashboard covers what you want once memory matters: a memory explorer, a history timeline with a year-long activity heatmap, side-by-side conflict resolution, an expiry-policy editor, and analytics that include a confidence distribution and breakdowns by source and type.

Own it: your memory estate is yours

13. Open source, and portable in both directions

Memanto is MIT-licensed and on GitHub. Your memory estate exports as a single Markdown file or as an Open Knowledge Format (OKF) bundle, which the docs describe as an open, vendor-neutral spec from Google Cloud. An OKF bundle is a folder of Markdown files with YAML front matter, organized by memory type: browsable, diffable and git-friendly. Memanto’s own fields, such as confidence and provenance, survive the round trip.

memanto memory export --okf

Coming in is just as deliberate. memanto migrate imports from Mem0, Letta, Supermemory, Zep and Hindsight, as well as OKF bundles. Each import maps records onto Memanto's types, skips what the source itself had already retired, keeps anything it can't map in a supporting-data footer, and writes a preview before you commit.

memanto migrate mem0 --dry-run

We think the right way to keep users is to make leaving easy.

14. It runs where your data has to live

The cloud backend has a free tier: 500 credits a month, roughly 100,000 operations, up to five agents, no credit card. If your data can’t leave your building, the on-prem backend runs in Docker with Ollama for embeddings and answers. After the first model pull it makes no outbound calls, so it works air-gapped, with the same features as cloud.

The docs estimate 5 to 10 minutes for first on-prem setup, on a machine with at least 4 cores and 8 GB of RAM. There are Kubernetes manifests for production, and enterprises can run the backend in their own VPC on AWS or GCP.

15. Privacy is designed into the small decisions

Some details only show up when you read the design closely. Conversation extraction drops secrets. The dashboard and the VS Code extension only talk to a server on your own machine. In the Vapi integration, caller memory is keyed by an HMAC of the phone number, so raw numbers are never kept, and the model never passes a caller ID, so a prompt injection can’t reach another caller’s memories.

A word on benchmarks

Memanto’s paper reports 89.8% on LongMemEval and 87.1% on LoCoMo, with a step-by-step ablation and reproducibility appendices (arXiv:2604.22085). I’m mentioning them late on purpose.

Agent memory benchmarks are contested right now. Zep published a detailed critique of how Mem0 ran Zep on LoCoMo (Zep blog). A July 2026 analysis argued that the common LoCoMo harness leaves out the 446 adversarial questions where the right answer is to decline (DEV Community). Vendors’ numbers, ours included, are hard to compare across projects.

So judge any memory system, Memanto included, on behavior you can test. Does it tell you when two memories disagree? Can you undo a mistake? Can you see who wrote what? Can you leave? The evaluation at the end of this article takes about 30 minutes. We are working on deep research and more reliable and trusworthy benchmarking system for all agentic memories, stay tuned!

What to know before you adopt it

Memanto moves fast, and that cuts both ways. Version 0.2.26 shipped on October 2, 2026, and a few releases along the way carried breaking changes, so pin a version in production and read the changelog when you upgrade.

Conflict detection is a batch pass over a day’s memories, not a check on every write. If you need a contradiction caught the moment it is written, run detection more often or add your own guard. Also note that adopting a policy preset replaces the whole policy, including rules you wrote yourself.

Cloud and on-prem keep separate agent registries, so an agent created on one backend is not visible from the other. If you expect to move, export to OKF and import on the other side.

Finally, if what you want is an agent runtime with memory built into the agent itself, a platform like Letta, where agents run on its server and edit their own memory blocks through tools, is a different and legitimate design (Letta docs). Memanto is built for the other case: you keep the agents and frameworks you already have, and give them one memory agent to share.

A 30-minute evaluation you can run this week

1. Install it and connect the coding tool you use most: pip install memanto, then memanto connect <your-tool>.
2. Work normally for a session and let your agent save its decisions. The next day, ask it what was decided.
3. Plant a contradiction: memanto remember "The API allows 100 requests a minute" --type fact, then the same with 500. Run memanto detect-conflicts, then memanto conflicts, and expire the loser.
4. Bring it back with memanto memory restore <id>, then run memanto recall --as-of yesterday to see memory as it stood before today's changes.
5. Export with memanto memory export --okf and open the bundle in your editor.
6. If you already use another memory system, run memanto migrate <provider> --dry-run and read the preview.

If those six steps don’t change how you think about agent memory, you’ve lost half an hour. If they do, the docs, the Discord and r/Memanto are the next stop.

Memory is how agents get better

For two years we have judged agents mostly by what they can do inside a single context window. The next stretch is about what they carry forward: the decision from last week, the lesson from last night’s failed run, the preference a customer mentioned once and never had to repeat.

That only works if memory stays true as it grows. Curated, reconciled, consolidated, and briefed back at the right moment, a memory estate becomes something your agents get better with, instead of something they slowly drown in.

That future is closer than it looks, and every developer who gives their agents a memory worth trusting moves it a little nearer. Your agents focus. Memanto remembers.

Also plese don’t forget to check our Youtube channel

https://www.youtube.com/@moorchehai

Sources: Memanto docs · Memanto on GitHub · Memanto paper, arXiv:2604.22085 · Mem0 v2 to v3 migration guide · Zep: facts and temporal validity · Letta: stateful agents · DEV: Mem0 conflict resolution · DEV: the LoCoMo abstention gap · Zep: LoCoMo critique