Covalence is a macOS native application that provides persistent, semantic long-term memory for any AI client through MCP (Model Context Protocol). It runs on the user's own hardware, without the need for a cloud or registered account, and all memories are stored locally in the form of SQLite files.

Covalence’s cross-client AI persistence memory layer

Core parameters and statistics

Project	Parameters
Product Positioning	Local persistence memory layer (MCP Server) across AI clients
Delivery form	macOS native desktop application (.dmg installation package)
Protocol/Interface	MCP (Model Context Protocol), exposing 9 Tools
Embedded model	nomic-embed-text-v1.5 (fp16, ~261MB, running locally)
Vector dimensions	256 (Matryoshka truncation, original 768→256)
Vector Index	sqlite-vec (vec0 KNN)
Keyword Index	SQLite FTS5 (BM25)
Fusion Strategy	Reciprocal Rank Fusion (k=60) + Hyperbolic Time Weighting (10%)
Minimum System Requirements	macOS 15 (Sequoia) or later, Apple Silicon
Storage backend	SQLite (local files, full user control)
Latest version	v1.4.0 (2026-04-27)
Licensing Model	Free, no account/no telemetry/no cloud dependencies
GitHub Stars	Unpublished (the main repository is a private repository darronz/covalence)

Covalence's positioning is very clear: it is not another AI chat tool, nor a knowledge base management system, but an infrastructure layer - inserting a layer of persistent memory between the AI client (Claude Desktop, Claude Code, Cursor, etc.) and the large model. All embedded computation is done natively on Apple Silicon through the MLTensor, without any third-party API or network calls.

User and market recognition

Gradually build user awareness in the field, and product capabilities are used by content creators and teams to improve work efficiency. Some industry users have incorporated it into their daily workflow. It is recommended to refer to the latest official disclosures for specific user scale and industry adoption rate data.

Cost advantage

C-side/Personal User: Covalence is completely free. No subscription fees, no pay-per-use, no hidden fees. Users only need to download and install, and all embedded calculations are completed on the local Mac without consuming any API credits. This is the most fundamental cost difference between it and cloud memory solutions (such as the API version of Mem0).

API/Developer: Covalence does not provide independent API services, but is embedded in the AI ​​client in the form of MCP Server. Developers don’t need to pay additional API call fees for memory functionality—the only cost is local compute and storage on the macOS hardware.

Enterprise/Private: Because Covalence's data is stored entirely within the user's SQLite file, enterprises can directly incorporate memory files into existing backup and security policies without the additional cost of a privatized deployment. However, the current version only supports stand-alone operation on macOS and does not support team sharing or multi-user collaboration. Enterprise-level memory sharing scenarios cannot yet be covered.

Hidden Costs: Mainly from macOS exclusives - if the workflow involves an AI client for Windows/Linux (like VS Code + Copilot on Windows), Covalence is not currently covered. In addition, there is about a 2% accuracy gap (official self-test) between the retrieval quality of the local embedding model (nomic-embed-text-v1.5) and the cloud large model embedding, which may not be as good as the dedicated fine-tuned model in semantic search in highly specialized fields.

Main functions

• Semantic Search Memory: Based on hybrid vector + keyword retrieval, the user's natural language query is converted into an embedding vector, and vec0 KNN cosine similarity search and FTS5 BM25 full-text search are performed simultaneously in local SQLite, sorted by Reciprocal Rank Fusion, supplemented by hyperbolic aging weighting (the new memory weight is slightly higher, but the aging only accounts for 10% of the total score to prevent overwriting the true relevance).
• Core Memories: Users can mark the most important knowledge as "core memories", and these memories will always be returned first when AI searches. Core memory can only be explicitly set by the user, and AI has no right to upgrade ordinary memory to core independently, ensuring that users maintain full control over key information.
• Spaces (space isolation): Use the --space parameter to divide the memory into independent partitions. The memories of different projects, different clients or different purposes do not interfere with each other. A --space corresponds to an independent partition in the SQLite database, and searches and browsing only return results for the current space.
• File Memories: New function in v1.4.0, which can monitor local folders and automatically index the contents of Markdown/text/configuration files as read-only memory for AI search. Supports YAML frontmatter parsing and .gitignore style ignore rules with a 1MB file size limit.
• MCP Tool Set: Exposes 9 standard MCP Tools (see the tool open list below for details). AI clients can call these tools through the standard MCP protocol to complete memory additions, deletions, modifications, and status monitoring.

