memanto

<p align="center">
  <a href="https://www.memanto.ai/">
    <img alt="Memanto" src="https://github.com/moorcheh-ai/memanto/raw/main/assets/memanto-logo.svg" width="440">
  </a>
</p>

<h3 align="center">Memory that AI Agents Love!</h3>

<p align="center">
  Memanto is a <strong>Memory Agent</strong>; a companion agent that manages the memories of your other agents:<br>
  what to keep, what conflicts, what expires, and who needs to know.
</p>

<p align="center">
  <a href="https://github.com/moorcheh-ai/memanto"><img alt="GitHub stars" src="https://img.shields.io/github/stars/moorcheh-ai/memanto?style=social"></a>
  <a href="https://pepy.tech/projects/memanto"><img alt="Downloads" src="https://static.pepy.tech/personalized-badge/memanto?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads"></a>
  <a href="https://arxiv.org/abs/2604.22085"><img alt="arXiv" src="https://img.shields.io/badge/arXiv-2604.22085-b31b1b.svg"></a>
  <a href="https://pypi.org/project/memanto/"><img alt="PyPI" src="https://img.shields.io/pypi/v/memanto.svg?color=%2334D058"></a>
  <a href="https://opensource.org/licenses/MIT"><img alt="MIT License" src="https://img.shields.io/badge/license-MIT-yellow.svg"></a>
</p>

<p align="center">
  <sub><a href="README.md">English</a> · <a href="i18n/README_es.md">Español</a> · <a href="i18n/README_zh-CN.md">简体中文</a> · <a href="i18n/README_ja.md">日本語</a></sub>
</p>

```bash
pip install memanto
```

```bash
npm install @moorcheh-ai/memanto
```

<!-- ============================================================
     DEMO GIF — highest-impact missing asset. assets/demo.gif
     VHS tape provided separately. Under 15s, under 3MB.
     ============================================================ -->

<!-- <p align="center">
  <img alt="Memanto in 15 seconds" src="https://github.com/moorcheh-ai/memanto/raw/main/assets/demo.gif" width="900">
</p> -->

---

> **Every platform will store your agents' memory. None of them will manage it.** Managing it across platforms is against their interest. That is the job of a Memory Agent.

Persistence is solved. Claude, Bedrock, Cursor, and every vector store will happily keep what your agents write. None of them will tell you that two of your agents now believe opposite things about your auth service, that a preference from March has quietly outranked a decision from last week, or that the agent you spun up this morning is about to redo work another one finished and reverted.

Storage is a filing cabinet. Memanto is the chief of staff; it decides what goes in, watches the access, resolves what contradicts, discards what's stale, and briefs each agent before it acts.

---

## It's an agent, not an API

Memanto isn't a library you call. It's a second agent that runs beside your fleet and does six things on its own judgment. Each one is a real behavior with a command behind it, nothing here is a roadmap item.

| | What Memanto does | Run it |
|---|---|---|
| **Observes & extracts** | Watches the interaction streams of the agents it serves and pulls durable knowledge out of ephemeral traffic — decisions, preferences, facts, failures — instead of archiving transcripts wholesale. | `memanto remember --from-conversation` |
| **Consolidates** | Merges extracted memories into one canonical estate. Duplicates collapse, fragments join, repeated observations strengthen confidence instead of multiplying rows. | `memanto schedule enable` |
| **Reconciles** | When new knowledge contradicts old, Memanto supersedes rather than appends — preserving what was believed and when. "What's true now" and "what did we believe then" stay different questions. | `memanto conflicts` |
| **Forgets** | Decay, expiry, and deliberate deletion are policies it executes, not cleanup you remember to do. An estate that only grows becomes noise; managed forgetting is what keeps recall sharp at month twelve. | `memanto forget` |
| **Briefs** | Before an agent acts, Memanto hands it the minimal relevant slice of the estate. Your agents don't query anything — they get briefed by a colleague. | `memanto agent bootstrap` |
| **Moves knowledge** | Through the Open Knowledge Format, the estate crosses frameworks and vendors — so a fleet spanning Claude Code, Cursor, and your own stack shares one memory instead of five silos. | `memanto memory export --okf` |

**And it does this while you're asleep.** `memanto schedule enable` and the loop runs daily: new memories curated, duplicates merged across agents, contradictions flagged for your review. You come back to a fleet that knows more than it did yesterday, without having sorted anything yourself.

---

## 60 seconds to a managed fleet

