Memty: your AI memory, owned by you

The problem

Every chat starts from zero.

You explain your project, your stack, and your preferences again and again. When an assistant does remember, that memory is locked inside one company's product, mixed with everything else, and hard to inspect.

PROBLEM 01

You repeat yourself

Each new chat, tool, or model needs the same background again. That costs time and tokens, and things get missed.

PROBLEM 02

Memory is locked in

What ChatGPT knows about you doesn't help in Claude, Gemini, or your code editor. Switching tools means starting over.

PROBLEM 03

You can't see or control it

Built-in memories are opaque. It's hard to tell what was stored, fix what's wrong, keep secrets out, or delete something for good.

What Memty does instead

One vault, every AI

A single local file that works with chat websites, MCP clients, the clipboard, and Python.

Small, clear facts

Memory is stored as short Title: value facts, not long transcripts, so it stays accurate and cheap to send.

You approve everything

Facts from chats are only proposals. You edit or untick them before anything is saved.

Private by default

Nothing leaves your computer until you press Send. Private facts appear to AIs only as [private].

How it works

Save once. Recall anywhere.

Everything runs on your machine. Every assistant reaches the same vault through one local daemon: browser chats through a small local bridge, desktop and coding agents through the Model Context Protocol, and you through the terminal. Nothing is synced between apps. They all read the same file.

Chat websitesChatGPT · Claude.ai · Gemini · PerplexityMemty Bridge extension in Chrome, Edge, or Brave

Desktop & coding agentsCursor · Claude Code · Codex · VS Code · Windsurf · Claude DesktopAny MCP client

Terminalmemty remember · recall · clip · scan · inbox · reportThe memty CLI

memty serveBridge on 127.0.0.1:8765. Needs the pairing token and an approved extension. Starts at login.

memty mcpStarted by each client over stdio, no port. Tools memty_sync, memty_propose, memty_drill.

CLITalks to the daemon directly. Every command works on the same vault.

memtyd: one local daemon per vaultStarted automatically by whichever tool needs it first. A lock file allows only one per vault. It listens on a random loopback port with a secret token, handles one request at a time so two tools can never overwrite each other, and runs the privacy gate on everything it hands out.

~/.memty/ledger.sqlite3: your vaultOne SQLite file on your disk: facts, rules, summaries, archived sources, version history, the proposal inbox, and receipts. No cloud, no sync, no account.

Connections and ports

Piece	How it's reached	Who may connect
memtyd	`127.0.0.1`, random port, recorded with a secret token in `ledger.sqlite3.daemon.json`	Local processes that can read that file. Every request carries the token, and only a fixed list of vault operations is accepted.
Browser bridge	`127.0.0.1:8765` (change with `--port`)	Only extensions you paired. Web pages, other hosts, and other origins are refused.
MCP server	stdio, no network port	Only the app that started it, such as Cursor or Claude Code
CLI	Directly to memtyd	You, in your terminal

A fact's journey: from ChatGPT to Cursor

01Select
In ChatGPT you select "We deploy on Fly.io" and click ＋ Save to Memty.
02Propose
The bridge turns the selection into short facts on your computer, with no model call. You review and save.
03Store
memtyd writes deploy_target: Fly.io into the project.api namespace as a confirmed fact.
04Recall
In Cursor the agent calls memty_sync for project.api. memtyd builds a 120-token capsule and runs the privacy gate.
05Receipt
Cursor gets Deploy target: Fly.io. A receipt records that one fact was served, without its value.

Five ideas behind it

01Atomic facts
One value per namespace.slot, at most 40 tokens. Saving a new value replaces the old one and keeps the history.
02Namespaces
Separate contexts such as work.project or personal. A chat only gets the namespace you choose.
03The compiler
Builds a small capsule per request: newest facts first, or the most relevant ones for a question, under a hard token budget.
04Privacy gate
Every capsule is checked: private values are masked, secrets stop the request, blocked providers get nothing.
05You decide
Proposals need your approval, from chats and from agents. Your own facts can't be overwritten automatically. Deleted means deleted.

Proof: tokens and accuracy

Fewer tokens. More exact answers.

We passed one architecture handoff between Claude and Gemini over five turns, three ways: replaying the full documents, sending retrieved snippets, and sending a selected Memty context. Token counts are what the providers reported. Each run made real, billable API calls.

