Does everos auto-invoke its skills?

Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.

Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.

Agent Memory

Plugin

everos

One portable memory layer for every AI agent: local-first, Markdown-native, user-owned, and self-evolving across apps, tools, and workflows.

BOOST

evermind-ai@evermind-ai

GitHub

Plugin Signal84/100Strong

maintained100

capable52

documented100

adopted88

Install

$ npx -y skills add evermind-ai/everos --agent claude-code

Stats

Python TypeScript HTML Bash SQLite

+7 tags

Vercel Git GitHub Markdown Anthropic OpenAI Hugging Face

13,357

Stars

927

Forks

Active

Maintenance

Python

Language

Apache-2.0

License

21h ago

Last commit

11mo ago

Created

6h ago

Added

Repo: evermind-ai/everos

In this plugin

6 commands 5 skills

commands
skills

See everything inside

What's inside

Skill(5 skills)

/add-memory-kindAdd a new business memory kind end-to-end. Pick the storage combination (Markdown / SQLite / LanceDB), pick the markdown strategy (daily-log / skill-named / single-file), then wire up the schema(s), repo(s), and writer(s)./commitStage and create a Conventional Commits message for the current change /new-branchCreate a GitHub branch from main with the project naming convention

Command(6 commands)

/askThe question to answer /debugView EverMem debug logs to troubleshoot memory saving and retrieval issues /helpGet help with EverMem plugin setup and available commands

Badges

README

ExcerptRead the full README on GitHub

EverOS banner

Website · Documentation · Blog · 中文

Why EverOS
Ecosystem Integrations
Quick Start
Use Cases
Documentation
EverMind Ecosystem
Contributing

Why EverOS

EverOS is a Python library and local-first memory runtime for agents and makers. It gives one portable memory layer across coding assistants, apps, devices, and workflows from day one. It stores conversations, files, and agent trajectories as readable Markdown, then syncs local SQLite and LanceDB indexes for fast retrieval and self-evolving reuse.

Ecosystem Integrations

EverOS adds durable memory to the agent and workflow platforms below—and comes built into Raven. Choose an integration to open its setup guide.

Quick Start

One OpenRouter API key is enough to start EverOS, write durable memories, and retrieve them with keyword search.

Prerequisites

Python 3.12+
One OpenRouter API key

1. Install

uv pip install everos
# or: pip install everos

2. Try the standalone demo — no key required

No API key or server setup required—run one command to quickly experience how EverOS stores and recalls memory:

# If you installed EverOS as a package:
everos demo

# If you cloned or forked this repository and have not activated .venv:
uv run everos demo

Enter something EverOS should remember, then ask a related question to watch the memory move through ingest -> extract -> index -> recall.

https://github.com/user-attachments/assets/98cb8e1e-2ca8-4504-b0a6-0b9a040a0a5c

3. Initialize and add your OpenRouter key

everos init

This creates ~/.everos/everos.toml and ~/.everos/ome.toml. Open ~/.everos/everos.toml; the generated model and OpenRouter URL are already correct, so replace only the empty api_key:

[llm]
model = "openai/gpt-4.1-mini"
api_key = "<OPENROUTER_API_KEY>"
base_url = "https://openrouter.ai/api/v1"

This is the smallest Tier 1 setup: memory add, flush, Markdown persistence, cascade indexing, and keyword search.

Use everos init --root <path> if you want a different memory root. Pass the same --root <path> to subsequent commands.

4. Start EverOS

everos server start

Keep the server running, then open a second terminal and check it:

curl http://127.0.0.1:8000/health

Look for "status":"ok". With this one-key setup, capabilities.llm is true; embedding and rerank remain false until you configure them.

5. Add and retrieve your first memory

[!NOTE] Business endpoints live under /api/v2. The older /api/v1 prefix still resolves to the same handlers so existing integrations keep working, but it is a legacy alias that may be removed in a future major release — write new code against /api/v2.

Add a tiny conversation:

TS=$(($(date +%s)*1000))

curl -X POST http://127.0.0.1:8000/api/v2/memory/add \
  -H 'Content-Type: application/json' \
  -d "{
    \"session_id\": \"demo-001\",
    \"app_id\": \"default\",
    \"project_id\": \"default\",
    \"messages\": [
      {\"sender_id\": \"alice\", \"role\": \"user\", \"timestamp\": $TS, \"content\": \"I love climbing in Yosemite every spring.\"},
      {\"sender_id\": \"alice\", \"role\": \"user\", \"timestamp\": $((TS+10000)), \"content\": \"My favorite coffee shop is Blue Bottle in SOMA.\"}
    ]
  }"

Flush the memory at the end of the session:

curl -X POST http://127.0.0.1:8000/api/v2/memory/flush \
  -H 'Content-Type: application/json' \
  -d '{"session_id":"demo-001","app_id":"default","project_id":"default"}'

Search it back:

curl -X POST http://127.0.0.1:8000/api/v2/memory/search \
  -H 'Content-Type: application/json' \
  -d '{
    "user_id": "alice",
    "app_id": "default",
    "project_id": "default",
    "query": "Where do I like to climb?",
    "method": "keyword",
    "top_k": 5
  }'