```bash
pip install memanto
memanto                            # "On-Prem" (Docker, no account) or "Cloud" (free key)
memanto connect claude-code        # also: cursor, codex, windsurf, cline, goose, copilot…
```

Your agents now share one managed estate. No code changes, no wrapper, no rewrite of your agent loop.

```bash
# backend-agent learns something on Monday
memanto remember "Auth migrated to JWT — session cookies deprecated" --type decision

# review-agent, which never saw that session, knows it on Friday
memanto recall "how does auth work"
memanto answer  "why did we drop session cookies?"     # grounded, no extra API key

# what did the fleet believe last Tuesday? what changed since the release?
memanto recall "deployment policy" --as-of 2026-08-05
memanto recall "deployment policy" --changed-since v2.1
```

macOS, Linux, Windows. `memanto ui` opens a local dashboard over the whole estate — browse it, search it, audit it.

---

## Own your agentic memory

This is the part that matters in two years, and it's the part every platform-native memory feature is designed to prevent.

**Your estate is a file.** `memanto memory export --okf` gives you the [Open Knowledge Format](https://docs.memanto.ai/integrations/okf) — plain Markdown, readable, diffable, committable, greppable. Not a proprietary dump you can technically request. The actual working format.

**It moves.** `memanto migrate` imports from Mem0, Letta, Supermemory, Zep, Hindsight, or any OKF bundle. The same command works in reverse. OKF is an open interchange format any framework or vendor can implement — including ours' competitors, deliberately.

**It runs on your machine.** Local Docker + Ollama, no account, no API key, nothing leaves your infrastructure. Or free cloud, or your own hosting. `memanto config backend` switches between them in one command, and the estate comes with you.

**MIT.** No open-core tier waiting to gate the useful half. No feature flags, no seat limits, no rug pull.

There is no lock-in because there is nothing to lock.

---

## Security & sovereignty

<!-- ============================================================
     TODO — Majid: fill from your hardening work. Structure is
     right; the specifics are yours. Items marked ⟨…⟩ need input.
     Anything you can't substantiate today, delete rather than soften.
     ============================================================ -->

**Nothing leaves your machine in on-prem mode.** Docker + Ollama, no account, no outbound calls. The full loop — extraction, consolidation, reconciliation, briefing — runs locally.

**Scoped by default.** Each agent gets its own namespace. Your production-ops agent doesn't read your scratch experiments; you provision exactly what each one should know and nothing more.

**Every belief is traceable.** Confidence score, source, provenance, and timestamp. When an agent acts on something, you can walk back to where that belief entered the fleet and when — which is the difference between an auditable estate and a black box.

**Forgetting is a decision you make, not a side effect.** A memory is `active` or `expired` — nothing else. It becomes expired only because a policy you wrote says so, and it carries the date and the rule name that did it. Expired memories still recall, clearly labelled, and `memanto memory restore` puts one back. Deleting is a separate, explicit act.

---

## Memory that expires on your terms

Every memory is **active** until a policy retires it. Expiry is stamped, auditable, and reversible — the content survives, and the memory keeps showing up in recall marked `[EXPIRED]` with the reason it aged out.

```bash
memanto policy list-preset          # conservative / balanced / aggressive
memanto policy apply-preset balanced  # shows it in full, then asks
memanto policy apply --dry-run      # exactly what would expire, per rule
memanto policy apply                # shows the policy + matches, then confirms
```

Policies live in `~/.memanto/policies/<agent>.yaml` and have two halves — a per-type retention table for broad strokes, and named rules for everything sharper. The first matching rule wins, so a rule can also *pin* a memory that the table would otherwise expire:

```yaml
retention:
  context: 7d
  event: 30d
  preference: never          # durable user truths don't age out
rules:
  - name: pinned
    match: {tags: [pinned]}
    expire_after: never      # an explicit pin beats the table
  - name: low-confidence-guesses
    match: {provenance: [inferred], confidence_below: 0.5}
    expire_after: 14d
purge_expired_after: never   # optional hard delete, off by default
```

Recall shows both states side by side; narrow with `--active` or `--expired`. Point-in-time recall is unaffected — `--as-of` still reconstructs what was true then, including memories that have expired since.

```bash
memanto memory expire mem-123       # retire one by hand
memanto memory restore mem-123      # and put it back
```

The nightly job (`memanto schedule enable`) runs the sweep for you. An agent with no policy set never expires anything.

---

## Unlike memory storage

| | Memory storage | **Memanto** |
|---|---|---|
| What it is | A database with an SDK — write, embed, retrieve | An agent with judgment over your fleet's memory |
|