VS FULL REPLAY

61.1%

fewer input tokens: 5,448 vs 13,989 across three runs

VS RETRIEVED SNIPPETS

42.0%

fewer input tokens: 5,448 vs 9,386

EXACT ANSWERS

30/30

expected values returned exactly. Both baselines: 27/30.

MEMORY PAYLOAD

88%

smaller memory payload than the full documents (445 vs 3,710 estimated tokens, five turns)

Input tokens, three live runs combinedClaude Haiku 5.5 and Gemini 2.5 Flash alternating · lower is better

Full document replay13,989

Simulated retrieval9,386

Selected Memty context5,448

Memory supplied over five turns, offlineMemty's token estimator, same fixture · lower is better

Full source documents3,710

Curated snippets + tools1,620

Selected Memty context445

Every run, as the providers reported it

Run	Context supplied	Input tokens	Output tokens	Exact answers
1	Full document replay	4,663	309	9/10
1	Simulated retrieval	3,148	463	9/10
1	Selected Memty context	1,816	204	10/10
2	Full document replay	4,663	308	9/10
2	Simulated retrieval	3,090	477	9/10
2	Selected Memty context	1,816	204	10/10
3	Full document replay	4,663	281	9/10
3	Simulated retrieval	3,148	363	9/10
3	Selected Memty context	1,816	204	10/10

Getting facts in costs nothing

PROJECT SCAN

0 LLM tokens, ~7 ms

memty scan read this repository's manifests and saved 21 baseline facts in a median of 7.4 ms, with no model call.

CHAT EXTRACTION

0 LLM tokens by default

Facts are picked from a selection with fixed local rules. An optional local Ollama model never leaves your machine.

CAPSULE BUILD

~3 ms for 300 facts

Ranking, the privacy gate, and packing to the token budget run locally, in a median of 3.0 ms.

What this does and doesn't show. All runs use one synthetic five-turn fixture with ten facts, prepared by hand and loaded into Memty. The retrieval baseline is curated snippets and illustrative tool definitions in the prompt, not a real RAG or MCP product. The live runs don't count the cost of creating the facts, and three repeats on one task don't prove general performance. The offline table checks that the right values were supplied, not that a model used them. The prompts, per-turn answers, raw usage, and the code to reproduce everything are public: benchmarks/token_burn ↗.

Get started

Three commands. One time.

Requires Python 3.10 or newer on Windows, macOS, or Linux. No account, API key, or sign-up.

Install Memty

Terminal

pip install memty

Installs the CLI, the vault, the MCP server, and the browser extension files.

Start the bridge

Terminal

memty serve --autostart

Starts Memty now and every time you log in. Per-user, no admin rights. Undo with memty serve --no-autostart.

Add the extension

Terminal

memty extension --open

Open chrome://extensions, turn on Developer mode, click Load unpacked, and pick the folder that opened. It pairs itself, with no token to copy.

Using Cursor, Claude Code, Codex, VS Code, Windsurf, or Claude Desktop? Also run memty connect. It connects each detected client through the client's own official installer. Then restart the client.

Working in a code project? Run memty init (or memty scan) once in its folder. Memty reads your manifests and saves 10 to 20 baseline facts about the stack, with zero tokens, so your agents start with context instead of an empty vault.

Prefer the terminal? memty remember work.project editor "VS Code" saves a fact, and memty clip work.project copies your facts for any AI app.

Browser extension · Memty Bridge

Memory inside the chats you already use.

Works on ChatGPT, Claude.ai, Gemini, and Perplexity in Chrome, Edge, and Brave. A small purple pill sits above the message box. Drag its ⋮⋮ grip anywhere, and each site remembers the spot.

⚡ MEMTY · ALT+M

Bring your facts

Adds your saved facts to the top of the message box, newest first, within about 350 tokens. You see and can edit it before sending.

SELECT TEXT

＋ Save to Memty

Select any part of an answer and a bubble appears. Memty proposes short facts from it, right on your computer.

REVIEW CARD

Edit, then save

Rename titles, fix values, or untick anything. Saving replaces an older value with the same title and keeps private facts private.

☰ YOUR FACTS

Manage everything

Opens your fact list: search, edit, add, delete, mark private, and switch or create namespaces.