Model and version evolution

Covalence's version iteration will accelerate from April 2026 and is currently undergoing rapid evolution from CI verification to feature delivery:

Early pipeline validation period (v1.3.2 - v1.3.5)

These four releases focus on the stability of the CI/CD pipeline. v1.3.2 is the first round of end-to-end automated release verification; v1.3.3-v1.3.4 fixes pipeline problems such as missing embedded models, incorrect DMG upload paths, and unsynchronized release notes; v1.3.5 urgently fixes a P0-level bug that crashed the application at startup without Xcode.

Mainline feature release (v1.4.0)

v1.4.0, released on April 27, 2026, is the first major feature version, bringing three core capabilities: file synchronization (Anchor Memories) allows Covalence to automatically index local folder content; AI Instruction rewriting makes behavior guidance more precise; Space Switcher (Space Switcher) provides UI support for multi-project management. Also released is the cov-benchmark command line tool for retrieving quality benchmarks (current score 30/30).

Technical advantages

Covalence's technical architecture is designed around the three principles of "local priority, privacy and security, and low latency". The following explains its mechanism and effects from the perspective of the causal chain.

Native embedding + Matryoshka truncation: The embedding model nomic-embed-text-v1.5, running through MLTensor on Apple Silicon, outputs a 768-dimensional vector that is immediately truncated to the first 256 dimensions. This design is based on the discovery of Matryoshka Representation Learning that the first N dimensions are themselves a valid embedding subset, only losing about 2% of retrieval accuracy, but reducing storage space from 3KB to 1KB per memory. For memory banks that grow with conversations, three times the storage efficiency means users can maintain memory cycles longer on equivalent hardware.

Asymmetric search encoding: The query and document are encoded using different text prefixes (search_query: vs search_document:) so that the query and document fall into different regions of the vector space. Cosine similarity measures "can the document answer this question" rather than "whether the two pieces of text are similar". This is crucial in AI memory scenarios - the user's search intent is usually a question rather than a copy and paste, and asymmetric encoding is better suited to question-and-answer retrieval than symmetric encoding.

Hybrid Retrieval Fusion (RRF): Vector similarity search and BM25 keyword search are executed in parallel, each taking max(limit×4, 20) candidates (×6 when there are filter conditions to compensate for the loss of post-Swift layer filtering), filtered by cosine threshold (default 0.3) and then merged and sorted by Reciprocal Rank Fusion (k=60). This standard parameter (same as Microsoft Azure AI Search and Elastic) ensures the stability of the fusion. A 10% aging weight ensures that new memories win out if they are equally relevant, but that older memories that are truly relevant are not overwritten by aging.

Zero external dependency architecture: The entire system - database, embedded model, search engine - all runs on the user's hardware. No network calls, no API keys, and no third-party cloud dependencies. Memory files are SQLite files that are fully owned by the user and can be exported to Markdown or JSON at any time.

How to use

Get started quickly in 3 minutes

The use of Covalence is divided into two steps: installing the application + configuring the MCP connection.

1. Install the application

Download the latest DMG from covalence.app, drag Covalence.app into the /Applications directory and launch it. Requires macOS 15+ and Apple Silicon.

2. Configure MCP connection

Taking Claude Desktop as an example, add: in ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "covalence": {
      "command": "/Applications/Covalence.app/Contents/MacOS/cov-mcp"
    }
  }
}

Claude Code users add via command line:

claude mcp add covalence /Applications/Covalence.app/Contents/MacOS/cov-mcp

Cursor users add the same JSON configuration in Settings > MCP Servers.

3. Add AI commands (recommended)