You should see the Yosemite memory in the response. Keep "method": "keyword" in this one-key setup because the API defaults to hybrid search, which requires an embedding provider.

[!TIP] First memory unlocked. You just gave EverOS a fact, flushed it into durable Markdown-backed memory, and searched it back through the local index. That is the core loop. Want to see the source of truth? Open ~/.everos and inspect the generated Markdown files.

For annotated responses and the Markdown files EverOS creates, see QUICKSTART.md.

What works with one key?

The OpenRouter one-key setup is EverOS Tier 1. It supports server startup, memory add and flush, durable Markdown storage, cascade indexing, and keyword search. Add optional providers only when you need the features below:

Configuration	Adds
`[llm]` only	Core memory flow and keyword search
Add `[embedding]`	Vector/user hybrid search, reflection, and skill extraction
Add `[rerank]` too	Agentic search, default agent hybrid search, and Knowledge Wiki
Add `[multimodal]` and parser extra	Image, PDF, audio, and office-file ingestion

Missing optional capabilities are reported by /health and return a clear HTTP 422 if you request a feature that needs them.

[!NOTE] everos demo --live is different from the standalone demo in step 2: it connects to a running server and uses the real add/flush/search flow. It uses hybrid search, so add an embedding provider before you run it.

Optional: Ingest Multimodal Files

To ingest non-text content (image / pdf / audio / office documents) through /api/v2/memory/add content items, install the optional extra:

uv pip install 'everos[multimodal]'   # or: pip install 'everos[multimodal]'

This pulls in everalgo-parser (with the [svg] bundle for SVG support via cairosvg). Configure the [multimodal] section in everos.toml; its default model is google/gemini-3.8-flash via OpenRouter.

Office document support requires LibreOffice as a system dependency. The parser shells out to soffice (LibreOffice's headless renderer) to convert .doc / .docx / .ppt / .pptx / .xls / .xlsx to PDF before feeding the result into the multimodal LLM. Without LibreOffice, office uploads return HTTP 415 with a clear error message; PDF / image / audio / HTML / email parsing is unaffected.

Install on the host before serving office documents:

brew install --cask libreoffice              # macOS
sudo apt-get install -y libreoffice          # Debian / Ubuntu

For Contributors

git clone https://github.com/EverMind-AI/EverOS.git
cd EverOS
uv sync                              # creates ./.venv and installs deps
uv run everos demo --plain           # try the local educational demo; no API keys needed
uv run everos init                   # add one OpenRouter key to ~/.everos/everos.toml

uv run everos --help
make test

Use Cases

Now that you have had your first successful EverOS moment, explore what people are building with persistent memory across agents, apps, and community integrations.

Use cases show what persistent memory makes possible in real products and workflows. Some examples are packaged in this repository; others point to external demos or integrations you can study and adapt.

File tree

More plugins by @evermind-ai.

View @evermind-ai’s profile

VerifiedPlugin

Agent Orchestration Python Node

raven

One Surface, All Agents: Raven generates DAGs and orchestrates multiple specialized agents for complex tasks. Raven is the harness of harnesses, built for recursive self-improvement (RSI).

23 skills+15.3k

@evermind-ai

Install this plugin

FAQ

everos is a Claude Code plugin with 5 hand-picked skills for agent memory work, indexed on Flowy. Install it with the command on its page. It includes add-memory-kind, commit, new-branch. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.

What is everos?: One portable memory layer for every AI agent: local-first, Markdown-native, user-owned, and self-evolving across apps, tools, and workflows.
How do I install everos?: Run these in Claude Code: npx -y skills add evermind-ai/everos --agent claude-code. Then prompt normally.
Does everos auto-invoke its skills?: Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.
Is everos free?: Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.

Is this plugin yours?

Claim it with GitHub Submit a plugin Promote it

TS=$(($(date +%s)*1000)) curl -X POST http://127.0.0.1:8000/api/v2/memory/add \ -H 'Content-Type: application/json' \ -d "{ \"session_id\": \"demo-001\", \"app_id\": \"default\", \"project_id\": \"default\", \"messages\": [ {\"sender_id\": \"alice\", \"role\": \"user\", \"timestamp\": $TS, \"content\": \"I love climbing in Yosemite every spring.\"}, {\"sender_id\": \"alice\", \"role\": \"user\", \"timestamp\": $((TS+10000)), \"content\": \"My favorite coffee shop is Blue Bottle in SOMA.\"} ] }"

curl -X POST http://127.0.0.1:8000/api/v2/memory/search \ -H 'Content-Type: application/json' \ -d '{ "user_id": "alice", "app_id": "default", "project_id": "default", "query": "Where do I like to climb?", "method": "keyword", "top_k": 5 }'

Configuration

Adds

[llm] only

Core memory flow and keyword search

Add [embedding]

Vector/user hybrid search, reflection, and skill extraction

Add [rerank] too

Agentic search, default agent hybrid search, and Knowledge Wiki

Add [multimodal] and parser extra

Image, PDF, audio, and office-file ingestion

git clone https://github.com/EverMind-AI/EverOS.git cd EverOS uv sync # creates ./.venv and installs deps uv run everos demo --plain # try the local educational demo; no API keys needed uv run everos init # add one OpenRouter key to ~/.everos/everos.toml uv run everos --help make test