What the AI receives

Database: PostgreSQL 16 on Neon
Deploy target: Fly.io
Editor: VS Code
Files: memty-extension/manifest.json, memty-extension/content.js
Client: [private]

Plain lines, no tags

One Title: value line per fact. Facts with the same title share a line.
Newest facts first, so something you saved a minute ago is always included.
If the list is too long, the oldest lines are left out to stay within budget.
Private values show as [private]. A secret fact stops the request instead.
If the block is already in your message, Memty won't add it twice.

How facts are picked from your selection

01Clean
Removes formatting, links, citation numbers like [1], and Memty blocks you pasted earlier.
02Find candidates
Bullet points and Key: value lines first, otherwise the first five plain sentences of 4 to 30 words.
03Filter
Drops questions, headings, fragments under 3 words, and lines that look like code.
04Shape
Uses the key as the title (or the first meaningful words), groups file paths, caps each fact at 40 tokens, max 12.
05Summarize code
Code is never stored. Each block becomes one line, such as Python code in db.py defines connect, Ledger.

No AI model is used by default. Extraction runs on fixed rules, so it's instant, free, private, and predictable. It reads the shape of text (bullets, Key: value lines, short sentences), not its meaning, which is why every proposal goes through your review. For smarter extraction, set MEMTY_OLLAMA_MODEL (for example llama3.1) to use a local Ollama model. It still runs on your machine, and Memty falls back to the rules if Ollama doesn't answer.

Desktop & CLI agents

Your coding agents share one memory.

Cursor, Claude Code, Codex, VS Code, Windsurf, and Claude Desktop reach the vault over the Model Context Protocol. The clipboard and Python cover everything else. The same vault powers every route; use one or all of them.

MCP clients: one command

Client	How `memty connect` connects it
Claude Code	Runs Claude Code's official `claude mcp add --scope user memty`, so Claude Code validates and saves its own settings.
Cursor	Opens Cursor's official MCP install link, and Cursor asks you to confirm.
Codex CLI	Runs Codex's own `codex mcp add memty` installer.
VS Code	Runs `code --add-mcp` with a stdio server definition. You confirm in VS Code.
Claude Desktop	Prints the exact entry and where to add it (Settings › Developer › Edit Config).
Windsurf	Prints the exact entry for Windsurf's MCP settings.

Memty never edits another app's settings file. A bad write can stop an app from starting, so every change goes through the app's own installer or through you. Every client starts its own small MCP server, and all of them share the same memtyd and the same vault: a fact saved in Codex is in Cursor's next recall.

What agents can do

Tool	What it does	Guardrail
`memty_sync`	Recall a namespace's capsule. When you ask, save up to 25 facts in one call and get the updated capsule back.	120-token capsule, checked by the privacy gate. MCP clients are treated as cloud providers by default.
`memty_propose`	Suggest a fact the agent learned on its own, from code, config, or what you said.	New facts are saved as unconfirmed. A change to an existing fact waits in your inbox until you approve it.
`memty_drill`	Read the archived source text behind a fact.	Only for a genuinely local model, and at most 4,000 characters.

Clipboard · any AI app

memty clip work.project                  # copy your facts
memty clip work.project --query "deploy" # most relevant first
memty clip work.project --print          # print instead
memty clip work.project --format xml     # for agents and tools

Treated as a cloud destination: private values are masked, and secrets stop the copy. Tip: bind it to a keyboard shortcut.

Python

from memty import open_ledger

vault = open_ledger()   # ~/.memty/ledger.sqlite3
vault.record("work.project", "editor", "VS Code",
             verification_state="USER_CONFIRMED")
capsule = vault.context("Which editor do I use?", provider="claude")
print(capsule["text"])   # bounded <memty_state> block

Also: vault.forget(), vault.rehydrate() to restore masked values locally, and vault.drill_down() for archived source text.

Trust control plane

No black box. No silent overwrites.

Memory you can't inspect is memory you can't trust. Memty fills itself without a model, lets agents suggest instead of overwrite, and keeps a receipt every time it hands memory to an assistant.

MEMTY SCAN · MEMTY INIT

Starts full, not empty

Reads pyproject.toml, package.json, Cargo.toml, Dockerfile, and .env.example and saves your stack as facts in milliseconds, with no model and no network. From env templates it keeps key names only; a real .env is never opened. Facts you confirmed or deleted are never touched.

