What cross-IDE persistent context platforms are available for engineering teams?
A lead engineer whose people split work across Claude Code, Cursor, Codex and JetBrains is not looking for a ranking. The person is looking for a place where one decision stays visible when the next person opens a different tool. This article describes what each vendor documents for that job. It does not test products.
TL;DR
- Three kinds of product answer the question. Shared memory stores the team writes to: Basic Memory, Cognee, Mem0, MemoryLake, MemoryPlugin, Mnemoverse, Supermemory and Zep in the vendor's cloud, or TencentDB Agent Memory on the team's own servers. Code and company context served to agents over MCP: Augment Context Engine, Glean, Sourcegraph and Unblocked. Team rules and skills rendered into each tool's files: Packmind, Augment workspace rules and BuildBetter ZeroShot.
- Every tool still gets its own connection. In every option checked, each coding tool needs its own connector or its own file, with its own sign-in where the vendor uses one. Unblocked, Glean and Packmind automate parts of that setup.
- Check who sees a teammate's contribution before comparing prices. Cognee, Letta, Supermemory and Zep document four different defaults, and for Supermemory and Zep, narrowing them takes a higher plan.
- One machine is a different problem from a team. Tencent's MemHub, published on 16 October 2026, runs one runtime per installation. Tencent's team product is a different one, TencentDB Agent Memory.
This library is published by Mnemoverse, which makes a persistent memory API for AI agents. Mnemoverse is one of the options compared here, and every fact about it, as about the others, comes from the vendor's public pages read on 16 October 2026 unless another read date is given.
Three kinds of cross-IDE context platform
A shared memory store is a persistent knowledge base that people and their agents write to, and that each connected tool reads back. Basic Memory describes the effect: "Notes created in Codex are immediately available in Claude Code, Cursor, Claude Desktop, or any other MCP client." Basic Memory
Code and company context is an index of repositories, pull requests, documents, tickets and chat that agents search and read over MCP. Sourcegraph serves code search and navigation; Unblocked indexes code together with the discussions around it. Sourcegraph · Unblocked
Team rules and skills are standards, commands and skills kept in one place and written into the instruction file each assistant already reads. Packmind keeps the sources in .packmind/ and renders them into each assistant's own folder or file. Packmind
MCP (Model Context Protocol) is the protocol through which a coding tool reaches an outside server's tools. Most products below use it; TencentDB Agent Memory uses a model proxy instead, and Augment workspace rules, BuildBetter ZeroShot and ByteRover work through files or skills.
| Kind | What it holds | Who writes it | How a tool connects | Who controls access | Examples |
|---|---|---|---|---|---|
| Shared memory store | notes, decisions, context | people and their agents, while they work | MCP server, plugin or extension; a changed base URL for TencentDB Agent Memory | the vendor's roles, spaces, datasets or projects; on your own servers, you | Basic Memory, Cognee, Mem0, MemoryLake, MemoryPlugin, Mnemoverse, Supermemory, TencentDB Agent Memory, Zep; Letta keeps memory inside an agent |
| Code and company context | an index of code, pull requests, documents, tickets, chat | nobody new: it indexes systems the team already uses | MCP server, local or hosted | the product's administrators; Glean and Sourcegraph also apply people's existing permissions | Augment Context Engine, Glean, Sourcegraph, Unblocked |
| Team rules and skills | standards, commands, skills | whoever maintains the playbook, or sessions turned into skills | a file in each tool's own format | organization administrators and the repository | Packmind, Augment workspace rules, BuildBetter ZeroShot |
Shared memory store Code and company context Team rules and skills
Claude Code Cursor Claude Code Cursor Claude Code Cursor
^ | ^ | ^ ^ ^ ^
| v | v | | | |
+--------------------+ +--------------------+ +--------------------+
| one store that the | | an index of code, | | one playbook kept |
| team writes into | | PRs, docs and chat | | in the repository |
+--------------------+ +--------------------+ +--------------------+
tools read and write tools search and read rendered into each
tool's own fileStart with the missing artifact. If a decision captured during a coding session should become retrievable knowledge, look at memory. If the answer already exists in a repository, ticket or discussion, look at context search. If agents need to follow a review checklist or a coding convention, look at rules.
The connection is a separate concern. In the options documented here, each tool receives its own MCP entry, plugin, extension, proxy setting or instruction file, and sign-in is per client where the vendor uses one. A shared backend does not remove those steps. Three vendors bundle part of the work, each in its own way: Unblocked with a local detection script that finds supported agents on a macOS or Linux machine, Glean with device management (administrators push the setup through MDM), and Packmind with repository rendering of one playbook into each selected tool's files. Those are deployment conveniences, not interchangeable sharing models. Unblocked setup · Glean hosts · Packmind rendering
"Names" and "lists" below describe the pages read. A tool not named on those pages is not thereby unsupported.
Tencent's MemHub: one installation versus a team
On 16 October 2026, Tencent Hunyuan published the open repository Hy-Memory, whose first commit is titled "Initial open source release". Hy-Memory is a memory engine and Python SDK; the hy-memory package has been on PyPI since 21 May 2026, and the repository's license is Apache-2.0. Tencent's MemHub is "a local-first desktop and CLI product that unifies conversation history and coding traces from user-authorized AI applications", built on Hy-Memory in the same repository. Repository · README · PyPI
The architecture page sets the unit of deployment: "There is one managed Runtime and one MemHub data home per installation." Data sits in SQLite under ~/.one-memory by default. Each application connects through an MCP entry, a Skill, hooks or a plugin, with two separate switches: inject, where MemHub hands memory to the app on request, and sync, where the app hands its history to MemHub. For Claude Code that means an MCP entry in ~/.claude.json, the memhub-recall Skill and three capture hooks, and recall through that MCP entry is an active query, not an automatic prefetch. Architecture · Claude Code connection
Tencent's MemHub lists ten tools; its support table dated 14 October marks eight as open: Hermes, Cursor, Claude Code, Codex, WorkBuddy, OpenCode, Qwen Code and Pi. An Apple silicon Mac app and Linux runtimes were downloadable on 16 October; Intel Mac and the npm install path were still pending. Windows is not supported in v1.0.0; a maintainer said support would come, with no date. Support table · Release v1.0.0 · Windows issue
The connection prompt in the source tells the agent that web chats, remote containers and another machine cannot use these local paths, and that it should not create a public proxy. Tencent documents no hosted MemHub service as of 16 October. Tencent documents MemHub as one runtime per installation; its team product is TencentDB Agent Memory. Treat them as separate purchasing and deployment questions. Connection prompt · TencentDB Agent Memory
Shared memory stores for engineering teams
Each tool reaches the shared store through its own connector; the mechanism is described in MCP servers that share state across IDEs. What differs for a team is the scope behind the connection: an account, a dataset, an agent, a project or a shared space. Vendors are in alphabetical order, and prices are in the full table below.
Basic Memory
Basic Memory keeps one Markdown knowledge base that tools reach over remote MCP (Basic Memory Cloud) or a local stdio server; its integration pages name Codex, Claude Code, Cursor and Claude Desktop, among others. In Basic Memory Teams, "Anything a teammate writes is immediately available to everyone else and to their agents". Each team gets its own isolated cloud database, roles run in five levels from viewer to owner, and billing is per seat. The app is free and open source locally, and cloud plans start with a 7-day trial. The local version has "No team features; runs entirely on your computer". Teams · Roles · Pricing
Cognee
Cognee Cloud runs a hosted MCP server with OAuth that names Claude (web and Desktop), Claude Code and ChatGPT. Unless a dataset is named, each client writes into a dataset of its own, and "recall without a dataset searches everything you can access, so memories written by one client are visible to the others." Invited users get all tenant-wide datasets, and access control is enforced per dataset. The free tier has one workspace, 1M tokens and unlimited users. On your own stack, the open cognee-mcp shares one knowledge graph in API Mode, while in Standalone mode "Each MCP instance maintains separate data." Do not assume that running several standalone connections creates a team store. Cloud MCP · Members · cognee-mcp · Pricing
Letta: memory inside an agent
Letta keeps memory inside an agent rather than in a store each tool writes to. Through the ACP adapter, "the agent and its memory stay on the Letta Platform while tools run against the working tree on your machine"; the examples cover Zed, JetBrains IDEs and Obsidian. The hosted MCP server lets Claude Code, Cursor or another agent create stateful Letta agents, delegate work to them and read their replies. This is delegation, not a shared store, and "OAuth-only clients are not supported yet." Letta for teams adds organizations with Admin, Editor and Analyst roles, and "Agents are private to their creator by default." Shared memory repositories live in Letta Cloud and require cloud-hosted agents. Free plans are limited to three stateful agents. ACP · Hosted MCP · Permissions · Shared memory · Pricing
Mem0
Mem0's MCP server is hosted, and "Memories you store this way live in your Mem0 account, not on your computer." A client signs in through the browser or with an API key; the page names seven MCP clients as examples, including Claude Code, Codex, Cursor and Devin Desktop (Windsurf). Per the changelog, the shared editor plugin covers Claude Code, Cursor, Codex, Antigravity and Kimi Code on one memory bank, and in the Claude Code integration "Everyone on the repo reads and writes the same pool." Organizations and projects are optional, with OWNER and READER roles. Hobby is a free start with one project. Mem0 Open Source is a separate, self-hosted REST API and dashboard; the hosted MCP endpoint requires a Platform API key. MCP · Changelog · Claude Code · Self-hosting · Pricing
MemoryLake
MemoryLake's MCP page names Claude Code, Claude Desktop, Cursor, Devin Desktop (Windsurf), Cline, Continue.dev and Zed. A team is created in the console, colleagues join by email or invite link, and roles are Owner, Admin, Member or custom, with workspaces and per-resource permissions. The scope is picked at connection time: "you select the workspace and boundary on the OAuth consent screen when a client connects." The coding-agent scenario page describes an OpenClaw plugin. The free plan has 300,000 tokens a month, and the Claude Code page is explicit: "Paid tiers only for team collaboration." MCP · Teams · Claude Code · Pricing
MemoryPlugin
MemoryPlugin pairs a Chrome and Safari browser extension for ChatGPT, Claude, Gemini and other chat apps with a hosted MCP server (plus a local one) for Claude Code, Cursor, Devin Desktop (Windsurf), Claude Desktop and other MCP clients. Team sharing comes with Pro, whose card reads "Shared buckets for your team"; Core has none. Every subscription starts with a 7-day trial that needs a card. MemoryPlugin Sync is a downloadable macOS app for Apple silicon that brings Claude Code, Codex and Cursor conversations into the MemoryPlugin chat history. Its download page, read on 18 October, says that syncing those chats requires Pro, and that browsing local chats in the app is free on any plan. Home page and plans · Pricing and FAQ · Sync download
Mnemoverse (the author's company)
Mnemoverse documents one memory per account: "Any key or sign-in from the same Mnemoverse account reaches the same memory." For a team, "Each engineer keeps their own API key; the team shares knowledge through a room (Beta)". Rooms (beta) "carry no separate price", and "Each member's room reads and writes are billed against their own account's plan". The limit to weigh: rooms are in beta. Coding assistants · Pricing
Supermemory
Supermemory's MCP server uses OAuth: "Sign in or create an account, then choose which spaces the client can access." Teammates then work within the spaces they may read or write, and ChatGPT on the web connects through developer mode. The coding plugins for Cursor, Claude Code, Muse Code, Codex and OpenCode share one repository tag, "so agents working on the same repo read and write the same memory", and they are on every plan, including Free. Team invitations start on Pro, and each member or pending invitation takes a seat. The invite dialog defaults to the Member role with Full access, which includes all containers; limiting a teammate to selected container tags (Restricted, with Read or Write per tag) needs Scale or Enterprise. The free coding connection and the team permission model are different entitlements. MCP · Cursor plugin · Invitations · Billing
TencentDB Agent Memory
TencentDB Agent Memory is "a team-level memory hub for AI Agents" from Tencent Cloud, separate from Tencent's MemHub, which a team deploys itself. An agent connects by pointing its model base URL at the team's proxy (for Claude Code, ANTHROPIC_BASE_URL): "No plugin, hook, or MCP server is required." The repository names DeepSeek Harness, Claude Code, Codex, CodeBuddy, WorkBuddy, Hermes and OpenClaw. On feat/server_team, the repository's default branch, new chat memory and skills are private by default, the README's visibility table lists four settings (private, team, restricted and agent), and the roles are administrator and member. The license is MIT with a Tencent preamble. Where memory is stored is one question; where model requests go is another. Here every LLM request from a connected agent passes through the proxy the team runs. Repository · Install guide
Zep
Zep's Context MCP Server is one address: "One URL serves every MCP client and every Zep project on Zep managed cloud." A user's in-house agent and their personal MCP client share one user graph. The plugin installs in Claude, ChatGPT, Cursor, Claude Code and Codex CLI, and administrators distribute it through each host. Users sign in through Google Workspace or an enterprise identity provider; custom OIDC requires Enterprise. The default for shared graphs is broad: "Every authenticated MCP user can list and search every shared Context Graph in the token-bound project." Moving connections to UserGroup ABAC on Zep managed cloud requires Enterprise and the ABAC entitlement. Dashboard SSO for members is separate from end-user sign-in to the Context MCP Server. The free plan starts with 10,000 credits a month. Context MCP Server · Graph authorization · SSO · Pricing
Who sees what on a shared memory store
For a team, this question matters more than the connector. Make the permission check specific. When an engineer connects, what can they search before an administrator changes anything? The documented answers differ:
- Zep: every shared graph in the project, until an administrator moves connections to UserGroup ABAC (Enterprise and the ABAC entitlement on managed cloud).
- Supermemory: every container by default (the invite dialog defaults to Member with Full access); Restricted, per-tag Read or Write, on Scale or Enterprise.
- Cognee Cloud: all tenant-wide datasets; access control per dataset.
- Letta: not a colleague's agents, which are private to their creator by default.
- Basic Memory Teams: everything teammates write, under five roles.
- MemoryLake: the workspace and boundary picked at OAuth consent; team collaboration on paid tiers.
- Mem0: projects are optional; a READER can view and search but not manage members.
- Mnemoverse: each engineer's own account, plus what the team shares through a room (beta).
- TencentDB Agent Memory: what has been marked
team. New chat memory and skills are private by default;restricted(access by user, role or agent ACL) andagentare the other settings.
These defaults deserve a pilot test before sensitive material goes in.
Code and company context over MCP
These products answer a different question: what existing evidence should the coding agent read?
Augment Context Engine serves code context over MCP in two ways: "Run the Auggie CLI locally as an MCP server (stdio)", which indexes the working directory, or connect to the hosted engine over HTTP, which indexes "Selected repos' default branches (chosen during GitHub App install)". Its docs carry 12 quickstarts, among them Claude Code, Codex, Cursor, Zed and GitHub Copilot. MCP requests are billed in tokens. The two paths index different material, so decide which one matches the code the team wants agents to read. Context Engine · Pricing
Glean brings permission-aware enterprise context to MCP hosts, "so users can only search, read, and act on content they can already access in Glean". Its plug-in serves Cursor, Claude Code and Codex, and of the plug-in Glean says, "Claude Cowork and GitHub Copilot aren't supported." The broader MCP host list names 13 hosts, including JetBrains AI Assistant, Junie and VS Code, and administrators can push setup through MDM. Do not confuse the plug-in's client list with the MCP host list. There was no price on glean.com on 16 October. Plug-in · MCP hosts
Sourcegraph gives agents an instance's code search, navigation and analysis, including Deep Search, and its MCP server is "Supported on Enterprise plans." Administrators control access with the MCP#ACCESS permission, and "Users can only read data from repositories they are already allowed to access in Sourcegraph." The buying boundary is both the Enterprise contract and the existing repository permissions. MCP and permissions · Pricing
Unblocked indexes code, pull requests, Slack and Microsoft Teams, Confluence, Jira, Linear and more, and gives agents two MCP tools, context_research and context_get_urls. "The install script supports macOS and Linux." On Windows, the docs point to a guide for each app. Unblocked also documents Shared Memories: a correction made in a shared conversation is saved, admins manage it, and the vendor lists where it applies (the web app, the Mac app, Slack, Microsoft Teams and the CLI). That list is the vendor's; this comparison does not extend it. Product · MCP setup · Shared Memories
Team rules and skills across coding tools
Here the team shares instructions rather than a store. Shared memory is written while people work: an agent saves a decision, and a teammate's agent in another tool finds it later. Shared rules are written once and rendered into the file each assistant reads. A team can use both.
Augment workspace rules live in .augment/rules, "for project-specific guidelines that should be shared with your team via version control." User guidelines are a different scope: "Guidelines defined in VSCode will not propagate to JetBrains IDEs and vice versa." Put shared project instructions in the repository rather than assuming that personal IDE settings travel. Guidelines
BuildBetter ZeroShot "turns your team's sessions and PR reviews into reusable skills". Its pricing separates local use, a free hosted plan for up to 3 team members and 200 sessions a month, and Pro with session handoff. Client lists differ by card: the free card says "Works with Claude & Codex" and the Pro card "Works with Claude, Codex, Cursor & Gemini". Read the card for the deployment you intend rather than combining those lists into one promise. Product · Plans
Packmind shares rules, not memory. Its sources in .packmind/ are "the single source of truth", and Packmind renders them into each assistant's own files; the vendor's table lists 10 targets, from Claude Code, Cursor and GitHub Copilot to AGENTS.md and Kiro. Organization administrators choose which assistants receive the files, and Spaces require the Enterprise version. The open plan is free, and self-hosting uses Docker Compose or Kubernetes. Consistency here comes from rendering a shared playbook, not from retrieving session history. Rendering · Managing agents · Spaces · Self-hosting
Local-first context on one developer's machine
Local-first is a deployment property, not a substitute for inspecting the sharing controls.
ByteRover V4 "connects agents through the published ByteRover skill." In the vendor's words, "Your memory stays local first, with a cloud option to selectively share it with other agents and people." The free card reads "Shared agent memory for a small team, saved as context files." The working choice is which local context to publish. Product and plans · V4 agents
claude-mem runs a local worker with SQLite and Chroma, with optional cloud sync. By default it "limits startup context to the current harness"; a setting turns on shared startup context between Claude Code and Codex. TeamBrain is "An optional shared workspace beside My Work, with real team work lists, member attribution and linked findings. Each person chooses what to share". The v13.40.0 release of 16 October added joining a team from the terminal and read-only team_brief and team_search MCP tools. Repository · Release v13.40.0
Pieces keeps memory on the device: "All captured context is processed and stored entirely on your device", cloud sync is optional, and its MCP server needs PiecesOS. The app asks for a plan when it opens, and "Starting the 7-day Pro trial takes a card on file." In the vendor's words, "Pro helps one person capture and recall their own work context, in every tool they use." Enterprise adds organization-level policy, in which admins approve providers, sources and features, and memory settings "automatically sync to all team members' Pieces Desktop and PiecesOS installations." Long-term memory · Team settings · Pricing
Tencent's MemHub, covered above, belongs in this group: one runtime and one data home per installation, with no hosted MemHub service documented on 16 October.
Cross-IDE context platforms compared: the full table
All pages were read on 16 October 2026 unless a row gives another read date, and every price is the vendor's price on its read date. Rows show a selection of the tools each vendor names; a tool missing from a row may still be named on the vendor's pages, and is not thereby unsupported. Products are alphabetical within each kind.
| Product | Kind | Where it lives | How a tool connects | Tools the vendor names | How a team shares | Plans and prices on 16 October 2026 |
|---|---|---|---|---|---|---|
| Basic Memory | Shared memory | Local files, or an isolated cloud database per team | Remote MCP or local stdio | Codex, Claude Code, Cursor, Claude Desktop | Teams workspace; five roles | Local free (AGPL-3.0); Team $15 per seat a month ($13 at 10+, $12 at 20+); Business $30 per seat a month with SSO; 7-day trial. Pricing |
| Cognee | Shared memory | Cognee Cloud, or your own stack | Hosted MCP with OAuth; cognee-mcp API Mode | Claude (web, Desktop), Claude Code, ChatGPT; cognee-mcp adds Cursor, Cline, Continue, Codex | Tenant-wide datasets; access per dataset | Free: 1 workspace, 1M tokens, unlimited users; Standard $1.00 per 1M tokens plus $5 per extra workspace. Pricing |
| Letta | Memory inside an agent | Letta Platform and Letta Cloud | ACP adapter; hosted MCP for delegation | Zed, JetBrains IDEs, Obsidian (ACP); Claude Code, Cursor (MCP) | Organizations; agents private by default | Free plans limited to 3 stateful agents; Teams Pro $20 per seat a month (read 17 October). Pricing |
| Mem0 | Shared memory | Mem0 account, or self-hosted Open Source | Hosted MCP; editor plugin | Seven example clients, including Claude Code, Codex, Cursor | Optional organizations and projects; repository pool | Hobby free (10,000 adds, 1,000 retrievals a month, 1 project); Starter $19 a month; Pro $249 a month; Enterprise custom. Pricing |
| MemoryLake | Shared memory | MemoryLake workspaces | MCP with OAuth scope selection | Claude Code, Claude Desktop, Cursor, Cline, Continue.dev, Zed and others | Console team and roles; paid tiers for teams | Free $0 with 300,000 tokens a month. Pricing |
| MemoryPlugin | Shared memory | MemoryPlugin account | Browser extension; hosted or local MCP | ChatGPT, Claude, Gemini; Claude Code, Cursor, Claude Desktop | Shared buckets on Pro | Core $15 a month or $89 a year; Pro $25 a month or $180 a year; 7-day trial with a card. Pricing |
| Mnemoverse (the author's company) | Shared memory | The Mnemoverse account | API key or sign-in, one memory per account | See Editors | Rooms (beta), each member on their own account | Rooms (beta) carry no separate price; each member billed on their own plan; Free $0, Pro $29 a month. Pricing |
| Supermemory | Shared memory | Supermemory cloud | MCP with OAuth; coding plugins | ChatGPT (web); Cursor, Claude Code, Muse Code, Codex, OpenCode | Spaces; invitations from Pro, all containers by default; per-tag limits on Scale or Enterprise | Free $0 with $5 of credits a month; Pro $19 a month (3 team seats); Max $100; Scale $399 a month. Pricing |
| TencentDB Agent Memory | Shared memory | Your own servers | Base URL pointed at the team's LLM proxy | DeepSeek Harness, Claude Code, Codex, CodeBuddy, WorkBuddy, Hermes, OpenClaw | Private by default; team, restricted and agent visibility | Self-deployed; MIT with a Tencent preamble. Repository |
| Zep | Shared memory | Zep managed cloud | One Context MCP Server URL; plugin | Claude, ChatGPT, Cursor, Claude Code, Codex CLI | Project-wide graphs until ABAC on Enterprise | Free: 10,000 credits a month, 2 projects, 1 MCP seat; Flex $125 a month; Flex Plus $375 a month (monthly billing); Enterprise custom. Pricing |
| Augment Context Engine | Code context | Working directory, or hosted index of selected repositories | MCP over stdio or HTTP | 12 quickstarts, including Claude Code, Codex, Cursor, Zed | Flat team plan; Enterprise SSO, OIDC, SCIM | Standard $20 a month for the team (up to 50 seats, $20 usage included); Business $100 a month. Pricing |
| Glean | Company context | Glean's index | Plug-in or MCP host; MDM | Plug-in: Cursor, Claude Code, Codex; 13 MCP hosts | Existing Glean permissions | No price on glean.com on 16 October. Website |
| Sourcegraph | Code context | Your Sourcegraph instance | MCP; MCP#ACCESS permission | Claude Code, Codex, Cursor, Copilot, OpenCode, Amp | Existing repository permissions | MCP on Enterprise plans; Enterprise from $16K, minimum annual contract. Pricing |
| Unblocked | Code and company context | Unblocked's index | MCP; install script (macOS, Linux) or per-app guides | Guides including ChatGPT, Claude Code, Codex, Cursor, JetBrains IDEs, VS Code | Admin-managed Shared Memories; SSO and SCIM on Enterprise | Platform $29 per user a month, billed annually; 21-day trial, no card. Pricing |
| Augment workspace rules | Team rules | .augment/rules in the repository | Files under version control | VS Code and JetBrains | Through version control | Augment plans as above. Guidelines |
| BuildBetter ZeroShot | Team skills | Local, or hosted | Sessions turned into skills | Free card: Claude, Codex; Pro card adds Cursor, Gemini | Free hosted for up to 3 members | Local $0; Pro $100 per user a month; Enterprise SSO and SAML. Pricing |
| Packmind | Team rules and skills | .packmind/ in the repository, or self-hosted | Rendered files; MCP server and CLI | 10 targets, including Claude Code, Cursor, GitHub Copilot, Codex | Organizations; Spaces on Enterprise | Open plan free; Enterprise adds SSO, SAML, SCIM and data residency. Pricing |
| ByteRover | Local first | Local, with a cloud option | Published ByteRover skill | Agents through the skill | Selective sharing | Free card: shared agent memory for a small team. Website |
| claude-mem | Local first | Local SQLite and Chroma | Local worker; TeamBrain MCP tools | Claude Code, OpenClaw, Codex, Gemini, Hermes, Copilot, OpenCode and more | Optional TeamBrain; each person chooses | Open repository; TeamBrain join in v13.40.0. Repository |
| Pieces | Local first | On the device | MCP through PiecesOS | Claude, Cursor, Codex, Antigravity | Enterprise organization policy | Pro $18.99 and Enterprise $22.99 per user a month, billed monthly; 7-day Pro trial with a card. Pricing |
| Tencent's MemHub | Local first | One runtime per installation | Per-app MCP entry, Skill, hooks or plugin | Ten listed, eight marked open | One installation | Open repository (Apache-2.0). Release |
How to choose a cross-IDE context platform for a team
Use these five questions to turn the catalog into a shortlist.
What should persist, and who writes it?
Ask for a concrete example: an architectural decision, a repository answer, a review convention or a session handoff. Then trace its authoring path. Basic Memory accepts knowledge that teammates write. Sourcegraph serves code that already exists. Packmind distributes guidelines someone maintains. ZeroShot derives skills from sessions and reviews. These are different workflows even when the same coding assistant consumes the result.
Where may the data live?
Decide whether vendor cloud, your own servers or one developer's machine is acceptable before comparing connectors. For your own servers, look at TencentDB Agent Memory, Cognee's cognee-mcp in API Mode, Mem0 Open Source and self-hosted Packmind, and note their different jobs: a model-request proxy, a shared knowledge graph, a REST API with a dashboard, and rules distribution. Basic Memory also runs locally, without team features. Where memory is stored and where model requests go are separate questions; TencentDB Agent Memory sits in the path of every LLM request.
Who sees a new contribution, and from which plan?
Run the permission check above against each product on the shortlist. Then note which plan includes the control you need: SSO on Basic Memory Business, SSO and SCIM on Unblocked Enterprise, UserGroup ABAC on Zep Enterprise, per-tag limits on Supermemory Scale or Enterprise, and MCP itself on Sourcegraph Enterprise plans.
Must browser chats use the same context?
Check a browser connection separately from editor setup. Cognee names Claude on the web and ChatGPT; Supermemory documents a ChatGPT developer-mode setup; Zep has an administrator quickstart for Claude and ChatGPT. MemoryPlugin works through a browser extension. Tencent's MemHub connection prompt says web chats cannot use its local paths. Zep in Claude and ChatGPT
Does anyone work on Windows?
Require an installation path for each actual workstation. For Tencent's MemHub, Windows is not supported in v1.0.0; a maintainer said support would come, with no date. Unblocked's install script covers macOS and Linux, and on Windows its docs point to the guide for each app. An MCP endpoint is not evidence that a vendor's installer covers every operating system.
For a pilot, follow one contribution from authoring to retrieval in another teammate's tool. Check attribution, access scope and billing ownership along the way. That exercise tests the team's intended workflow rather than merely confirming that a connector starts. Re-check each vendor page before buying: the dates in this article are the read dates, not a promise that the plan is still there.
Common questions
What cross-IDE persistent context platforms are available for engineering teams?
Three kinds of product answer it. Shared memory stores the team writes to: Basic Memory, Cognee, Mem0, MemoryLake, MemoryPlugin, Mnemoverse, Supermemory and Zep in the vendor's cloud, or TencentDB Agent Memory on the team's own servers. Code and company context that agents search and read over MCP: Augment Context Engine, Glean, Sourcegraph and Unblocked. Team rules and skills rendered into each tool's own files: Packmind, Augment workspace rules and BuildBetter ZeroShot. In every option checked, each coding tool still gets its own connector or its own file.
Do all teammates see everything in a shared agent memory?
It depends on the vendor and the plan. Zep lets every authenticated MCP user search every shared Context Graph in the project until an administrator moves connections to UserGroup ABAC, an Enterprise feature on Zep's managed cloud. Supermemory invitations start on Pro, an invited Member gets every container by default, and per-tag limits need Scale or Enterprise. Cognee Cloud gives invited users all tenant-wide datasets, with access enforced per dataset. Letta agents are private to their creator by default.
Does each coding tool need its own setup and sign-in?
In every option checked, yes: each tool gets its own MCP entry, plugin, extension, proxy setting or instruction file, with its own sign-in where the vendor uses one. Unblocked's install script, Glean's MDM rollout and Packmind's rendered files do part of that setup in one step.
Can a team keep shared agent context on its own servers?
Yes, with some options: TencentDB Agent Memory as a self-deployed proxy, Cognee's open cognee-mcp in API Mode, Mem0 Open Source with its REST API and dashboard, and Packmind on Docker Compose or Kubernetes. Basic Memory also runs locally, without team features.
How is shared memory different from shared rules for coding agents?
Shared memory is written while people work: an agent saves a decision, and a teammate's agent in another tool finds it later. Shared rules are written once and rendered into the file each assistant reads, as Packmind does, or kept in Augment's .augment/rules folder under version control. A team can use both.
Is Tencent's MemHub a platform for teams?
Tencent documents MemHub as local-first, with one runtime and one data home per installation, and its connection prompt says that web chats, remote containers and another machine cannot use its local paths. Tencent's team product is a separate one, TencentDB Agent Memory from Tencent Cloud.
Sources
All pages read on 16 October 2026 unless another read date is given. Prices, plans and tool lists change; check the vendor's page before deciding.
- Tencent Hy-Memory and MemHub: Hy-Memory README; the MemHub folder; MemHub architecture; MemHub support table; Claude Code page; connection prompt in recall-installer.ts; release v1.0.0; issue 9 on Windows; Hy-Memory site; hy-memory on PyPI
- TencentDB Agent Memory: repository; install guide
- Basic Memory: integrations; Codex; Teams; Teams release note; pricing
- Cognee: Cloud MCP; cognee-mcp overview; members; permissions and access control; agent integrations; pricing
- Letta: ACP; hosted MCP; teams quickstart; permissions; shared memory; pricing (read 17 October)
- Mem0: Mem0 MCP; changelog highlights; Claude Code integration; organizations and projects; open-source setup; llms.txt; pricing
- MemoryLake: MCP integration; Claude Code integration; team knowledge base; concepts; coding agents; pricing
- MemoryPlugin: home page and plan comparison; memory features and FAQ; MemoryPlugin Sync download page (read 18 October)
- Mnemoverse: Coding assistants; Rooms (beta); API pricing; Editors
- Supermemory: MCP; MCP setup; Cursor plugin; billing; inviting team members; local and enterprise; pricing
- Zep: Context MCP Server; Zep in Claude and ChatGPT; role-based access control; Enterprise SSO; graph authorization; pricing
- Augment: Context Engine MCP; guidelines; pricing
- Glean: Glean plug-in; MCP host apps; about MCP; glean.com
- Sourcegraph: MCP; pricing
- Unblocked: what is Unblocked; MCP overview; JetBrains; Shared Memories; SSO; pricing
- Packmind: artifact rendering; managing AI agents; organizations; spaces; self-hosted install; pricing
- BuildBetter ZeroShot: home page; pricing
- Pieces: long-term memory; MCP; memory settings for teams; member permissions; general settings; pricing
- claude-mem and ByteRover: claude-mem repository; v13.40.0 release, TeamBrain; ByteRover; ByteRover V4 agents
Related
- MCP Servers That Share State Across IDEs: the mechanism behind several clients sharing one backend, and the ways it can stop.
- Rooms (beta): documentation for the sharing mechanism named in the Mnemoverse entry.
- Connecting editors: editor connection documentation.
Edward Izgorodin · Mnemoverse · 2026-10-16
Mnemoverse is a persistent-memory API for AI agents. Free key: console.mnemoverse.com · Plans and limits · Docs: Getting Started