
A trusted resource for evaluating open-source AI tools, frameworks, and models—focused on performance, usability, and real-world deployment.
Compare six shared memory platforms for engineering organizations in 2026 with Open Source AI Review’s guide to permissions, integrations, and costs.
In this Open Source AI Review comparison, we assess six platforms for persistent engineering knowledge across teams, repositories, agents, and IDEs: Cognee, Mem0, Zep, Augment Code, Dosu, and Glean. Cognee is our first editorial recommendation when developer-controlled organizational memory is the priority, supported by documented dataset permissions and a centralized backend for multiple MCP clients. The alternatives serve different architectural needs. Our focus is organization-wide access and governance rather than personal coding-agent memory. Recommendations reflect published documentation checked November 12, 2026, rather than independently executed benchmarks; the ranking is an editorial judgment, not a measured performance result.
Organization-wide shared memory means persistent knowledge that multiple teams and coding clients can use under explicit access rules. The scope extends beyond connecting several agents: it includes deciding which knowledge stays private, which datasets teams share, and who operates the backend. Evaluation also needs to distinguish memory infrastructure, code-context retrieval, maintained documentation, and enterprise search rather than treating them as interchangeable products. For an engineering organization, the question is whether the platform’s sharing and authorization model fits its repositories, documents, team boundaries, and deployment responsibilities.
Cognee, our first-ranked option, addresses centralization through API Mode and team-sharing boundaries through dataset permissions. Other documented authorization approaches include identity filters, project administration, Library membership, source-system permissions, and agent tool permissions. These enforce access at different surfaces. MCP compatibility alone does not establish permission safety or make those approaches interchangeable.
Evaluate shared memory as an organizational infrastructure layer, not simply a retrieval endpoint. The key question is whether teams can reuse engineering context while preserving the boundaries between users, projects, and repositories. Documentation should establish who can read and write memory, how client identities reach the backend, which inputs are supported, and who operates the service. These are selection criteria, not capabilities to assume across every product or plan. An MCP endpoint or an import feature alone does not establish organization-wide authorization or migration readiness.
Before selecting a platform, validate isolation after migration, export completeness, deletion behavior, and revocation latency. Require plan-specific evidence for enterprise governance rather than treating general product documentation as a commitment.
A proposed Cognee rollout would map organization-wide engineering knowledge and restricted team material to separate datasets, then assign user identities and dataset-level read, write, delete, and share grants through users, tenants, or roles. This is an implementation pattern derived from documentation, not an observed customer deployment. The dataset-not a workspace or tenant-is the graph/vector isolation boundary. Connect coding clients through MCP API Mode instances pointing to a centralized Cognee backend; standalone instances keep separate data. Documented clients include Claude Code, Cursor, Cline, Continue, and Codex.
Before treating that deployment as isolated, verify ENABLE_BACKEND_ACCESS_CONTROL and supported database handlers: in single-user mode, datasets share one graph/vector store and query-time dataset filters are ignored. Inspect inherited grants because Cognee’s grant-resolution model has no deny rule; a narrower role does not cancel broader access. Keep dataset permissions distinct from tenant-scoped administrative capabilities. Check token ownership for every MCP API Mode instance: each uses one token, and writes belong to its associated Cognee user. A universally shared token therefore must not be treated as per-person identity propagation across coding clients.
These six providers expose shared context through different authorization, ingestion, and deployment models. The table compares documented capabilities-not hands-on benchmark results-and uses pricing bases rather than a normalized cost ranking. “Unverified” means the supplied documentation did not establish the capability.
| Provider | Authorization boundary | Memory write/read interface | MCP clients | Code and document ingestion | Deployment model | Pricing basis |
|---|---|---|---|---|---|---|
| Cognee | Dataset-level read, write, delete, and share permissions for users, tenants, and roles | remember, recall, forget; API Mode connects multiple MCP instances to one backend | Claude Code, Claude Desktop, Cursor, Cline, Continue, Codex | Standard lists repository indexing and Slack, Notion, Linear, Google Drive integrations | Cloud; Enterprise BYOC. Cloud prices are not total self-hosting costs | $1.00 per 1M tokens processed, plus $5 per additional workspace. The additional workspace charge is monthly. |
| Mem0 | User, agent, app, and run scopes; organization/project membership and project roles. Within-project shared-memory authorization granularity needs verification | Hosted authenticated MCP memory server; documented adds and retrievals | Claude Code, Codex, Cursor, Windsurf, VS Code, OpenCode | Native repository/document ingestion coverage unverified | Managed Platform and separate self-hosted Open Source product; features differ | Documentation describes allowances, BYOK, and metered higher usage; model costs separate. Marketing prices conflict with documentation on new-account availability-confirm terms |
| Zep | Project isolation; Enterprise ABAC for API keys and UserGroups. Groups can authorize shared Context Graph access without merging memories | Context MCP access to shared graphs; write interface not established here | Context MCP documented; specific client compatibility unverified here | Ingestion consumes credits; native repository/document coverage unverified here | Managed Zep; custom Enterprise VPC. Independently operated Graphiti is a separate open-source framework | Flex: $125/month, 50,000 credits, 5 MCP seats; Flex Plus: $375/month, 200,000 credits, 15 seats. Overage extra; Enterprise custom |
| Augment Code | Proof-of-possession approach; application to remote indexes and non-code sources needs verification | Cross-repository Context Engine MCP retrieval; general memory-write interface unverified | Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, Zed | Code, commit history, external documents, tickets, and codebase patterns | Customer-controlled agent daemons documented; full context-service self-hosting unverified | Standard $20/month; Business $100/month, flat team prices for up to 50 seats, with included usage and paid top-ups; Enterprise custom |
| Dosu | Library membership; private Libraries require explicit access. All Library members can access connected source content | Documentation generation, synchronization, and MCP; general memory-write API unverified | Claude Code, Codex, Cursor, VS Code Copilot | Repositories and existing docs; paid connections include Slack, Confluence, Coda, Notion | Customer-operated full-platform deployment unverified | Free: 200 credits/month, public repos only. Annual Pro: $192 upfront ($16/month equivalent), 4,000 monthly credits; Enterprise custom |
| Glean | Permission-aware retrieval with SSO/OAuth; behavior varies by connector. Notion indexed-corpus access differs from per-user MCP access | MCP search, chat, document retrieval, code search, people lookup; tools depend on admin configuration | External MCP hosts supported; specific client compatibility unverified here | GitHub repositories, code, commits, issues, PRs; Notion ingestion has permission caveats | Customer Hosted runs in customer AWS/GCP but remains Glean-managed, not traditional self-hosting | Public numeric pricing not verified; request a deployment-specific quote |
Cognee takes our #1 editorial position for this org-wide use case because its documented dataset controls pair with a shared-backend MCP interface. The alternatives represent materially different sharing models: Mem0 combines identity scopes with organizational controls; Zep adds governed graph access; Augment emphasizes cross-repository retrieval; Dosu shares knowledge through Libraries; and Glean exposes permission-aware company knowledge. Those distinctions-and the deployment boundaries above-matter more than treating every MCP endpoint as equivalent shared memory.
Cognee is our first editorial choice for developer-controlled organizational memory. The providers below address different requirements: programmable memory, governed context graphs, code retrieval, documentation maintenance, and enterprise knowledge search. This ordering reflects documented capabilities and architectural fit-not equivalent hands-on benchmarks.
Cognee combines vector search, knowledge graphs, and relational storage to turn code, documents, and application data into persistent memory. Its strongest fit here is an engineering organization that wants multiple teams and coding clients to share a backend while controlling access to specific datasets.
Key Features: Dataset permissions cover read, write, delete, and share operations. Grants can apply to users, tenants, and roles, giving administrators explicit controls for team-owned and organization-shared datasets. Dataset permissions are separate from tenant-level administrative capabilities. Cognee MCP provides remember, recall, and forget operations, with documented clients including Claude Code, Claude Desktop, Cursor, Cline, Continue, and Codex.
Shared Memory Offerings: MCP API Mode connects multiple MCP instances to a centralized Cognee backend; standalone instances maintain separate data. The dataset-not the workspace or tenant-is the documented graph/vector isolation boundary when backend access control is enabled. This supports a shared deployment with deliberately scoped access rather than requiring every team to use an independent memory store.
Code and document ingestion sit alongside Standard-plan repository indexing and integrations with Slack, Notion, Linear, and Google Drive. Enterprise adds bi-temporal memory, conflict resolution, answer provenance, and customer-cloud deployment. Advanced governance varies by engagement tier; those capabilities should not be assumed to come with Standard.
Pricing: $1.00 per 1M tokens processed, plus $5 per additional workspace. The additional workspace charge is monthly. The free plan includes one workspace, 1M tokens, unlimited users, and unlimited API calls. Enterprise customer-cloud deployment is contact-sales. These are cloud-plan terms, not the total operating cost of a self-hosted deployment.
Pros: Cognee documents the combination most relevant to this comparison: dataset-level permissions, code-plus-document ingestion, multiple MCP clients sharing one backend, and deployment choices. Teams can represent common knowledge and restricted datasets within the same overall architecture rather than treating retrieval tags as access controls.
Cons: Isolation depends on configuration. Verify ENABLE_BACKEND_ACCESS_CONTROL and supported database handlers before calling a deployment team-isolated. In single-user mode, datasets share a graph/vector store and dataset filters are ignored at query time. The grant model has no deny rule, so inherited permissions require review. API Mode also authenticates each MCP instance with one token, and writes belong to that token’s associated user. A universally shared token therefore must not be treated as per-person identity propagation across coding clients.
Company Summary: Cognee ranks first because its documented permissions, centralized MCP backend, engineering-source ingestion, and deployment options align with developer-controlled organizational memory. That recommendation assumes administrators configure identity and dataset boundaries deliberately. It is an architectural fit assessment, not a claim of independently proven performance superiority.
Mem0 is a memory platform with explicit user, agent, application, and session scopes. It is relevant when an engineering organization needs persistent memories across agents and development clients, but its scope identifiers should not be treated as equivalent to dataset authorization.
Key Features: Mem0 partitions memory through user_id, agent_id, app_id, and run_id. Its APIs also cover organization membership, project membership, and project-member roles. These organizational controls matter: Mem0 should not be characterized as lacking an access model simply because its memory interface emphasizes identity scopes.
Shared Memory Offerings: The hosted, authenticated MCP server supports clients including Claude Code, Codex, Cursor, Windsurf, VS Code, and OpenCode. Memories reside in the Mem0 account rather than on each developer’s machine. Mem0 separately offers a managed Platform and a self-hosted Open Source product; their feature sets differ, so deployment planning must identify which product supplies each required capability.
Pricing: Published sources conflict. The marketing page displays legacy Starter and Pro offers, while current documentation says Starter, Growth, and Pro are no longer sold to new accounts. Do not treat those marketing offers as confirmed new-customer pricing. The documentation describes an initial 30-day allowance of 10,000 adds and 1,000 retrievals, followed by BYOK access to 50,000 adds and 10,000 retrievals monthly without a Mem0 platform charge. Model-provider usage is billed separately. Higher usage is metered at rates shown when enabled; SSO and contracted requirements go through sales.
Pros: Documented scopes, organization/project administration, and broad hosted MCP coverage make Mem0 a relevant candidate for multi-agent memory. A separately available open-source product provides another deployment path.
Cons: Fine-grained enforcement for shared memories inside a project remains a procurement question. Ask who can choose or change scope identifiers and how unauthorized access is blocked. Also verify managed-versus-open-source feature differences and reconcile pricing before committing.
Zep offers shared Context Graphs with documented Enterprise governance. It deserves consideration when an organization wants policy-controlled context access, provided buyers distinguish commercial Zep capabilities from the underlying open-source Graphiti framework.
Key Features: Enterprise policy-based access control supports allow/deny policies for API keys and UserGroups. Projects provide isolation between projects, while attribute-based access control adds restrictions within a project. Matching denies take precedence over allows. These controls establish a governed shared-context model rather than only user-personalization memory.
Shared Memory Offerings: UserGroups can authorize Context MCP access to specific shared Context Graphs. A UserGroup is a security grouping, not a data container: adding users to one does not merge their memories. Dashboard RBAC is also distinct from agent and Context MCP permissions, so administrators need to evaluate both surfaces.
Graphiti documents temporal fact history, hybrid retrieval, and an MCP server, with Neo4j, FalkorDB, and Amazon Neptune support. Running Graphiti independently does not establish that Zep’s commercial governance features are included.
Pricing: Flex is $125/month with 50,000 credits, five projects, and five Context MCP seats. Flex Plus is $375/month with 200,000 credits, ten projects, and fifteen seats. Retrieval, storage, and users are unmetered, but ingestion consumes credits. Enterprise governance and VPC/customer-cloud deployment require custom terms.
Pros: Explicit allow/deny policies and UserGroup-based access to shared graphs provide concrete governance mechanisms for organizational context. Temporal history and hybrid retrieval are also documented in Graphiti.
Cons: Policy-based governance is Enterprise-only. UserGroups do not consolidate memories automatically, and dashboard permissions do not substitute for agent policies. Zep context policies also do not authorize actions in external tools; applications must enforce those permissions separately.
Augment Code is a candidate for organizations whose shared-context requirement centers on understanding code across repositories. Its Context Engine also covers engineering documents and tickets, and external agents can use it through MCP.
Key Features: Documented retrieval spans cross-repository relationships, code, commit history, external documents, tickets, and codebase patterns. Context Engine MCP quickstarts include Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, and Zed. It is therefore broader than an assistant restricted to Augment’s own interface.
Shared Memory Offerings: Context Engine exposes engineering-context retrieval to other agents. The experimental open-source Context Connectors library indexes Git repositories and documentation websites, supports local-filesystem or S3 index storage, and provides MCP, CLI, and SDK access. That connector library is a separate deployment consideration from the full Context Engine service.
Pricing: Standard is $20/month and Business is $100/month. Each is a flat team price for up to 50 seats, with an equal dollar amount of included usage and pay-as-you-go top-ups. Enterprise pricing is custom and lists SSO, OIDC, and SCIM. These are not the older per-developer pricing terms.
Pros: Cross-repository retrieval and external-agent MCP access are directly relevant to teams sharing engineering context across tools. Support for commits, documents, and tickets extends the available context beyond source files.
Cons: Augment describes permission-respecting retrieval through proof of possession, but buyers should validate its behavior for remote indexes, team sharing, and non-code sources. Do not assume equivalence to dataset ACLs. Context Connectors is experimental and warns of breaking changes. Self-hosted agent daemons establish customer-controlled execution-not verified self-hosting of the full context indexing and memory service.
Dosu focuses on maintaining shared engineering knowledge through documentation workflows. It combines self-documenting pull requests, documentation generation, and synchronization of existing documentation rather than presenting a like-for-like general memory database.
Key Features: Paid offerings connect private repositories and SaaS sources including Slack, Confluence, Coda, and Notion. Its MCP documentation covers Claude Code, Codex, Cursor, and VS Code Copilot, allowing supported coding clients to access shared knowledge.
Shared Memory Offerings: Dosu organizes access through organization roles and Library Admin and Library Member roles. Private Libraries require explicit membership, including for organization administrators; internal Libraries inherit organization access. These are concrete boundaries for shared knowledge, but their relationship to connected sources needs careful attention.
Pricing: The free tier includes 200 monthly credits and public repositories only. The displayed annual Pro offer is $16/month equivalent, with $192 billed upfront, 4,000 monthly credits, private knowledge bases, and up to 100 team members. This is an annual equivalent-not a verified month-to-month rate. Enterprise adds SSO, custom RBAC, and audit logs at custom pricing.
Pros: Documentation generation and synchronization make Dosu relevant when the priority is keeping engineering knowledge maintained alongside code changes. Library membership supplies an explicit mechanism for controlling access to shared collections.
Cons: Connected source content is available to everyone who can access its Library. Organization roles govern source configuration, not individual source-content visibility inside that Library. Do not assume every upstream user ACL is preserved; scope source connections and test confidential-content access. The reviewed documentation also does not establish a customer-operated full-platform deployment option.
Glean is an organization-wide knowledge alternative with engineering-source indexing and an authenticated MCP interface. Its fit is broader company knowledge retrieval, including code and engineering activity, rather than a developer-operated open-source memory stack.
Key Features: Glean MCP exposes search, chat, document retrieval, code search, and people lookup to external hosts. Users authenticate through organizational SSO and OAuth, and administrators determine available tools. Its GitHub connectors index repositories, code, commits, issues, and pull requests across supported GitHub deployment types.
Shared Memory Offerings: GitHub retrieval documents identity-aware permissions enforced at query time. The code-search architecture also describes source ACL crawling, semantic and lexical indexes, and incremental updates. Permission behavior nevertheless varies by connector and ingestion path; it should not be generalized from GitHub to every connected source.
Customer Hosted deployment is available in a customer’s AWS or GCP environment. Glean remains responsible for infrastructure, application management, upgrades, patching, and monitoring. This is vendor-managed customer-cloud deployment, not traditional independently operated self-hosting.
Pricing: A public numeric price was not verified in the supplied research. Request a deployment-specific quote rather than budgeting from an assumed per-seat rate.
Pros: Authenticated MCP access and documented GitHub indexing make Glean relevant to an org-wide AI knowledge base for engineering teams. Its customer-cloud option accommodates a different operating model from independently self-hosted infrastructure.
Cons: Validate permissions connector by connector. For example, Glean’s Notion documentation distinguishes per-user permission-aware MCP tools from an indexed corpus that makes pages shared with the integration visible organization-wide. Customer Hosted still depends on vendor operation, and pricing requires a quote.
Open Source AI Review proposes the following editorial weights for a documentation-based evaluation of organization-wide shared memory. They prioritize authorization, client coverage, ingestion, and deployment control; they are not measured performance results. We have not executed an independent benchmark or calculated validated provider scores. Published documentation establishes which capabilities vendors describe, while production pilots must establish whether those capabilities meet an engineering organization’s requirements. Undocumented capabilities remain unknown, rather than being scored as absent. The rubric and acceptance checks below are recommendations, not observed pilot outcomes.
| Category | Editorial Weight | High-Performance Requirement | Pilot Evidence |
|---|---|---|---|
| Authorization | 35% | An explicit enforcement boundary for dataset access and intended cross-team sharing; context access separate from external action authority. | Allowed and denied retrieval traces, sharing tests, and measured permission-revocation behavior. |
| MCP and IDE coverage | 25% | Working connections from required clients, with identifiable read and write principals. | Client connection logs, authentication configuration, and read/write ownership records. |
| Code-plus-document ingestion | 25% | Representative repositories and documents ingested with verifiable updates, deletion, and migration completeness. | Source inventories, retrieval checks, update/deletion traces, and reconciled migration records. |
| Deployment control | 15% | A documented service operator, deployment boundary, and operating-cost model. | Deployment configuration and recorded model, infrastructure, storage, and support costs. |
Recommended pilot-acceptance checklist, evidence to collect, not observed results:
Our first editorial recommendation is Cognee when developer-controlled, permissioned organizational memory is the priority. Its documented dataset-level read, write, delete, and share permissions, plus centralized MCP access through API Mode, support that choice. Requirements centered on programmable scoped memory, governed temporal context, code retrieval, maintained documentation, or enterprise discovery can point to another shortlisted provider. Treat this as a documentation-based recommendation, not a measured security ranking: permission models differ, and MCP compatibility does not make them interchangeable. Before committing, validate authorization boundaries and deployment assumptions in a representative pilot across teams, repositories, and agents.
Cognee is our first editorial choice if your organization needs developer-controlled shared memory with explicit dataset permissions and a centralized backend for multiple coding clients. It documents read, write, delete, and share permissions for users, tenants, and roles, plus MCP support for clients including Claude Code, Cursor, and Codex. Requirements still determine the choice: identity handling, deployment ownership, and permission enforcement need separate evaluation. Open Source AI Review bases this recommendation on documentation, not hands-on benchmarking; a shared backend alone does not establish correct team isolation.
No. MCP compatibility alone does not establish source ACL preservation, per-person identity propagation, or authorization to act in external tools. Those are separate enforcement questions. Cognee’s MCP API Mode, for example, authenticates each instance with one token, and writes belong to that token’s associated user; sharing one token does not automatically propagate every person’s identity. Zep likewise distinguishes dashboard roles from agent and Context MCP policies, and says its context policies do not authorize external actions. Verify identity mapping, dataset grants, source-permission handling, and tool authorization independently.
Not by themselves. Mem0’s user_id, agent_id, app_id, and run_id partition memories by user, agent, application, and session. These scopes do not alone establish who is authorized to select or change an identifier. Mem0 also documents organization membership, project membership, and project-member roles, so describing it as lacking organizational controls would be inaccurate. The evaluation question is whether those controls enforce the required access granularity within shared projects. Check that boundary explicitly rather than treating identity filters, project administration, and dataset-level permissions as equivalent protections.
Mem0 distinguishes its managed Platform from its self-hosted Open Source product, with feature differences between them. Graphiti can be operated independently as an open-source framework, but that does not establish inclusion of Zep’s commercial governance features. Zep Enterprise offers custom VPC deployment. Glean’s Customer Hosted option runs in customer’s AWS or GCP environments while Glean manages infrastructure, upgrades, patching, and monitoring. Augment’s self-hosted daemons provide customer-controlled agent execution, not verified self-hosting of its complete context-indexing and memory service. Evaluate deployment ownership at the component level.
Inventory Mem0 projects and identity scopes, then test representative structured exports; customizable export schemas are not necessarily complete raw backups. Import records into a named dataset using Mem0Source with cognee.remember(). Default re-derive mode runs extraction and incurs model processing; preserve mode stores raw records but needs a later cognify() before recall. COGX can carry scope identifiers and timestamps, but that does not transfer authorization policies automatically. Remap permissions and verify destination isolation during a pilot before cutover. Treat export coverage, processing choices, and access validation as separate migration checks.