Add Covalence's behavior guidance directives to the AI client's system prompts to tell the AI when to use memory_search and memory_store. The instruction content is available at covalence.app/docs/ai-instruction/.

Tool open list (MCP Tools)

Covalence exposes the following 9 Tools through the MCP protocol, which the AI client can call directly:

Tool name	Function	Key parameters
memory_store	Store new memory	content(required), title, tags, metadata, core
memory_search	Semantic search memory	query(required), limit, threshold, tags, source, core
memory_list	Browse recent memory	limit, offset, source, tags, core
memory_retrieve	Get complete memory by ID	id(required)
memory_delete	Permanently delete memory	id (required)
memory_update	Update memory content	id (required), content, title, tags, metadata
memory_promote	Upgrade to core memory	id (required)
memory_demote	Downgrade to normal memory	id (required)
memory_status	Get current space statistics	No parameters

Architecture link

AI Client (Claude Desktop / Claude Code / Cursor / OpenCode)
    ↓ MCP Protocol (stdin/stdout)
cov-mcp (Covalence MCP Server, macOS native binary)
    ↓
SQLite Database (local file)
    ├── vec0 virtual table (vector index, 256-dimensional cosine similarity)
    └── FTS5 virtual table (keyword index, BM25)

Engineering Pitfall Guide

1. Token and context control: Covalence's memory_search returns 5 results by default (maximum 20). The Token consumed by the AI client for each search is determined by the length of the returned memory content. It is recommended to set a reasonable limit value in the AI ​​instruction to prevent a single search from introducing too many contexts and filling the window. The limit of memory_list defaults to 10 and the maximum is 50. When browsing in pages, pay attention to the increasing offset.

2. Tag filtering and performance: When using tags/source/core filter conditions, Covalence's vector search will over-fetch (taking limit×6 candidates) because filtering is performed at the Swift layer rather than the SQL layer. This means that a filtered search consumes more local computing resources than an unfiltered search. In high-frequency filtering scenarios, it is recommended to control the limit value to avoid unnecessary performance loss.

3. Impotence and security of file synchronization: File memories (File Memories) are read-only, and Covalence does not modify the source file. However, after a file is deleted or moved, the corresponding memory will not be automatically cleaned up - it needs to be handled manually in the application settings ("Keep or delete" option). In addition, cov-mcp currently only communicates through local stdin/stdout and does not expose network ports (remote MCP transmission is in the roadmap), so there is no risk of network unauthorized access, but you need to pay attention to the access permissions of SQLite files when multiple users share the same macOS account.

Product Pricing

The pricing model is subject to the official real-time page. Usually a freemium or subscription system is used, and basic functions can be used for free. Advanced functions or high-frequency use require paid subscriptions, and users are advised to evaluate the optimal solution based on actual usage.

Application scenarios

• Cross-session context retention: When developers use Claude Code or Cursor for multi-day project development, Covalence can remember the technical decisions, code specifications, and key constraints of the previous stage, avoiding the need to explain the context from scratch for each new conversation. Key points to verify: Whether AI automatically calls memory_search at the beginning of a new session, and whether the retrieved memory contains the decision-making information required for the current task.
• AI transformation of personal knowledge base: Add the folders containing personal notes, technical documents, and configuration files to Covalence's monitoring list, and the AI ​​client can directly search for these local contents in the conversation without manual copying and pasting. Verification focus: Automatic re-indexing delay after file changes, and YAML frontmatter parsing support for structured metadata.
• Multi-item memory isolation: Create an independent memory space for each item through the --space parameter, so that the AI ​​will not "erroneously recall" the context of item B when processing item A. Suitable for developers who maintain multiple client projects or technology stacks at the same time. Key points of verification: Whether the AI ​​can accurately identify the current space after space switching, and whether the data isolation across spaces is complete.

Does not fit the boundary

• Covalence is currently only available for macOS and is not available to Windows/Linux users.
• Network transport MCP (remote/network transport) is not supported, and clients such as ChatGPT that only support remote MCP connections are temporarily unavailable.
• The single-machine architecture determines that it is not suitable for team shared memory or multi-user collaboration scenarios.
• Searches based on nomic-embed-text-v1.5 have limited accuracy in highly specialized fields (such as legal terms, medical literature), and the embedding model cannot be customized.

