memU
memU is an open-source memory layer that lets Codex, Claude Code, Cursor and other agents share one inspectable store of preferences, decisions and reusable skills, written as readable Markdown across sessions and devices.
What is memU?
memU is a memory layer for the AI agents you already run. It answers a narrow, well-defined problem: agents forget everything between sessions, so the same context has to be pasted again and again. memU gives Codex, Claude Code, Cursor, OpenClaw, Hermes and WorkBuddy a single shared store of preferences, decisions and learned skills, reachable from any of them and from any device.
The architecture is described as agent-driven. Judgment and synthesis stay inside the host agent; memU only stores, embeds and retrieves. The memory service itself makes no LLM or chat call, and its only model dependency is the embedding used for indexing and search. Each host adapter wires two seams into the agent's workflow: a record seam, where a scheduled bridge reads new sessions and prepares self-contained jobs, and an inject seam, a standing instruction that makes the agent retrieve relevant memory before it answers.
Installation is delegated to the agent. The user fetches an API key, pastes a short prompt, and the agent retrieves a canonical SKILL.md, identifies its own host, installs the matching adapter and verifies the record and retrieval paths. Running the same prompt in another host connects that agent to the same memory.
What gets stored is readable Markdown: recall files with a name, description, content and track; searchable text segments with their embeddings; and indexed workspace resources. Retrieval is embedding-only, with the query embedded once, segments ranked by vector similarity and matches rolled up to the complete file. There is no BM25 fusion, no graph traversal, no query rewriting and no summarisation step. Not every session becomes memory either: the bridge prepares, the agent decides whether anything is worth keeping.
The project runs in two modes. memU Cloud is a managed, cross-device backend configured with an API key. Self-hosted mode keeps everything on the customer's own machine, on SQLite for single-device use or Postgres with pgvector for larger, concurrent stores, with an embedding provider chosen among OpenAI, Jina, Voyage, Doubao and OpenRouter. The code is open source under Apache-2.0, and an enterprise track is offered through scoped design-partner engagements.
What it does
- Give several AI agents one shared memory of preferences, decisions and conventions
- Turn useful session history into reusable Markdown skills automatically
- Retrieve the right context before a task through embedding-based search
- Inspect, edit and audit every remembered fact as a plain Markdown file
- Carry a convention learned in one agent straight into the next one you open
- Keep the whole memory store on your own infrastructure with SQLite or Postgres
- Separate contexts that must not mix, using distinct user and agent scopes
When to use memU / When not to
A quick filter to help you decide if memU is the right fit.
When to use memU
- Developers who switch between several coding agents on the same codebase and want conventions to survive the switch
- AI and ML engineers assembling agent stacks who need a memory backend they can inspect and self-host
- Startup founders and CTOs who want project decisions and constraints to outlive individual sessions
- Support and customer success teams reusing customer context and durable playbooks across conversations
- Researchers and technical writers who prefer source-linked Markdown notes to opaque vector records
When not to use memU
- Teams that need a documented public memory API: memU deliberately ships host adapters and a CLI instead
- Buyers who must budget before talking to a vendor, since no price list is published anywhere
- Organisations under strict European compliance duties: the site never mentions the GDPR and publishes no processing agreement
- Mobile-first users, as there is no iOS or Android application
- Non-technical users whose agent has no dedicated adapter and no session logs the generic detector can read
How to use memU
A typical end-to-end flow, from setup to results.
- Get a memU Cloud API key from the account site, or clone the open-source repository if you intend to self-host
- Copy the installation prompt displayed with your key and paste it into a new session of your agent
- Let the agent fetch the canonical SKILL.md, using the key as a Bearer token in the Authorization header
- Wait while the agent identifies its own host and installs the matching adapter
- Let it configure the shared backend and verify the record and retrieval seams
- For self-hosting, configure an embedding provider and pick SQLite, Postgres with pgvector, or the in-memory backend for tests
- Run the same installation in every other agent you want connected to the same memory
- If your agent has no dedicated adapter, run the generic detector to check its session logs and instruction file
- Run the adapter's doctor command to confirm the resolved configuration and perform a live retrieval
- Set distinct scope values whenever two contexts must stay apart, then review the Markdown files memU has committed
Pros & Cons
Pros
- Memory stays readable Markdown, inspectable before and after commit, instead of an opaque vector store
- The memory service makes no LLM call, so it adds no second inference bill on top of your agent
- One backend shared by several agents: a convention learned in Codex is available in Cursor or Claude Code
- Open source under Apache-2.0, with the package, CLI, installation skill and adapters all public
- Self-hosting keeps the entire store on customer-controlled infrastructure
- Setup is delegated to the agent itself, with no API integration to design or maintain
- The agent decides what is worth keeping, so transcripts are not archived indiscriminately
Cons
- No public pricing at all: no pricing page on the site, and the application domain returns a 404
- No public API documentation, and the documentation URL simply serves the homepage
- The GDPR is never mentioned, and no processing agreement, subprocessor list or certification is published
- No postal address appears anywhere, including in the privacy policy and the terms
- No documented way to exclude your data from training, while the policy allows memory data to be analysed
- Prepaid service credits are non-refundable and expire one year after purchase or issuance
- The headline LoCoMo benchmark is presented by the vendor itself as outdated for the current architecture
Pricing & Plans
memU can be used at no charge: the homepage advertises a free install, the site's own structured data declares an offer at USD 0, and the self-hosted edition is published under the Apache-2.0 licence. No paid price point is public. The vendor operates a prepaid service credit system, described at length in its Service Credits Terms without a single published amount, while enterprise and custom agreements set their own credit terms, usage limits and billing arrangements contract by contract. Self-hosting carries an indirect cost, since the customer supplies their own embedding provider credentials.
- memU Cloud — managed
- cross-device backend configured with a memU Cloud API key
- Self-hosted — private storage under the customer's control
- on SQLite or Postgres
- with their own embedding provider credentials
- Enterprise — custom memory systems
- private deployment and agent integration
- delivered through scoped design-partner engagements
- Prepaid Service Credits — bought in advance and redeemed against services
- with no amount published
Data, GDPR & hosting
A consolidated view of how memU handles your data.
GDPR overview
There is no mention of the GDPR anywhere on the site: neither the privacy policy, nor the Service Credits Terms, nor any product page refers to the regulation, and no Article 27 EU representative or data protection officer is named. The only privacy framework cited by name is the Californian CCPA. The policy states that the services are operated from the United States and that international transfers rely on appropriate safeguards such as Standard Contractual Clauses or adequacy decisions, which is the single European-facing element on record. Access, portability, correction, deletion and processing-restriction rights are offered, but as contractual commitments rather than as GDPR obligations. No data processing agreement is published or offered on request, and no subprocessor list exists.
Who owns the data?
The privacy policy in force since 1 October 2025 is published by MemU Technologies, Inc., which collects account, billing, profile, usage, device and log data, plus a dedicated AI Memory Data category covering the conversations and documents a user chooses to memorise. The company states that it does not sell, trade or rent personal information, and shares it only with service providers, in a business transfer, under legal compulsion, or with explicit consent. Users are offered access and portability, correction, deletion, marketing opt-out and processing-restriction rights. In self-hosted mode the store sits on customer infrastructure, so the vendor never holds the content at all.
Reuse rights
Memory and skill files are written by the user's own agent and stay readable Markdown, so they can be opened, edited, exported or deleted at will; the policy grants access, portability and download through account settings or on request, with no permission step. In return, MemU reserves the right to analyse memory data to improve its services, generate insights and personalise the experience, subject to the account's privacy settings, and content may be processed by third-party AI providers such as OpenAI and Anthropic when those integrations are used. No opt-out from model training is documented anywhere. Self-hosted deployments keep the files entirely under the customer's own control.
Data retention & training
Hosting summary
The privacy policy states that the services are operated from the United States, and that information may be transferred to, stored and processed in the United States and other countries. No specific hosting country beyond that, and no cloud provider, is named. International transfers are said to rely on appropriate safeguards such as Standard Contractual Clauses or adequacy decisions. Announced security measures include encryption in transit and at rest using AES-256 and TLS, multi-factor authentication and internal access controls, regular security audits and vulnerability assessments, staff training and background checks, and incident response procedures. No subprocessor list is published. Self-hosted deployments change the picture entirely: memory lives on the customer's own machine or infrastructure, in SQLite or Postgres, and the enterprise track offers customer-controlled storage and embedding infrastructure. Note that the site's domain resolves to a Cloudflare anycast address, which says nothing about where user data is actually held.
Things to keep in mind
Risks and trade-offs to weigh before adopting memU.
- Memory content is stored and may be analysed by the vendor to improve its services, with no documented way to opt out
- Memorised conversations and documents can be processed by third-party AI providers such as OpenAI and Anthropic
- No postal address is published, and the legal and privacy contacts sit on a different domain from the site itself
- European users have no Article 27 representative, no processing agreement and no subprocessor list to rely on
- Installation asks an agent to fetch a remote instruction file with an API key, a supply-chain step worth reviewing in a corporate setting
- Delegating recall to a shared store can erode the habit of restating context deliberately, and a wrong memory quietly propagates to every connected agent
- Prepaid service credits are non-refundable and expire one year after purchase or issuance
Setup & Integrations
Technical difficulty
Low on the managed path, provided you already run a supported agent: you fetch an API key, paste one prompt, and the agent installs and verifies its own adapter, which the site calls a one-click install. Self-hosting is markedly harder, since you must configure an embedding provider with its key, model and optional base URL, then set up SQLite or Postgres with pgvector. Everything runs from the command line, with a doctor command for diagnosis. There is no public API documentation and no administration interface outside memU Cloud.
Deployment
Integrations
Behind memU
Social
Resources
All the official URLs gathered for verification and reference.
Alternatives
Tools that compete with or complement memU.
Frequently asked questions
What exactly does memU do?
Which agents are supported?
Does memU call a language model of its own?
Can I read what memU has remembered?
Is there an API I can integrate against?
How much does it cost?
Can I keep the data on my own infrastructure?
Is memU GDPR compliant?
Is there a minimum age?
Should you pick memU?
memU occupies a narrow and clearly argued position: it is not another agent, but the memory those agents lack. The technical story is unusually legible for a young project — an embedding-only retrieval path, no language model call inside the memory service, readable Markdown instead of opaque vectors, and a repository published under Apache-2.0 that anyone can inspect before committing to anything. For a developer already juggling Codex, Claude Code and Cursor on the same codebase, the promise that a convention learned once survives the switch is concrete and cheap to test.
The reservations are just as clear, and they concern the company more than the product. No price is published anywhere, so the cost of the managed tier cannot be estimated before a conversation. No postal address appears on any page, and the legal and privacy contacts sit on a neighbouring domain rather than on the site's own. The GDPR is never mentioned, no processing agreement or subprocessor list exists, and the privacy policy allows memory content to be analysed with no documented opt-out — a combination that will stop most European compliance reviews. The vendor is candid about its own headline benchmark being outdated, which speaks well of it, but it also leaves current performance undocumented.
The sensible way in is the one the project itself suggests: install the open-source edition, keep the store on your own machine, and judge retrieval quality on real sessions before considering the managed backend. Teams with strict data-governance obligations should settle the hosting, retention and training questions in writing first.
- Choosing a selection results in a full page refresh.
- Opens in a new window.