MEMTY INBOX

Agents propose, you decide

When Cursor or Claude Code learns something, a brand-new fact is saved as unconfirmed. A change to a fact you already have waits in your inbox: memty approve or memty reject. Approving never lowers a fact's privacy level.

MEMTY REPORT

A receipt for every capsule

Recall, clip, MCP, and the browser each log what they served: which client, how many facts and tokens, how many values were masked, and any request a secret blocked. Slot names only, never values.

Inbox · example

$ memty inbox
[1] project.api -> cache_engine: "Redis" [confirmed] => "DragonflyDB" (Proposed by Cursor)
      why: compose.yaml runs dragonfly

$ memty approve 1
[1] approved: project.api.cache_engine = "DragonflyDB" (user-confirmed, v2)

The old value stays in memty history. memty reject 1 leaves the fact untouched.

Report · example

$ memty report
42 capsules served across Claude, Cursor & Perplexity | 114 verified facts reused
| ~91,000 tokens saved | 4 SECRET slots protected

  By channel        web 24, mcp 15, recall 3
  Privacy           6 confidential value(s) redacted, 2 request(s) blocked by a SECRET slot
  Most reused       project.api.database x31, project.api.framework x27

Illustrative numbers. "Tokens saved" is a conservative local estimate, compared with sending the whole namespace and its sources, and the report says so.

Your facts, your control

See it. Fix it. Delete it for good.

Open Your Memty facts from the ☰ button on the pill or from the extension icon. Everything Memty knows is listed there, newest first.

View and search

Every fact in a namespace, with when it was saved and whether you added it or it came from a chat.

Edit and add

Change a title or value, or add a fact by hand. Your edits are marked as confirmed, so automatic extraction can never overwrite them.

Mark private

Chat AIs only see [private]. The real value is never sent to the browser, not even to this page, but you can still replace or delete it.

Delete permanently

Deleting removes the value and its whole history. Saving from a chat can't bring it back. Only you can, by adding it again.

Namespaces

Switch between contexts like work.project and personal, or create a new one. Each chat gets one namespace.

Version history

Every change keeps the previous value. In the terminal, memty history work.project editor shows them.

Where your data lives

What	Where	Notes
Your facts	`~/.memty/ledger.sqlite3`	One SQLite file on your disk. On Windows: `C:\Users\<you>\.memty`. Change it with `--db` or `MEMTY_VAULT_PATH`.
Inbox and receipts	Inside the same file	Agent proposals waiting for you, and one receipt per capsule served (counts and slot names, never values).
Daemon	`ledger.sqlite3.daemon.json`, `.daemon.lock`	The running memtyd's loopback port and secret token, and the lock that allows only one daemon per vault.
Pairing	`ledger.sqlite3.web-token`, `.web-paired.json`	The extension's token (owner-only) and which extensions may connect.
Extension files	`~/.memty/browser-extension`	Installed by `memty extension`.
Browser storage	Extension settings only	Port, token, chosen namespace, and pill position. No facts are stored in the browser.
Cloud	Nothing	Memty has no servers, accounts, sync, or telemetry.

Privacy & security

Built so websites can't read your vault.

Every fact has a privacy level. Every request is checked against it before anything is shown to an AI.

PUBLIC

Shared with any assistant you send it to.

Editor: VS Code

INTERNAL

Only for local models and providers you trust. Cloud chats don't receive it.

(left out)

PRIVATE · CONFIDENTIAL

Cloud assistants see a placeholder. The real value stays on your computer.

Client: [private]

SECRET

Never sent to a cloud assistant. A matching request is stopped and asks for a local model.

request refused

How the local bridge is protected

Listens only on 127.0.0.1, never on your network. This can't be changed.
Every data request needs a secret token, stored owner-only beside your vault.
Web pages are refused. Only browser extensions may connect, and only those you approved.
Pairing is trust on first use. To add a browser or a reinstalled extension, run memty pair: one more extension may connect within two minutes.
Host checks block DNS-rebinding attacks. Writes must be JSON, which blocks form-based attacks.
Only the extension's background worker holds the token. Scripts inside chat pages never see it.
The site is identified from the tab's real address (ChatGPT → openai), so a page can't pretend to be trusted.

