EverMe provides a shared personal memory layer for supported AI agents. Its one-line setup lets an agent read the official installation instructions, install the EverMe CLI, guide you through authentication, and configure its own integration.

You can connect the CLI to the managed EverMe service or point it to a separately deployed EverOS instance. This gives users a choice between a managed experience and a self-hosted, open-source memory engine.

Key Takeaways

• EverMe’s official one-line setup begins by pasting a single instruction into a supported local AI agent.

• The EverMe CLI is installed through npm with npm install -g @everme/cli.

• Manual setup uses evercli auth login, evercli plugin install <agent>, and evercli doctor.

• Official integrations include Claude Code, Claude Desktop, Codex, Cursor, Devin, Hermes, Kimi Code, OpenCode, OpenClaw, Raven, WorkBuddy, and other supported environments.

• Connected agents use a shared account-level memory pool, helping relevant context follow the user across applications.

• The EverMe CLI and agent plugins are open source under Apache 2.0.

• Developers can use the managed EverMe service or connect the CLI to a self-hosted EverOS endpoint.

• EverOS is a separate open-source memory engine built around readable Markdown records with local SQLite and LanceDB indexes.

What Is the EverMe One-Line Install?

The EverMe one-line install is an instruction that you paste into a supported AI agent already running on your computer.

Use the following official instruction:

Read https://everme.evermind.ai/SKILL.md and follow the instruction to install and configure EverMe.

The agent reads the official EverMe installation skill and follows its instructions to:

1. Install the EverMe CLI.

2. Guide you through authentication.

3. Install the appropriate EverMe integration for that agent.

4. Check that the configuration is working.

This is different from running a one-line shell installer. The instruction delegates the documented setup process to the agent, reducing the need to edit configuration files manually.

Developers who want full control can complete the same process manually.

EverMe Installation Prerequisites

Before installing EverMe manually, make sure the local environment has:

• A supported AI agent or client

• Node.js and npm

• A browser that can complete the authentication flow

• Permission to install the EverMe CLI and update the selected agent’s configuration

The supported integration list may change as new plugins are added. Check the official EverMe GitHub repository before installation for the latest compatibility information.

If you plan to connect EverMe to a self-hosted EverOS deployment, you will also need the URL of that EverOS endpoint.

How to Install EverMe Manually

If you prefer not to use the agent-guided one-line instruction, complete the following steps in your terminal.

Step 1: Install the EverMe CLI

Install the official CLI package through npm:

npm install -g @everme/cli

The npm package provides the evercli command used for authentication, agent integration, memory import, and diagnostic checks.

This command installs the EverMe client toolchain. It does not install or start the separate EverOS memory engine.

Step 2: Authenticate

Run:

evercli auth login

This command opens a browser-based Device Flow for authentication.

The managed EverMe service handles the account and hosted memory connection. If you want to use a self-hosted EverOS deployment instead, set its address before signing in:

export EVERME_API_BASE=https://your-host

evercli auth login

Replace https://your-host with the address of your EverOS endpoint.

Step 3: Connect an Agent

Install the integration for the AI agent you want to use:

evercli plugin install <agent>

Replace <agent> with a supported integration name. For example:

evercli plugin install claude-code

evercli plugin install codex

evercli plugin install cursor

evercli plugin install openclaw

You can run more than one plugin installation command if you want multiple agents to access the same EverMe memory pool.

Each agent has its own configuration surface. The EverMe CLI applies the appropriate settings and integration files for the selected client.

Step 4: Check the Installation

Run the official diagnostic command:

evercli doctor

This checks the EverMe CLI configuration and installed integration.

After the diagnostic check completes, open the connected agent and ask:

What do you remember about me?

The agent can then use EverMe’s memory resources, including the mem://profile resource, to retrieve relevant information.

A configured plugin or MCP entry confirms that the integration was registered. Testing a real memory request provides a more complete check of authentication and memory access.

Which AI Agents Does EverMe Support?

The current EverMe CLI repository documents integrations for the following agents and clients:

Some clients require an additional host-controlled step.

For example, the current EverMe documentation states that Kimi Code users must complete the plugin installation inside the Kimi Code interface. WorkBuddy users may also need to approve the new MCP server in its management interface.

Because integrations continue to evolve, use the EverMe repository’s compatibility table as the authoritative source.

How EverMe Shares Memory Across Agents

Every agent connected to the same EverMe account can use the same account-level memory pool. This allows relevant context to follow the user between supported applications instead of remaining tied to one agent session.

For example, information saved while using Claude Code may later be available to Codex or Cursor when those clients are connected to the same memory pool.

Whether a specific detail is returned depends on factors such as:

• Whether the information was successfully saved

• Whether memory processing and indexing completed

• The query used by the agent

• Memory permissions and scope

• The retrieval configuration

• The selected agent’s integration behavior

EverMe therefore supports cross-agent continuity, but it should not be interpreted as a guarantee that every previous message will be inserted into every future conversation.

For workflows involving several agents, see EverMind’s overview of its multi-agent memory platform.

EverMe, EverMe CLI, and EverOS: What Is the Difference?

EverMe and EverOS are related, but they serve different roles.

The EverMe CLI repository contains the command-line tool, MCP server, SDK components, agent hooks, and supported client integrations.

The managed EverMe product, including its hosted backend, account system, web application, and billing service, is separate from the open-source CLI repository.

