One Memory, Twelve Tools: Why Engram Rides a Protocol Instead of Scraping Web Pages

As of this week, Engram has a documented setup guide for twelve AI tools. Your memory — the exact words of every conversation you've chosen to keep — is now readable and writable from ChatGPT, Claude, Claude Code, Cursor, VS Code, Windsurf, Zed, Cline, Goose, Gemini CLI, Codex CLI, and JetBrains IDEs.

Here's the part worth a blog post: we didn't write twelve integrations.

The twelve

Every row links to a guide with the exact config — including the traps we hit so you don't have to (Gemini CLI wants httpUrl, not url; Cline wants streamableHttp in exactly that casing; Goose has a known OAuth quirk with a one-line workaround).

We didn't write twelve integrations

Engram is one server speaking the Model Context Protocol — the open standard both OpenAI and Anthropic adopted for connecting tools to AI. Each of those twelve tools implemented an MCP client for its own reasons, on its own schedule, with its own engineers. When they did, Engram worked there. Our “ integration work” was testing the config and writing a docs page.

Compare that with the other way memory products get breadth: a browser extension with a hand-written adapter for every chat site's web page. That approach gets real coverage too — more raw platforms than MCP reaches today — but every adapter is code that breaks when someone else redesigns their UI, and every new platform is new code to write and maintain forever.

A protocol inverts the maintenance economics. Scraper coverage is a treadmill; protocol coverage compounds. When the next agent or IDE ships MCP support — and at this point they all do — Engram's list grows by one, and we write zero code.

Why memory belongs on the protocol side

There's a deeper reason we built on MCP than saved effort: it's the only place a verbatim memory can live.

A browser extension can only push text into a prompt box, so it has to keep memories short — distilled notes like “user prefers TypeScript.” An MCP server hands the AI real tools: search runs semantic + keyword retrieval over full transcripts server-side and returns just the relevant passages; append_messages stores the conversation exactly as it happened. The AI queries memory the way it queries the web — on demand, when the conversation needs it — instead of having a summary shoved into every prompt.

That's the difference between remembering about your work and remembering your work. The exact fix from a 1am debugging session survives verbatim, and comes back verbatim — in whichever of the twelve tools you happen to be in when you need it.

The same memory, everywhere your work happens

The list isn't twelve separate memories — it's one. Research a library in ChatGPT on your phone, and the decision is waiting in Claude Code when you open the terminal. Let Claude Code auto-capture the implementation session, and next week Cursor can answer “how did we fix the auth race?” with the actual diff discussion. Your memory stops being a feature of any one app and becomes something you own that the apps all consult.

What we won't claim

In the spirit of our comparison posts: Engram does notreach tools without MCP support. No Gemini web app, no Grok, no Perplexity — they don't let users attach MCP connectors today. If they ever do, they join the table for free; until then, we won't count them. Twelve is the honest number, and every one has a guide you can follow in minutes.

Try the two-minute proof

Connect Engram free (10,000 messages, no card) in whichever tool you use most, tell the AI to remember one real thing, then open a different tool from the table and ask for it back. One memory, your exact words, everywhere you work.