Applicable people

• AI developers on macOS platform: Developers who use AI programming tools such as Claude Code and Cursor are core users of Covalence. They require project context to be maintained across sessions and have high requirements for privacy and local control. Prerequisites: macOS 15+, Apple Silicon.
• Claude Desktop Heavy Users: Users who use Claude as a daily knowledge assistant can use Covalence to let Claude remember personal preferences, project background, and important decisions without having to manually provide context every time. Precondition: Accept about 2% recall precision loss caused by local embedding.
• Privacy-sensitive AI users: Users who are reluctant to upload their conversation history to the cloud due to data compliance or privacy concerns. Covalence's zero remote call architecture ensures that "data does not leave the local machine". Prerequisite: Willingness to manage your own backup and export of SQLite files.

Not applicable to the crowd

• Users primarily using ChatGPT (remote MCP client) - Covalence does not currently support the network transport modes required by ChatGPT.
• Users who need cross-platform (Windows/Linux) or cross-device memory synchronization.
• Teams that need a team collaboration memory or an enterprise-level knowledge management platform.

Summary and Outlook

Covalence enters the AI memory layer market with the differentiated positioning of "local first + MCP protocol". Its core value is: Does not rely on any cloud services, does not incur any ongoing costs, and only provides persistent semantic memory for AI clients through local embedding and hybrid retrieval running on the user's hardware. In terms of technical architecture, the three designs of Matryoshka truncation, asymmetric search coding and RRF fusion together constitute an engineering solution with theoretical support and quantitative trade-offs - about 2% accuracy in exchange for 3 times storage efficiency, which is a reasonable trade-off in the context of personal devices.

The current version (v1.4.0) has complete functional coverage: semantic search, core memory, spatial isolation, file synchronization MCP tool set, which basically meets the memory needs of individual users. However, the key constraints of the project are equally obvious: macOS exclusiveness, stand-alone architecture, no team collaboration capabilities, and project maintenance relying on the input of individual developers. In the context of the rapid changes in the AI ​​tool ecosystem, remote MCP transmission support and cross-platform support will be key nodes that determine whether it can evolve from an "interesting personal project" to a "widely adopted memory layer standard."

Acquisition/Adoption Risk Assessment: Covalence has almost zero adoption cost for individual developers (free + no registration + 5 minutes to configure) and can be tried as a "plug-and-play" enhancement to Claude Code/Cursor workflows. The trial period is recommended to be 1-2 weeks, focusing on evaluating: whether the AI ​​can automatically call the memory tool as expected, whether the retrieval results cover the key context in daily development, and whether macOS exclusivity conflicts with the current workflow. Enterprises need to verify before purchasing: the secure backup solution for SQLite files, the long-term risks of currently not having enterprise version support, and the commercial sustainability of the project maintainer. For scenarios that require cross-platform or team collaboration memory, it is recommended to also pay attention to the progress of solutions such as LangSmith and Mem0.

Related tools: github-copilot, cursor

Version Info

• File Sync, AI Instruction Rewrite & Space Switcher ：Added a new file synchronization function (Anchor Memories), which can automatically index the contents of local folders; fully rewritten AI instructions; added a new space switcher; and released the retrieval quality benchmark tool cov-benchmark. （2026-04-27）
• P0 Hotfix ：Fixed the serious issue of application startup crash without Xcode, and corrected the Swift runtime library embedding logic of the CI build pipeline. （2026-04-20）
• Pipeline Fix Release ：Three CI pipeline bugs in v1.3.3 have been fixed (embedded model missing DMG URL error, release notes not uploaded), and there are no user-side functional changes. （2026-04-19）
• Phase-Gate Round-Trip ：The first fully automatic CI/CD pipeline verification version, verifying the dispatch→workflow→commit→CF automatic deployment end-to-end process. There is no official precise date yet, please refer to the actual release label. （2026-04-16）