What to know

When you press Send, the facts in your message go to that AI company, like anything else you type. Review the block first.
The vault file is not encrypted. It's protected by your computer account. Don't put it in a synced folder such as OneDrive or Dropbox unless you want it uploaded.
To revoke access, run memty serve --new-token and restart the bridge. Every extension must pair again.
To erase everything, delete the ~/.memty folder.

Under the hood

Simple rules, strictly enforced.

Memty's behaviour is set by a handful of guarantees, each covered by automated tests.

Guarantee	How it's enforced
No contradictions	One value per `namespace.slot`. A new value supersedes the old one, which moves to an audit table with its version number.
Facts stay small	Values over 40 tokens are rejected, so each fact is one clear statement.
Deleting is permanent	Forgetting a fact tombstones it and purges its value and history.
Automation can't overrule you	Automatically extracted facts can't overwrite facts you confirmed, and can't restore facts you deleted.
Agents ask first	An agent's change to an existing fact goes to the inbox, never straight into the vault. Approving keeps the fact's privacy level and provider rules.
One writer	All tools go through one memtyd per vault, which handles one request at a time, so concurrent tools can't corrupt or overwrite each other.
Every capsule is accounted for	Each capsule served, and each request a secret blocked, writes a receipt with counts and slot names. Values are never written to receipts.
Bounded context	Every capsule is checked against a hard token limit: 350 for chat websites, 200 for the clipboard by default, 120 for MCP, and 600 for the API by default.
Newest first	Without a question, the most recently saved facts lead. With a question, facts are ranked by keyword overlap and optional semantic similarity.
Raw text stays out	Source text archived with a fact is never put in a capsule. It's only returned by an explicit drill-down call.
Rules per namespace	Logical rules such as "when writing database queries, always use async Motor" are stored per namespace and managed with `memty rule`.
Fast	Building a capsule takes about 3 ms (median) with 300 facts. Search uses SQLite FTS5 when available, with a plain SQL fallback.
Few dependencies	The vault and compiler use only the Python standard library. The package adds the official MCP library.

Anatomy of a fact

Field	Example	Meaning
Namespace	`work.project`	Which context it belongs to
Slot (title)	`deploy_target` → "Deploy target"	Its name; one value per slot
Value	`Fly.io`	The fact itself, up to 40 tokens
Verification	`USER_CONFIRMED`, `SPEC_LOCKED`, `EXTRACTED`	Who stands behind it: you, a pinned spec, or automatic extraction
Sensitivity	`PUBLIC`, `INTERNAL`, `CONFIDENTIAL`, `SECRET`	Who may see it (see Privacy)
Providers	allowed / blocked lists	Per-fact allow and block lists, e.g. never send to one provider
Version	`3`	How many times it has changed; older values are in the history
Hit count	`27`	How many capsules have included it, from the receipts

Commands

Everything from the terminal.

Run memty for a short introduction, or memty --help for every option.

Command	What it does
`memty serve --autostart`	Start the browser bridge now and at every login. `--no-autostart` undoes it, `--stop` stops it.
`memty extension`	Install or update the browser extension folder. Add `--open` to open it.
`memty pair`	Let one more browser (or a reinstalled extension) connect within two minutes.
`memty connect`	Connect Cursor, Claude Code, Codex CLI, VS Code, Windsurf, and Claude Desktop. `--dry-run` shows the plan.
`memty init` · `memty scan`	Save a code project's baseline facts from its manifests, with zero tokens. `--dry-run` previews them.
`memty inbox`	Review facts your agents proposed. `--all` includes resolved ones.
`memty approve ID` · `memty reject ID`	Accept a proposal as a confirmed fact, or discard it. `--all` for every pending one.
`memty receipts` · `memty report`	See each capsule served, or a summary: capsules, facts reused, estimated tokens saved, secrets protected. `--days 7` limits the period.
`memty remember NS SLOT VALUE`	Save a fact, e.g. `memty remember work.project editor "VS Code"`.
`memty recall "question"`	Print the capsule for a question. Add `--namespace` and `--provider`.
`memty clip NS`	Copy a namespace's facts to the clipboard for any AI app.
`memty list` · `memty history NS SLOT`	List active facts, or show earlier versions of one fact.
`memty forget NS SLOT`	Delete a fact and its history. `--purge-raw` also removes archived source text.
`memty summary NS --set "…"`	Set a short summary for a namespace.
`memty rule` · `rules` · `rule-delete`	Manage logical rules for a namespace.
`memty stats`	Show vault counts and its location.
`memty migrate PATH`	Import the latest facts from an earlier Memty vault. Deleted facts stay deleted.
`memtyd status` · `start` · `stop`	Check or control the shared background daemon. It starts automatically when needed.

