{"slug": "show-hn-memanto-is-a-memory-agent", "title": "Show HN: Memanto Is a Memory Agent", "summary": "Memanto, a new memory agent for AI systems, launched via Show HN, enabling users to install it with 'pip install memanto' and manage memories across platforms like Claude, Bedrock, and Cursor. The tool performs six autonomous functions—observing, consolidating, reconciling, forgetting, briefing, and moving knowledge—and runs daily via 'memanto schedule enable'. Memanto exports memories in the Open Knowledge Format, supports macOS, Linux, and Windows, and offers a local dashboard via 'memanto ui'.", "body_md": "Memanto is a **Memory Agent**; a companion agent that manages the memories of your other agents:\n\nwhat to keep, what conflicts, what expires, and who needs to know.\n\n```\npip install memanto\n```\n\nEvery 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.\n\nPersistence 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.\n\nStorage 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.\n\nMemanto 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.\n\n| What Memanto does | Run it | |\n|---|---|---|\nObserves & extracts |\nWatches 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` |\nConsolidates |\nMerges extracted memories into one canonical estate. Duplicates collapse, fragments join, repeated observations strengthen confidence instead of multiplying rows. | `memanto schedule enable` |\nReconciles |\nWhen 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` |\nForgets |\nDecay, 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` |\nBriefs |\nBefore 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` |\nMoves knowledge |\nThrough 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` |\n\n**And it does this while you're asleep.** `memanto schedule enable`\n\nand 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.\n\n```\npip install memanto\nmemanto                            # \"On-Prem\" (Docker, no account) or \"Cloud\" (free key)\nmemanto connect claude-code        # also: cursor, codex, windsurf, cline, goose, copilot…\n```\n\nYour agents now share one managed estate. No code changes, no wrapper, no rewrite of your agent loop.\n\n```\n# backend-agent learns something on Monday\nmemanto remember \"Auth migrated to JWT — session cookies deprecated\" --type decision\n\n# review-agent, which never saw that session, knows it on Friday\nmemanto recall \"how does auth work\"\nmemanto answer  \"why did we drop session cookies?\"     # grounded, no extra API key\n\n# what did the fleet believe last Tuesday? what changed since the release?\nmemanto recall \"deployment policy\" --as-of 2026-08-05\nmemanto recall \"deployment policy\" --changed-since v2.1\n```\n\nmacOS, Linux, Windows. `memanto ui`\n\nopens a local dashboard over the whole estate — browse it, search it, audit it.\n\nThis is the part that matters in two years, and it's the part every platform-native memory feature is designed to prevent.\n\n**Your estate is a file.** `memanto memory export --okf`\n\ngives 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.\n\n**It moves.** `memanto migrate`\n\nimports from Mem0, Letta, Supermemory, 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.\n\n**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`\n\nswitches between them in one command, and the estate comes with you.\n\n**MIT.** No open-core tier waiting to gate the useful half. No feature flags, no seat limits, no rug pull.\n\nThere is no lock-in because there is nothing to lock.\n\n**Nothing leaves your machine in on-prem mode.** Docker + Ollama, no account, no outbound calls. The full loop — extraction, consolidation, reconciliation, briefing — runs locally.\n\n**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.\n\n**Every belief is traceable.** Confidence score, source, timestamp, and what it superseded. 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.\n\n| Memory storage | Memanto |\n|\n|---|---|---|\n| What it is | A database with an SDK — write, embed, retrieve | An agent with judgment over your fleet's memory |\n| Core behavior | Persist | Curate, reconcile, consolidate, forget, brief |\n| Who decides what's kept | You, in application code | Memanto, on policy you set once |\n| When two agents disagree | Last write wins, silently | Both versioned, surfaced for review |\n| Forgetting | A `DELETE` you remember to run |\nA first-class policy that runs on schedule |\n| Scope | One app, one stack, one vendor's walls | A fleet, across stacks and vendors |\n| Your data | Exportable in theory | The working format is portable Markdown |\n\nStorage substrates sit *beneath* Memanto — vector stores, filesystems, and platform-native memory features are all backends it manages. Their commoditization is good for you: it makes the substrate free and leaves the management to something that's actually good at it.\n\n**⭐ Star the repo if Memanto is managing your fleet's memory**\n\nIt's the signal that tells us to keep building this in the open, under MIT, with nothing held back.\n\n**One pip install.** No vector store to provision, no embedding pipeline, no reranker, no schema migration, no backend to babysit. The retrieval engine ships in the box.\n\n**Works with what you already run.** `memanto connect claude-code`\n\n— same for Cursor, Codex, Windsurf, Cline, Continue, Goose, Copilot, and more. One command each.\n\n**Searchable the moment it's written.** No extraction pass at write time, no graph to rebuild, no indexing queue. `remember`\n\nreturns and every agent in the fleet can already recall it.\n\n**Typed, not soup.** 13 memory categories — `instruction`\n\n, `fact`\n\n, `decision`\n\n, `goal`\n\n, `preference`\n\n, `relationship`\n\n, and more — so recall is filterable instead of one undifferentiated blob.\n\n**A dashboard, not a log file.** `memanto ui`\n\nfor the whole estate. `memanto daily-summary`\n\nfor a readable digest of what changed across your agents. `memanto status`\n\nfor registered agents, sessions, and health.\n\n**Full CLI reference**\n\n| Capability | Commands | What it does |\n|---|---|---|\n| System status | `memanto status` |\nEnvironment, configuration, server health, active session, registered agents. |\n| Local REST API + web UI | `memanto serve` , `memanto ui` |\nRun the REST API locally and open an interactive browser UI. |\n| Agent lifecycle | `memanto agent ...` |\nCreate/list/delete agents, activate sessions, run `agent bootstrap` . |\n| Memory capture at scale | `memanto remember` |\nSingle memories, batch JSON, or `--from-conversation` to extract from chat logs. |\n| Editing & deletion | `memanto edit` , `memanto forget` |\nUpdate fields on a memory, or permanently delete a bad one. |\n| File ingestion | `memanto upload` |\nBring .pdf, .docx, .xlsx, .json, .txt, .csv, .md into an agent's namespace. |\n| Advanced recall | `memanto recall` |\nStandard search plus temporal queries (`--as-of` , `--changed-since` ) with filters. |\n| Grounded answers | `memanto answer` |\nGenerate answers from retrieved memory context. |\n| Daily intelligence | `memanto daily-summary` , `memanto conflicts` |\nSummaries, contradiction detection, interactive resolution. |\n| Sessions & automation | `memanto session ...` , `memanto schedule ...` |\nInspect sessions, enable scheduled daily runs. |\n| Estate export & sync | `memanto memory export` , `memanto memory sync` |\nExport structured Markdown, sync `MEMORY.md` into projects. `--okf` for a portable\n|\n| Import & migration | `memanto migrate` |\nImport from Mem0, Letta, Supermemory, or an OKF bundle. |\n| Configuration | `memanto config show` |\nAPI key status, active agent/session, server settings, schedule time. |\n| Fleet integration | `memanto connect ...` |\nClaude Code, Codex, Cursor, Windsurf, Antigravity, Gemini CLI, Cline, Continue, OpenCode, Goose, Roo, GitHub Copilot, Augment. |\n\n**Memory types:** `instruction`\n\n, `fact`\n\n, `decision`\n\n, `goal`\n\n, `commitment`\n\n, `preference`\n\n, `relationship`\n\n, `context`\n\n, `event`\n\n, `learning`\n\n, `observation`\n\n, `artifact`\n\n, `error`\n\n```\nmemanto remember \"User prefers concise answers\" --type preference\nmemanto recall \"user communication style\" --type preference\n```\n\nComplete reference: [CLI User Guide](https://docs.memanto.ai/cli)\n\n**Install options — fully local vs. free cloud**\n\n**Fully local. No account, no API key, nothing leaves your machine:**\n\n```\npip install memanto\nmemanto           # choose \"On-Prem\" — guides through Docker + Ollama setup\n```\n\nRequires Docker.\n\n**Free cloud. No card, ~60 seconds:**\n\n```\npip install memanto\nmemanto           # choose \"Cloud\" — paste your free API key\n```\n\nFree key at [console.moorcheh.ai/api-keys](https://console.moorcheh.ai/api-keys) — 100K free operations.\n\nSwitch any time: `memanto config backend`\n\n**Architecture**\n\nRecall is powered by an information-theoretic semantic engine that ships in the box — as a local Docker container or as a free cloud service. The `memanto`\n\nCLI manages either for you. Storage substrates beneath it are pluggable; Memanto is the agent above them.\n\n**On-prem:**\n\n**SDKs & REST API**\n\n**TypeScript / Node.js** — [ @moorcheh-ai/memanto](/moorcheh-ai/memanto/blob/main/sdks/typescript) boots a local Memanto server via\n\n`uvx`\n\nand exposes an ergonomic client (`remember`\n\n/ `recall`\n\n/ `answer`\n\n).**REST API** — start with `memanto serve`\n\n. Endpoint reference at [docs.memanto.ai/api](https://docs.memanto.ai/api) and `http://localhost:8000/docs`\n\nwhile running.\n\nRecall is more than search |\n\n**Setup & demo****Local dashboard tour****Docs →**[Memanto: Typed Semantic Memory with Information-Theoretic Retrieval for Long-Horizon Agents](https://arxiv.org/abs/2604.22085)\n\nOn public recall benchmarks we report 89.8% on LongMemEval and 87.1% on LoCoMo. Datasets and harness are open at [huggingface.co/moorcheh](https://huggingface.co/moorcheh) — run them yourself.\n\nA caveat we'd rather say out loud: cross-project scores on these benchmarks are not comparable. Reader model, judge model, judge prompt, and retrieval budget each move results by several points, and no two published runs share a configuration. Treat every number in this category — including ours — as directional. What a Memory Agent should eventually be measured on isn't recall at all, but estate quality over time: contradiction rate, staleness, and precision at month six.\n\n```\n@misc{abtahi2026memantotypedsemanticmemory,\n      title={Memanto: Typed Semantic Memory with Information-Theoretic Retrieval for Long-Horizon Agents},\n      author={Seyed Moein Abtahi and Rasa Rahnema and Hetkumar Patel and Neel Patel and Majid Fekri and Tara Khani},\n      year={2026},\n      eprint={2604.22085},\n      archivePrefix={arXiv},\n      primaryClass={cs.AI},\n      url={https://arxiv.org/abs/2604.22085},\n}\n```\n\nQuestions: [support@moorcheh.ai](mailto:support@moorcheh.ai) · [@moorcheh_ai](https://x.com/moorcheh_ai)", "url": "https://wpnews.pro/news/show-hn-memanto-is-a-memory-agent", "canonical_source": "https://github.com/moorcheh-ai/memanto", "published_at": "2026-08-19 04:01:37+00:00", "updated_at": "2026-08-19 04:41:08.787916+00:00", "lang": "en", "topics": ["ai-agents", "ai-tools", "ai-infrastructure"], "entities": ["Memanto", "Claude", "Bedrock", "Cursor", "Open Knowledge Format"], "alternates": {"html": "https://wpnews.pro/news/show-hn-memanto-is-a-memory-agent", "markdown": "https://wpnews.pro/news/show-hn-memanto-is-a-memory-agent.md", "text": "https://wpnews.pro/news/show-hn-memanto-is-a-memory-agent.txt", "jsonld": "https://wpnews.pro/news/show-hn-memanto-is-a-memory-agent.jsonld"}}