EverOS is the underlying open-source memory engine. It is designed for developers who want a local-first or self-hosted memory runtime for agents and applications.

Managed EverMe vs. Self-Hosted EverOS

EverMe supports two general deployment paths.

Managed EverMe

The managed service is designed for users who do not want to operate their own memory infrastructure. The EverMe CLI authenticates with the hosted service and connects supported agents to the user’s memory pool.

Managed plan availability, pricing, included credits, roles, and memory limits can change. Check the live EverMe product page for current information before subscribing.

Self-Hosted EverOS

Developers who want to operate the memory engine themselves can deploy EverOS and direct the EverMe CLI to that endpoint.

Self-hosting EverOS is a separate process from installing the EverMe CLI. The current EverOS package requires Python 3.12 or later and can be installed with:

pip install everos

Alternatively:

uv pip install everos

The standalone EverOS demo can be started without an API key:

everos demo

For a basic server deployment, initialize EverOS:

everos init

Then start the server:

everos server start

The current EverOS Quick Start uses an OpenRouter API key for its basic Tier 1 configuration. Additional providers may be required for optional embedding, reranking, knowledge, or multimodal capabilities.

Follow the official EverOS Quick Start for current configuration instructions.

How EverOS Stores Memory

EverOS uses a local-first, Markdown-native storage design.

Canonical memory records are stored as readable Markdown files. EverOS then maintains local SQLite and LanceDB indexes to support retrieval and reuse.

This architecture provides several practical benefits:

• Memory records remain readable outside the application.

• Users can inspect and edit canonical Markdown files.

• Memory files can be diffed and version-controlled.

• SQLite and LanceDB run locally without requiring MongoDB, Elasticsearch, or Redis.

• Indexes can be synchronized with the underlying Markdown records.

• Memory can be scoped by user, agent, application, project, and session.

Using local storage does not necessarily mean that every EverOS configuration is fully offline. Network requirements depend on the models, embedding services, rerankers, and other providers selected by the developer.

EverOS Memory Performance

EverMind publishes benchmark and performance results for EverOS, including:

• 93.05% overall accuracy on LoCoMo

• 83.00% accuracy on LongMemEval

• 90.04% recall on HaluMem

• Retrieval latency below 500ms at p95

• Approximately 10× lower token cost in its published comparison with full-context approaches

These are EverMind-reported results obtained under defined evaluation setups. They describe the memory engine’s published benchmark performance, not a guaranteed result for every EverMe installation.

Production performance can vary based on:

• Hardware and hosting environment

• Network conditions

• Memory volume

• Retrieval configuration

• Model and embedding providers

• Query complexity

• Concurrent traffic

The HaluMem recall result should also not be interpreted as a guarantee that every retrieved memory will be correct or that an agent can never hallucinate.

Readers can review the current performance claims and benchmark summaries on the EverOS product page.

Is EverMe Open Source?

The EverMe client toolchain is open source under the Apache License 2.0. This includes the CLI and agent plugin repository used to connect supported clients to the memory layer.

EverOS is also available under the Apache License 2.0.

The license permits users to use, modify, and distribute the open-source code, including in commercial environments, subject to the license terms and applicable notices.

However, the open-source repositories should not be confused with the complete managed EverMe product. The hosted backend, web application, account system, and billing service are separate from the EverMe CLI repository.

Official repositories:

• EverMe CLI and agent plugins

• EverOS memory engine

What to Do After Installing EverMe

After the installation is working, you can:

1. Ask the connected agent what it remembers about you.

2. Save a test preference or project detail.

3. Start a new session and ask the agent to recall that information.

4. Connect another supported agent with evercli plugin install <agent>.

5. Test whether relevant memory can be retrieved from the second agent.

6. Review your memory and integration settings before using EverMe with sensitive data.

7. Explore the EverMind Skill Hub for reusable agent capabilities.

8. Read the official documentation for current authentication and configuration guidance.

Frequently Asked Questions

What is the official EverMe one-line install?

Paste the following instruction into a supported local AI agent:

Read https://everme.evermind.ai/SKILL.md and follow the instruction to install and configure EverMe.

The agent reads the official installation skill and follows the documented setup process.

What is the manual EverMe installation command?

Install the EverMe CLI with:

npm install -g @everme/cli

Then authenticate with evercli auth login, install the relevant integration with evercli plugin install <agent>, and run evercli doctor.

Is pip install evermind the correct EverMe command?

No. The official EverMe CLI is installed through npm as @everme/cli.

The separate EverOS Python package is installed with:

pip install everos

How do I verify that EverMe was installed correctly?

Run:

evercli doctor

Then open the connected agent and test a memory request. The diagnostic command checks the configuration, while the agent test helps confirm end-to-end memory access.

Can I connect more than one AI agent?

Yes. Run evercli plugin install <agent> for each supported client you want to connect. Agents connected to the same account can use the same account-level memory pool.

Start Using EverMe

The fastest way to begin is to paste the official installation instruction into a supported local AI agent: Read https://everme.evermind.ai/SKILL.md and follow the instruction to install and configure EverMe. For manual setup, install the CLI with npm, authenticate, install the appropriate agent plugin, and run evercli doctor.

Developers who want managed memory can connect to EverMe. Those who need control over their memory infrastructure can deploy the open-source EverOS memory engine and point the EverMe CLI to their own endpoint.