Settings

Setting	Default	Purpose
`--db` / `MEMTY_VAULT_PATH`	`~/.memty/ledger.sqlite3`	Where your vault lives
`--user` / `MEMTY_USER`	`local`	User inside the vault
`MEMTY_PROVIDER`	external	How MCP clients are treated by the privacy gate
`MEMTY_OLLAMA_MODEL`	not set	Use a local Ollama model to extract facts

Progress & roadmap

Shipped in public, week by week.

Memty is in alpha (0.x). The storage format is stable and tested, while commands may still change between minor versions. See the changelog.

Week 1 · ShippedNov 1–2, 2026

The atomic vault and compiler

The foundation: a local SQLite vault of small, versioned facts and a compiler that builds bounded, privacy-checked context.

Facts with versioning, audit history, and permanent deletion
Namespace summaries, logical rules, and raw text drill-down
Token-bounded compiler with SECRET routing and CONFIDENTIAL masking
Per-fact provider allow and block lists

Week 2 · ShippedNov 3–4, 2026

One vault for every tool

A shared background service and an MCP server, so desktop and coding assistants use the same memory safely.

memtyd: one local daemon per vault, shared by every client
MCP server with memty_sync and capsule resources
memty connect through each client's official installer, never editing their settings files
A welcome screen in the CLI

Week 3 · ShippedNov 5, 2026 · v0.2.0 on PyPI

Memory in your browser, under your control

Memty reaches ChatGPT, Claude.ai, Gemini, and Perplexity, with a full fact manager and zero-setup install.

Memty Bridge extension: ⚡ Memty, select-to-save, review card, draggable pill
Your Memty facts page: view, edit, delete, add, mark private
Readable Title: value capsules, newest first
Local fact extraction with code summaries and optional Ollama
Automatic pairing, memty pair, login autostart, memty clip
Published to PyPI: pip install memty

Week 4 · ShippedNov 9, 2026 · on main

Every agent, one memory, measured

More desktop clients on the same vault, and the first public token benchmark.

memty connect for Codex CLI and VS Code, alongside Claude, Cursor, and Windsurf
memty_sync saves up to 25 facts in one call; memty_drill for local models
Each browser save becomes its own context you can pick before pasting
Token benchmark: 61% fewer input tokens than full replay and 30/30 exact answers in live Claude and Gemini runs

Week 5 · ShippedNov 12, 2026 · on main

The trust control plane

Memty stops being a black box: it fills itself without a model, agents propose instead of overwrite, and every capsule leaves a receipt.

memty scan / memty init: zero-token project bootstrap that never stores secret values
memty_propose and the memty inbox, approve, reject review queue
Context receipts, per-fact hit counts, memty receipts and memty report
A cleaner package: vault, context and privacy gate, extraction, trust, runtime, integrations
Focused on memory: the separate model-routing SDK was removed

Publish weeks 4 and 5 to PyPI, and list the extension on the Chrome Web Store so it installs in one click, without Developer mode.

Planned

Broader benchmarks

More tasks and repeats, comparisons with named RAG and MCP memory products using real tool calls, and the cost of creating memory counted, not just of reusing it.

FAQ

Good questions.

Is my data stored in the cloud?

No. Your facts live in one file on your computer, ~/.memty/ledger.sqlite3. Memty has no servers, accounts, sync, or telemetry, and the browser only keeps settings, never facts.

The one moment facts leave your computer is when you press Send in a chat: the block in your message goes to that AI company, like anything you type.

Does Memty really use fewer tokens?

In our published benchmark, yes: across three live runs passing one architecture handoff between Claude and Gemini, Memty's selected context used 5,448 input tokens versus 13,989 for replaying the full documents (61% less) and 9,386 for retrieved snippets (42% less), and it returned all 30 expected values exactly.

That's one synthetic task, not a guarantee for every workload, and it doesn't count the effort of creating the facts. The prompts, raw results, and code are public so you can rerun it. See Proof.

How do the browser and my coding agents share memory?

They all talk to the same local daemon, memtyd, which owns your vault file. The browser extension reaches it through the bridge on 127.0.0.1:8765; Cursor, Claude Code, Codex, and other MCP clients reach it through their own MCP server; the CLI reaches it directly. Nothing is copied between apps, so a fact saved in ChatGPT is in Cursor's next recall.

Can my coding agent change my facts?

Not on its own. An agent can add a brand-new fact, saved as unconfirmed. Any change to a fact you already have waits in memty inbox until you run memty approve. Facts you confirmed or deleted can't be changed by automation.

Does Memty use AI to pick facts from my chats?

Not by default. It uses fixed rules: it reads bullets, Key: value lines, and short sentences, and skips questions, headings, and code. That makes it instant, free, and private. Because rules don't understand meaning, every proposal goes to you for review first.

Set MEMTY_OLLAMA_MODEL to use a local Ollama model instead. It still never leaves your machine.

Why didn't my newest fact show up?

Since 0.2.0, facts are listed newest first, so a fact you just saved always leads. Check that it was saved to the namespace you're using (shown in the save message and on the facts page).

What does "This browser isn't connected to Memty yet" mean?

For your safety, Memty only talks to extensions you approved. A reinstalled extension or a second browser counts as new. Run memty pair in a terminal, then click Try again.

If memty pair says Cannot pair, another Memty bridge, for a different vault or an older version, is using port 8765. Stop it, then pair again.

Which browsers and sites are supported?

Chrome, Edge, and Brave, on ChatGPT (chatgpt.com and chat.openai.com), Claude.ai, Gemini, and Perplexity. Chat sites change often, so if the pill can't find an answer, select the text you want instead.

Does it work offline?

Yes. Saving, editing, and building capsules all run locally. You only need the internet for the AI chat itself.

What happens when I delete a fact?

Its value and whole history are removed from the vault, and automatic saving can't bring it back. You can only restore it by adding it again yourself.

Can I keep secrets in Memty?

Mark them Private to have chat AIs see only [private], or SECRET so any request that would include them is refused. The vault file itself isn't encrypted, so it relies on your computer account's protection.

Is the web workspace connected to the vault?

Not yet. The Memty web app is a separate companion; its account conversations and MongoDB memory don't sync with the local SQLite vault.

How do I update or uninstall?

Update: pip install -U memty, then memtyd stop so the daemon restarts on the new version, then memty extension and click reload on the extension. Open chat tabs update by themselves. Restart your MCP clients to pick up new agent tools.

Uninstall: memty serve --no-autostart, pip uninstall memty, and remove the extension. Your vault stays in ~/.memty until you delete it.

What does it cost?

Nothing. Memty is open source under the MIT license.

Your AI memory.Owned by you.

Every chat starts from zero.

You repeat yourself

Memory is locked in

You can't see or control it

One vault, every AI

Small, clear facts

You approve everything

Private by default

Save once. Recall anywhere.

Fewer tokens. More exact answers.

0 LLM tokens, ~7 ms

0 LLM tokens by default

~3 ms for 300 facts

Three commands. One time.

Install Memty

Start the bridge

Add the extension

Memory inside the chats you already use.

Bring your facts

＋ Save to Memty

Edit, then save

Manage everything

Plain lines, no tags

Your coding agents share one memory.

No black box. No silent overwrites.

Starts full, not empty

Agents propose, you decide

A receipt for every capsule

See it. Fix it. Delete it for good.

View and search

Edit and add

Mark private

Delete permanently

Namespaces

Version history

Built so websites can't read your vault.

PUBLIC

INTERNAL

PRIVATE · CONFIDENTIAL

SECRET

How the local bridge is protected

What to know

Simple rules, strictly enforced.

Everything from the terminal.

Shipped in public, week by week.

The atomic vault and compiler

One vault for every tool

Memory in your browser, under your control

Every agent, one memory, measured

The trust control plane

Release and easier install

Broader benchmarks

Good questions.

Keep memory useful.Keep it yours.

Your AI memory.
Owned by you.

Keep memory useful.
Keep it yours.