akitaonrails/ai-memoryPublic

Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors

AI summary: A unified long-term memory layer that persists context across different AI coding agents and development environments.

Stars
15.6K
+289 today
Forks
1.1K
Watchers
70
Open issues
16
Open PRs
2
Contributors
~201
Commits
6.1K
Branches
56
Views (30d)
32

RustMITCreated May 21, 2026Last push 1d agoLatest release v3.4.5+580 stars this week+6.5K this month

Quick answers

What is ai-memory?
A unified long-term memory layer that persists context across different AI coding agents and development environments.
What does ai-memory do?
AI-memory provides a centralized repository for storing the context, decisions, and architectural notes generated during AI coding sessions. Instead of losing history when switching between tools like Claude Code, Cursor, or Codex, this tool quietly observes and captures information across more than twenty supported agent harnesses. It consolidates session data into human-readable wiki pages upon completion. When a new agent is launched in the same directory, it retrieves this shared memory through search and brief context injection. This ensures continuity in complex projects without requiring developers to repeatedly re-explain architectures or past failures.
Who is ai-memory for?
This tool is intended for developers and teams who utilize multiple AI coding assistants and struggle with context fragmentation. It is ideal for those managing complex, long-running projects where architectural decisions need to be reliably communicated across different tools.
How popular is ai-memory on GitHub?
akitaonrails/ai-memory has 15,591 stars and 1,141 forks on GitHub, and gained 580 stars in the last 7 days.
What license does ai-memory use?
akitaonrails/ai-memory is released under the MIT license.

Star history

since Aug 18, 2026
05K10K15KAug 2026Sep 2026Oct 2026Nov 2026
15.6K stars as of Nov 10, 2026. Measured daily since Aug 18, 2026; GitHub no longer exposes earlier star timestamps.

Update history

5 recorded
  • Nov 10, 2026New release v3.4.5 (previously v3.3.2).
  • Nov 3, 2026New release v3.3.2 (previously v3.2.3).
  • Oct 25, 2026New release v3.2.3 (previously v3.1.1).
  • Oct 18, 2026New release v3.1.1 (previously v2.6.3).
  • Oct 10, 2026New release v2.6.3 (previously v2.5.2).

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-16: 0 commits2025-11-17: 0 commits2025-11-18: 0 commits2025-11-19: 0 commits2025-11-20: 0 commits2025-11-21: 0 commits2025-11-22: 0 commits2025-11-23: 0 commits2025-11-24: 0 commits2025-11-25: 0 commits2025-11-26: 0 commits2025-11-27: 0 commits2025-11-28: 0 commits2025-11-29: 0 commits2025-11-30: 0 commits2025-12-01: 0 commits2025-12-02: 0 commits2025-12-03: 0 commits2025-12-04: 0 commits2025-12-05: 0 commits2025-12-06: 0 commits2025-12-07: 0 commits2025-12-08: 0 commits2025-12-09: 0 commits2025-12-10: 0 commits2025-12-11: 0 commits2025-12-12: 0 commits2025-12-13: 0 commits2025-12-14: 0 commits2025-12-15: 0 commits2025-12-16: 0 commits2025-12-17: 0 commits2025-12-18: 0 commits2025-12-19: 0 commits2025-12-20: 0 commits2025-12-21: 0 commits2025-12-22: 0 commits2025-12-23: 0 commits2025-12-24: 0 commits2025-12-25: 0 commits2025-12-26: 0 commits2025-12-27: 0 commits2025-12-28: 0 commits2025-12-29: 0 commits2025-12-30: 0 commits2025-12-31: 0 commits2026-01-01: 0 commits2026-01-02: 0 commits2026-01-03: 0 commits2026-01-04: 0 commits2026-01-05: 0 commits2026-01-06: 0 commits2026-01-07: 0 commits2026-01-08: 0 commits2026-01-09: 0 commits2026-01-10: 0 commits2026-01-11: 0 commits2026-01-12: 0 commits2026-01-13: 0 commits2026-01-14: 0 commits2026-01-15: 0 commits2026-01-16: 0 commits2026-01-17: 0 commits2026-01-18: 0 commits2026-01-19: 0 commits2026-01-20: 0 commits2026-01-21: 0 commits2026-01-22: 0 commits2026-01-23: 0 commits2026-01-24: 0 commits2026-01-25: 0 commits2026-01-26: 0 commits2026-01-27: 0 commits2026-01-28: 0 commits2026-01-29: 0 commits2026-01-30: 0 commits2026-01-31: 0 commits2026-02-01: 0 commits2026-02-02: 0 commits2026-02-03: 0 commits2026-02-04: 0 commits2026-02-05: 0 commits2026-02-06: 0 commits2026-02-07: 0 commits2026-02-08: 0 commits2026-02-09: 0 commits2026-02-10: 0 commits2026-02-11: 0 commits2026-02-12: 0 commits2026-02-13: 0 commits2026-02-14: 0 commits2026-02-15: 0 commits2026-02-16: 0 commits2026-02-17: 0 commits2026-02-18: 0 commits2026-02-19: 0 commits2026-02-20: 0 commits2026-02-21: 0 commits2026-02-22: 0 commits2026-02-23: 0 commits2026-02-24: 0 commits2026-02-25: 0 commits2026-02-26: 0 commits2026-02-27: 0 commits2026-02-28: 0 commits2026-03-01: 0 commits2026-03-02: 0 commits2026-03-03: 0 commits2026-03-04: 0 commits2026-03-05: 0 commits2026-03-06: 0 commits2026-03-07: 0 commits2026-03-08: 0 commits2026-03-09: 0 commits2026-03-10: 0 commits2026-03-11: 0 commits2026-03-12: 0 commits2026-03-13: 0 commits2026-03-14: 0 commits2026-03-15: 0 commits2026-03-16: 0 commits2026-03-17: 0 commits2026-03-18: 0 commits2026-03-19: 0 commits2026-03-20: 0 commits2026-03-21: 0 commits2026-03-22: 0 commits2026-03-23: 0 commits2026-03-24: 0 commits2026-03-25: 0 commits2026-03-26: 0 commits2026-03-27: 0 commits2026-03-28: 0 commits2026-03-29: 0 commits2026-03-30: 0 commits2026-03-31: 0 commits2026-04-01: 0 commits2026-04-02: 0 commits2026-04-03: 0 commits2026-04-04: 0 commits2026-04-05: 0 commits2026-04-06: 0 commits2026-04-07: 0 commits2026-04-08: 0 commits2026-04-09: 0 commits2026-04-10: 0 commits2026-04-11: 0 commits2026-04-12: 0 commits2026-04-13: 0 commits2026-04-14: 0 commits2026-04-15: 0 commits2026-04-16: 0 commits2026-04-17: 0 commits2026-04-18: 0 commits2026-04-19: 0 commits2026-04-20: 0 commits2026-04-21: 0 commits2026-04-22: 0 commits2026-04-23: 0 commits2026-04-24: 0 commits2026-04-25: 0 commits2026-04-26: 0 commits2026-04-27: 0 commits2026-04-28: 0 commits2026-04-29: 0 commits2026-04-30: 0 commits2026-05-01: 0 commits2026-05-02: 0 commits2026-05-03: 0 commits2026-05-04: 0 commits2026-05-05: 0 commits2026-05-06: 0 commits2026-05-07: 0 commits2026-05-08: 0 commits2026-05-09: 0 commits2026-05-10: 0 commits2026-05-11: 0 commits2026-05-12: 0 commits2026-05-13: 0 commits2026-05-14: 0 commits2026-05-15: 0 commits2026-05-16: 0 commits2026-05-17: 0 commits2026-05-18: 0 commits2026-05-19: 0 commits2026-05-20: 0 commits2026-05-21: 10 commits2026-05-22: 43 commits2026-05-23: 43 commits2026-05-24: 34 commits2026-05-25: 47 commits2026-05-26: 31 commits2026-05-27: 23 commits2026-05-28: 19 commits2026-05-29: 17 commits2026-05-30: 19 commits2026-05-31: 5 commits2026-06-01: 13 commits2026-06-02: 28 commits2026-06-03: 4 commits2026-06-04: 12 commits2026-06-05: 6 commits2026-06-06: 18 commits2026-06-07: 0 commits2026-06-08: 4 commits2026-06-09: 0 commits2026-06-10: 0 commits2026-06-11: 11 commits2026-06-12: 8 commits2026-06-13: 3 commits2026-06-14: 13 commits2026-06-15: 19 commits2026-06-16: 6 commits2026-06-17: 17 commits2026-06-18: 6 commits2026-06-19: 4 commits2026-06-20: 9 commits2026-06-21: 8 commits2026-06-22: 7 commits2026-06-23: 6 commits2026-06-24: 16 commits2026-06-25: 0 commits2026-06-26: 17 commits2026-06-27: 0 commits2026-06-28: 2 commits2026-06-29: 2 commits2026-06-30: 3 commits2026-07-01: 11 commits2026-07-02: 14 commits2026-07-03: 2 commits2026-07-04: 3 commits2026-07-05: 1 commit2026-07-06: 1 commit2026-07-07: 3 commits2026-07-08: 2 commits2026-07-09: 10 commits2026-07-10: 20 commits2026-07-11: 9 commits2026-07-12: 7 commits2026-07-13: 15 commits2026-07-14: 4 commits2026-07-15: 7 commits2026-07-16: 0 commits2026-07-17: 4 commits2026-07-18: 5 commits2026-07-19: 12 commits2026-07-20: 10 commits2026-07-21: 16 commits2026-07-22: 16 commits2026-07-23: 19 commits2026-07-24: 6 commits2026-07-25: 17 commits2026-07-26: 3 commits2026-07-27: 29 commits2026-07-28: 5 commits2026-07-29: 13 commits2026-07-30: 31 commits2026-07-31: 9 commits2026-08-01: 16 commits2026-08-02: 2 commits2026-08-03: 8 commits2026-08-04: 15 commits2026-08-05: 5 commits2026-08-06: 7 commits2026-08-07: 8 commits2026-08-08: 0 commits2026-08-09: 1 commit2026-08-10: 0 commits2026-08-11: 2 commits2026-08-12: 4 commits2026-08-13: 1 commit2026-08-14: 5 commits2026-08-15: 7 commits2026-08-16: 14 commits2026-08-17: 7 commits2026-08-18: 14 commits2026-08-19: 18 commits2026-08-20: 2 commits2026-08-21: 11 commits2026-08-22: 6 commits2026-08-23: 7 commits2026-08-24: 9 commits2026-08-25: 9 commits2026-08-26: 6 commits2026-08-27: 3 commits2026-08-28: 20 commits2026-08-29: 5 commits2026-08-30: 6 commits2026-08-31: 19 commits2026-09-01: 54 commits2026-09-02: 19 commits2026-09-03: 36 commits2026-09-04: 18 commits2026-09-05: 10 commits2026-09-06: 11 commits2026-09-07: 12 commits2026-09-08: 13 commits2026-09-09: 15 commits2026-09-10: 10 commits2026-09-11: 25 commits2026-09-12: 6 commits2026-09-13: 2 commits2026-09-14: 8 commits2026-09-15: 19 commits2026-09-16: 11 commits2026-09-17: 3 commits2026-09-18: 35 commits2026-09-19: 19 commits2026-09-20: 40 commits2026-09-21: 41 commits2026-09-22: 16 commits2026-09-23: 26 commits2026-09-24: 41 commits2026-09-25: 43 commits2026-09-26: 7 commits2026-09-27: 8 commits2026-09-28: 38 commits2026-09-29: 35 commits2026-09-30: 25 commits2026-10-01: 67 commits2026-10-02: 63 commits2026-10-03: 42 commits2026-10-04: 33 commits2026-10-05: 5 commits2026-10-06: 48 commits2026-10-07: 41 commits2026-10-08: 48 commits2026-10-09: 101 commits2026-10-10: 40 commits2026-10-11: 55 commits2026-10-12: 77 commits2026-10-13: 155 commits2026-10-14: 31 commits2026-10-15: 94 commits2026-10-16: 46 commits2026-10-17: 98 commits2026-10-18: 45 commits2026-10-19: 75 commits2026-10-20: 23 commits2026-10-21: 166 commits2026-10-22: 91 commits2026-10-23: 28 commits2026-10-24: 37 commits2026-10-25: 42 commits2026-10-26: 54 commits2026-10-27: 13 commits2026-10-28: 105 commits2026-10-29: 69 commits2026-10-30: 32 commits2026-10-31: 59 commits2026-11-01: 31 commits2026-11-02: 26 commits2026-11-03: 40 commits2026-11-04: 51 commits2026-11-05: 35 commits2026-11-06: 50 commits2026-11-07: 114 commits2026-11-08: 58 commits2026-11-09: 53 commits2026-11-10: 45 commits2026-11-11: 0 commits2026-11-12: 0 commits2026-11-13: 0 commits2026-11-14: 0 commits
4,106 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Widely adopted

    15,591 stars

  • Very active

    4,106 commits in 52 weeks

  • Community-driven

    ~201 contributors

  • Well documented

    High community health score

  • Permissive license

    MIT

  • Continuous integration

    Automated checks passing

  • Repeat trending

    47 trending appearances

What ai-memory does

AI-memory provides a centralized repository for storing the context, decisions, and architectural notes generated during AI coding sessions. Instead of losing history when switching between tools like Claude Code, Cursor, or Codex, this tool quietly observes and captures information across more than twenty supported agent harnesses. It consolidates session data into human-readable wiki pages upon completion. When a new agent is launched in the same directory, it retrieves this shared memory through search and brief context injection. This ensures continuity in complex projects without requiring developers to repeatedly re-explain architectures or past failures.

This tool is intended for developers and teams who utilize multiple AI coding assistants and struggle with context fragmentation. It is ideal for those managing complex, long-running projects where architectural decisions need to be reliably communicated across different tools.

  • Cross agent compatibility: Supports seamless integration with over twenty different AI tools including Claude Code, Cursor, and Devin.
  • Silent observation: Hooks into existing workflows to capture context quietly without disrupting the user experience.
  • Wiki compilation: Consolidates captured session data into easily readable wiki pages when a coding task ends.
  • Context injection: Automatically provides necessary background information to new agents starting in a shared directory.
  • Shared memory pool: Centralizes data so multiple tools and teammates can access the same historical context.

Where teams use it

Maintaining project continuity

Ensure that context is not lost when switching from a terminal-based agent to a full IDE integration mid-task.

Onboarding new AI tools

Start using a completely different AI model on an existing codebase without having to explain the entire architecture from scratch.

Documenting failed approaches

Prevent different agents from attempting the same incorrect solution by persisting a record of previous debugging efforts.

Collaborative agent workflows

Allow multiple AI assistants to build upon the work of one another within the same directory.

README

main branch

ai-memory

Long-term memory for AI coding agents. Quit Claude Code mid-task, start OpenAI Codex in the same directory, continue without re-explaining the architecture, the failed approaches, or the open questions.

Website: aimemory.sh

Website Release Rust License

Why ai-memory

Your coding agent probably has a memory feature already. Claude Code takes its own notes, Cursor remembers some things, and every platform is adding more. They all have the same limits: the notes live on one machine, belong to one agent, and drop out of view when you switch tools or hand the work to a teammate.

ai-memory removes those limits.

  • It follows you across agents. More than twenty harnesses (Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Grok, Devin, Kimi, Kiro, and others) feed one shared memory. Quit Claude Code mid-task, open Codex in the same directory, and the next agent picks up a handoff that says where you left off, what failed, and what is still open. Handoffs are a typed protocol: each one has an owner and is claimed exactly once.

  • It can carry the session, not just a summary. Start agents with ai-memory run: quit Claude Code, run ai-memory run codex, and Codex gets the shared workstream plus a private, temporary local projection of Claude's visible native history for exact details the bounded startup packet omitted. The remote server receives only the harness and session identity, never the local transcript path or body. Direct harness launches behave exactly as before.

  • It follows you across projects. A small profile of how you usually work (your package manager, test layout, architecture habits) reaches every new repository at session start, so you stop re-explaining yourself. It sits below each repository's rules file as a default. It is on by default for a single user, and on a shared server it is opt-in and private per person. See docs/cross-project-profile.md.

  • It follows you across machines. Memory lives in a server you run, on the same laptop, a homelab box, or anywhere else, so the project you left on the desktop is the project you resume on the laptop, with the same knowledge and the same open questions.

  • It works for a team. Point everyone at one server, and what one person's sessions learn, everyone's agents can retrieve. Knowledge is shared per project; personal handoffs stay personal. Multi-user auth, per-person attribution, and an audit log are built in and are not a paid tier.

  • Your memory is plain markdown. The source of truth is a git-backed wiki of ordinary .md files: grep it, open it in Obsidian, edit it by hand, rsync it. The database is a derived index that can always be rebuilt from the files. There is no vector store to maintain and no content locked in a binary blob.

  • It captures the work itself, silently. Lifecycle hooks record what happened (prompts, tool calls, session boundaries), sanitize it at a typed privacy boundary before anything is stored, and the server consolidates it into readable pages. You do not have to ask it to remember anything. The default path uses zero LLM calls: capture, search, and handoffs all work with no API key.

  • It ages memory without an LLM. Memory decays on a schedule you can tune per tier, and memory you use decays slower: opening a page, searching it, or reaching it through a link counts as use. When episodic notes go cold they can be compacted down to their durable facts (file paths, error codes, decisions) instead of dropped. Near-duplicates collapse into one, and likely contradictions get flagged, all with zero API calls. Nothing is hard-deleted: the original stays in git and the version chain (restore-page brings it back). Access-weighted retention is always on because it can only keep memory longer. The parts that rewrite or drop content (compaction, dedup, per-tier curves) stay off by default until you turn them on.

  • It can also "dream", if you let it. With an LLM configured, an opt-in background pass rewrites whole clusters of cold notes into single coherent pages while you are idle, and cancels as soon as you come back to work. It never deletes a source (the pre-merge versions stay reachable), it is off by default, and it has to pass a recall eval before it could become default behavior. Unless you ask for more, the zero-LLM path above is what runs.

  • It is honest about itself. It ships as one self-contained binary. Purge commands say exactly what "deleted" means. The write ceiling (~700/s) is measured, not guessed. An audit log records every mutation.

How it works

capture ──▶ consolidate ──▶ recall ──▶ handoff
 hooks        session-end      search     next agent,
 observe      summaries as     + brief    any harness
 silently     wiki pages       injection

Agents emit sanitized observations through lifecycle hooks as you work. At session end, observations become coherent markdown pages in the project's wiki (optionally LLM-written; useful even without). The next session, in any agent on any machine, gets a bounded brief and can search everything: full-text, entities, links, and (optionally) vectors, fused into one ranking. Cross-agent handoffs pass the baton explicitly.

The full design, including the invariants that keep multi-user and multi-session use safe, is in docs/ARCHITECTURE.md.

An optional server-rendered management console provides user administration, session inspection and deletion, and personal MCP API keys. Build with --features management-ui and start serve --transport http --enable-management-ui; both compile-time and runtime opt-ins are required.

Support matrix

Every row below is a first-party integration (MCP registration, lifecycle hooks, or both) checked by CI. The full matrix with per-agent notes and caveats is in docs/support-matrix.md.

Area Status
Linux Supported
NixOS module Supported
macOS Supported
Windows via WSL2 Supported
Native Windows Experimental
Claude Code Supported
Codex Supported
Command Code Supported
Devin CLI Supported
OpenCode (V1/V2 auto-detected; legacy force-V2 aliases retained) Supported
Cursor Supported
Gemini CLI Supported
Oh My Pi / OMP Supported
Pi Supported
Crush Managed-only
Managed workstreams Opt-in
Claude Desktop MCP-only
OpenClaw Supported
Antigravity CLI Supported
Grok Build CLI Supported
Swival CLI MCP-only
Zero Supported
ZCode Supported
Kimi Code Supported
Kiro CLI Supported
Pool Hooks-only
GitHub Copilot CLI Supported
Factory Droid Supported
Meta Muse Code Supported
CodeBuddy Code Hooks-only
IBM Bob Supported
Qwen Code Supported
Qoder Supported
VS Code Copilot MCP-only
Zed MCP-only
DeepSeek Harness (DSH) Hooks + MCP
Cline CLI Hooks + MCP
FreeBuff MCP-only
Prime Agent MCP-only
Hermes Agent Supported
GrizzyBot Supported
LLM/auth providers Supported
Embedding providers Supported

Coming from another tool?

Most agent-memory tools optimize for one thing: extracting atomic facts per turn, a temporal knowledge graph, an agent-editable memory OS, or a hosted context API. ai-memory is built around a git-backed markdown wiki as the source of truth, with a derived index for retrieval. It captures automatically from lifecycle hooks, is shared across agents, machines, and people, and works with zero LLM calls by default. This table shows what carries over from each tool and what you gain:

Coming from… What's similar What you gain
Mem0 / fact extractors (LangMem) Automatic per-turn capture Memory compiles into readable pages you own and edit, not opaque fact rows; retrieval fuses FTS + entity + graph (+ local vectors) with no cloud API key
Zep / Graphiti (temporal KG) Temporal reasoning, typed relations Bi-temporal-lite (as_of, version-filtered search) and typed edges without standing up a graph database, in one binary
mcp-memory-service (fact rows, SQLite) SQLite + local embeddings, hook capture, typed edges, honest numbers, and, on 2.4, per-tier decay curves, extractive compression, DBSCAN cold-cluster dedup, access reinforcement, and contradiction flagging Human-editable markdown pages instead of fact-rows, cross-agent claim-once handoffs, and the same aging machinery done zero-LLM by default, reversibly (supersede-not-delete + restore-page), and off by default
basic-memory (file-first markdown) Markdown-on-disk as the source of truth Automatic lifecycle capture and a derived FTS/entity/graph index on top, cross-agent handoffs, and multi-user sharing built in
Claude Code built-in memory "Remember my project" convenience, zero setup Synced across machines and agents, searchable, team-capable, and captures tool lifecycle, unlike a per-laptop MEMORY.md
Hindsight / OpenViking (LLM or VLM in the loop) Living pages / document memory with a background consolidation loop, plus, on 2.4, belief-strength confidence plus an opt-in LLM "dream" rewrite of cold clusters A self-contained binary that runs zero-LLM by default and keeps memory in markdown files that are the source of truth, not a mirror; claim-once handoffs; the dream/belief features are opt-in, off by default, and never delete a source (vs a mandatory LLM loop)
Supermemory / LiquidLM (hosted memory API) A managed second brain with automatic ingestion Git-versioned markdown you own, no required API spend, offline operation, and per-project team sharing; ai-memory remembers this repo, not a general vault

Across all of these, ai-memory gives you files you own (git-backed markdown), a zero-LLM default, one self-contained binary, sharing across agents, machines, and teams, automatic lifecycle capture, and typed, claim-once handoffs. Opt-in features (LLM consolidation, vector search, the "dream" consolidation pass, belief-strength in ranking) stay opt-in, and the zero-LLM aging path (per-tier decay, extractive compaction, dedup, contradiction flagging, access-weighted retention) works with no API key at all.

Built on the shoulders of: the Karpathy LLM Wiki (compile-not-retrieve), agentmemory (hook capture for coding agents), basic-memory (markdown-on-disk truth), cognee (pipeline composition and triplet embeddings), Hermes Agent (the self-improvement loop), and A-MEM (Zettelkasten-style atomic notes).

The full comparison, covering where each approach wins, where ai-memory differs, and the published benchmark, is in How ai-memory compares.

Quick start

Linux and macOS (two commands, no root)

curl -fsSL https://github.com/akitaonrails/ai-memory/releases/latest/download/install.sh | sh
ai-memory setup

install.sh downloads the release for your OS and CPU, checks it against the release's published SHA-256 checksum (it refuses to install without a match), and links ~/.local/bin/ai-memory. ai-memory setup then creates the data directory with a bearer token in an owner-only file, starts a per-user service (systemd --user or a launchd LaunchAgent), and wires MCP, hooks and Agent Skills for every agent it finds, or the ones you name with --agent. It shows the plan, with where it found each agent, and asks first: answer y, or type the numbers of the agents to wire. --plan prints the plan and changes nothing, --web shows the plan as a page in your browser and applies the agents you tick there, --yes skips the question, and running it again changes nothing. Afterwards, restart your agents and ask one of them "What do you remember about this project?" to see it answer through ai-memory. Details, the environment variables and how to verify the script before running it are in docs/install.md. An AI agent installing ai-memory for you can follow INSTALL_FOR_AGENTS.md.

Claude Code and Codex users can wire their agent as a marketplace plugin instead (the binary is still installed as above):

claude plugin marketplace add akitaonrails/ai-memory && claude plugin install ai-memory@ai-memory
codex plugin marketplace add akitaonrails/ai-memory && codex plugin add ai-memory@ai-memory

Codex then asks you to trust the hooks in /hooks. See Marketplace plugins.

Windows (two commands, no admin)

In PowerShell:

irm https://github.com/akitaonrails/ai-memory/releases/latest/download/install.ps1 | iex
ai-memory setup

install.ps1 checks the release zip against its published SHA-256 checksum, unpacks it under %LOCALAPPDATA%\Programs\ai-memory and adds that directory to your user PATH. ai-memory setup then does what it does on Linux and macOS, with a logon entry in place of the service: the server starts when you sign in, with no console window, and restarts if it fails. Details and the other Windows setups (WSL2, Docker Desktop, a real Windows service) are in docs/windows.md.

With Scoop (ai-memory 3.4.0 or later):

scoop bucket add akitaonrails https://github.com/akitaonrails/scoop-bucket
scoop install ai-memory
ai-memory setup

Update it with scoop update ai-memory.

Arch Linux (AUR)

For native Arch installs, use the AUR packages. They install /usr/bin/ai-memory, packaged hook sources, and both system-level and user-level systemd units.

yay -S ai-memory-bin    # prebuilt Linux x86_64/aarch64 binary
yay -S ai-memory        # builds from source
ai-memory setup         # data dir, user service, agents, self-check

Homebrew (macOS and Linux)

The tap installs the prebuilt binary and its hook sources on macOS and on Linux, including atomic distributions such as Bazzite or Fedora Silverblue where Homebrew is the usual way to add tools:

brew install akitaonrails/tap/ai-memory
ai-memory setup         # data dir, user service, agents, self-check

Use either ai-memory setup or brew services start ai-memory, not both. Details are in docs/install.md.

Fedora (RPM)

Download the x86_64 or aarch64 RPM from the latest release, then install it:

sudo dnf install ./ai-memory-*.rpm

On a single-user workstation, ai-memory setup then does the rest, as on the two-command path above: data dir and token, a user service, the agents it finds, and a self-check.

ai-memory setup

System service installs use /var/lib/ai-memory and /etc/ai-memory/ via the packaged unit. Full user-service, system-service, auth, and provider setup is in docs/install.md#arch-linux-native-packages-aur.

macOS (menu bar app)

A self-contained .app that bundles the native ai-memory binary and hooks/ tree, starts the existing LaunchAgent, and opens /web, ai-memory status, and config.toml from the menu bar. Wiki, SQLite, config, and models stay in ~/Library/Application Support/ai-memory, so replacing the app is an update and does not rewrite that tree.

Needs a Rust toolchain and Xcode / Swift 6 (same as a source build):

git clone https://github.com/akitaonrails/ai-memory
cd ai-memory
./companions/ai-memory-macos/build.sh
open "companions/ai-memory-macos/dist/AI Memory.app"

Drag AI Memory.app to /Applications, then Install & Start Server from the menu extra (no Dock icon). The app reads the bearer token init wrote into its data dir, so the status item turns green on its own. Then wire your agents with the bundled binary; --no-service leaves the app's LaunchAgent in charge:

BIN="/Applications/AI Memory.app/Contents/Resources/runtime/ai-memory"
"$BIN" setup --no-service

Prebuilt tarball and launchd-without-the-app paths: docs/macos.md. Companion details: companions/ai-memory-macos.

Docker

You need: Docker or Podman + an agent CLI from the Support Matrix, or anything else that speaks MCP.

The published Docker image includes linux/amd64 and linux/arm64 variants, so Apple Silicon Macs and ARM64 Linux hosts can pull akitaonrails/ai-memory without --platform linux/amd64 emulation.

The Docker quick-start below has no authentication: the container never runs init, so it starts without a token. The server binds to loopback only, so nothing outside the machine can reach it, but local processes and browser pages can. Native installs that run ai-memory init get a bearer token by default; see Security below for that and for adding a token here.

# 1. Install the ai-memory CLI wrapper (a small shell script that
#    runs the binary inside a container with your $HOME mounted). This is
#    the only thing that needs to live on the host filesystem.
mkdir -p ~/.local/bin
wrapper_tmp="$(mktemp -d)"
trap 'rm -rf "$wrapper_tmp"' EXIT
wrapper_base=https://github.com/akitaonrails/ai-memory/releases/latest/download/ai-memory-wrapper
curl -fsSL "$wrapper_base" -o "$wrapper_tmp/ai-memory-wrapper"
curl -fsSL "$wrapper_base.sha256" -o "$wrapper_tmp/ai-memory-wrapper.sha256"
expected="$(awk 'NR == 1 { print $1 }' "$wrapper_tmp/ai-memory-wrapper.sha256")"
if command -v sha256sum >/dev/null 2>&1; then
    actual="$(sha256sum "$wrapper_tmp/ai-memory-wrapper" | awk '{ print $1 }')"
else
    actual="$(shasum -a 256 "$wrapper_tmp/ai-memory-wrapper" | awk '{ print $1 }')"
fi
[ -n "$expected" ] && [ "$actual" = "$expected" ] || { echo "wrapper checksum mismatch" >&2; exit 1; }
install -m 0755 "$wrapper_tmp/ai-memory-wrapper" ~/.local/bin/ai-memory
rm -rf "$wrapper_tmp"
trap - EXIT
# Most distros put ~/.local/bin on PATH automatically. If `which
# ai-memory` comes up empty, add this to ~/.bashrc / ~/.zshrc:
#     export PATH="$HOME/.local/bin:$PATH"

# 2. Start the server. `--restart unless-stopped` makes it come back
#    on docker daemon restart and on machine boot (provided your
#    docker service is enabled at boot — `sudo systemctl enable
#    docker` on most distros). Loopback-only bind (`127.0.0.1:49374`)
#    so nothing outside this machine can reach it. Omit the LLM /
#    EMBEDDING lines for zero-LLM mode — FTS5 search still works
#    without any keys.
docker run -d --name ai-memory \
    --restart unless-stopped \
    -p 127.0.0.1:49374:49374 \
    -v ai-memory-data:/data \
    -e AI_MEMORY_LLM_PROVIDER=anthropic \
    -e ANTHROPIC_API_KEY=sk-ant-... \
    -e AI_MEMORY_EMBEDDING_PROVIDER=openai \
    -e OPENAI_API_KEY=sk-... \
    docker.io/akitaonrails/ai-memory:latest

# 3. Wire your agent CLI in two commands. The wrapper takes care of
#    mounts and each client's config-path detection. Re-run with
#    `--agent codex`, `--agent command-code`, `--agent devin`, `--agent opencode`, `--agent opencode2`, `--agent gemini-cli`,
#    `--agent grok`, `--agent kimi-code`, `--agent kiro-cli`, `--agent copilot-cli`, `--agent droid`, `--agent muse`, `--agent cline`, `--agent qwen-code`, `--agent qoder`, `--agent omp`,
#    `--agent oh-my-pi`, `--client cursor`,
#    `--client gemini-cli`, `--client grok`, `--client kiro-cli`,
#    `--client cline`, `--client freebuff`, etc.
#    for additional agents; full list in docs/install.md.
ai-memory install-mcp   --client claude-code --apply
ai-memory install-hooks --agent  claude-code --apply

On Linux and macOS, the Docker wrapper runs install-hooks through its checksum-verified native host client. Global options may precede the command, for example ai-memory --config /path/to/config.toml run codex; the native client receives the complete argument list. The installed hooks therefore enforce client-side capture controls such as [capture] ignore_paths and allowlist mode before an event reaches the spool or network. Set AI_MEMORY_HOOK_PLATFORM=posix explicitly only when you need the legacy shell compatibility path; the installer warns that path cannot enforce capture policy v1.

The examples use docker; replace it with podman on a Podman host. The wrapper automatically uses Podman when Docker is not installed. Set AI_MEMORY_DOCKER=podman to force Podman when both engines are available.

That completes the setup on Linux/macOS. Start a Claude Code session as usual: every prompt and tool call now lands in ai-memory, and the next session you open in this project will see a handoff with where you left off. On macOS the native binary is the recommended path when you do not need Docker, either through the menu bar app above or a release tarball / launchd agent. Later updates for that path use ai-memory upgrade (checksum-verified GitHub release replace + hook refresh); see docs/install.md#keeping-ai-memory-up-to-date. The same native upgrade path covers Windows x86_64 zip installs under a writable prefix (see docs/windows.md Scenario C). Upgrading a 2.x install of any kind to 3.0? Read docs/upgrading-to-3.0.md first.

Wiring another agent is the same two commands with a different name: --client codex, --agent codex, and so on for every row of the support matrix. OpenCode is version-detected by host-side commands; when generating its artifacts inside a container, use setup-agent --agent opencode --opencode-dialect v1|v2 --to /tmp/unused because the container cannot inspect the host executable. The legacy opencode2, opencode-v2, and open-code2 aliases remain force-V2 compatibility spellings for old scripts; use opencode for new commands. The full per-agent guide, including Windows and remote servers, is docs/install.md.

Two agents in the same project at once, or teammates on one server, work out of the box: the "current project" pointer is isolated per caller by default (v1.39+). See docs/auto-scope.md for the optional session-aware Claude Code bridge and the details.

If in doubt, start your harness with ai-memory run. It is the preferred way to launch: the first time it runs a harness it auto-installs that harness's ai-memory hooks + MCP if they are missing (so capture and recall work without a separate install-hooks/install-mcp step to forget), it wires the right project scope by construction, and it adds cross-harness session continuity on top of shared memory. Everything is idempotent and one-time per harness and config home. If the server is unreachable, run warns and launches anyway with local capture spooling; run ai-memory recover after the server returns (see Degraded offline launches). Pass --require-server to fail closed instead.

ai-memory run claude
ai-memory run codex --yolo   # same workstream + local Claude history dossier
ai-memory run --profile work claude  # reusable config.toml env/account preset
ai-memory continue           # resume the newest managed checkout
# after a dead launcher left its lease behind (same operator only)
ai-memory run --force-unlock codex
ai-memory resume             # pick from ALL workstreams in this checkout only
ai-memory resume --search auth # find a workstream by name (case-insensitive)
ai-memory resume --all       # pick across every linked checkout

--force-unlock immediately expires the selected workstream's active lease; use it only when you know the previous launcher is gone. It does not kill a native process, and it cannot evict another authenticated operator's run. See the managed-workstream recovery notes for the full safety contract.

On a real harness switch, the receiving managed agent is told to consult AI_MEMORY_PREVIOUS_SESSION_HISTORY when you ask to continue and the bounded portable packet lacks a detail. The variable names a private temporary Markdown projection created from the previous harness's checkout-validated, read-only adapter; the file disappears when the managed child exits. It is local to the launcher machine. This covers quota exhaustion and other abrupt exits where the old harness cannot write a handoff: refreshed ai-memory routing also tells the new agent that "continue", "resume", and "pick up where we left off" mean to read that file first when the three managed-run variables are present. A switch on another machine still gets the server's portable ledger and handoff, but cannot read a native transcript that exists only on the first machine.

Without the managed launcher, a harness cut off the same way leaves no handoff at all, so the next one could pick up an older handoff or session page. When the newest captured work in the project is in another of your sessions that never ended and left no handoff after that work, the next session start carries a one-line notice that names that session. The agent then reads its newest prompts and tool results with memory_read_session_observations. The same session is listed first in memory_briefing's recent_sessions, and memory_handoff_list names it as newer_unended_session.

If that variable is absent on a real same-machine switch, run type -a ai-memory and ai-memory --version in the launching shell. This path requires the 3.1.0 or newer host client; a stale Cargo or package-manager binary earlier in PATH can shadow an updated wrapper.

In resume, type to search, use Up/Down to select a workstream, and Left/Right to choose its harness. Enter launches the selection; Escape clears a search, then cancels when the search is empty (Ctrl-C always cancels). The list scrolls and loads every checkout-local page; there is no default workstream cutoff. Use --limit N only when you want to cap the matching results. Workstreams from other repositories or worktrees are left out unless you pass --all, which lists every linked checkout (the current one first); continue still resumes the newest linked checkout from anywhere. Listing reads Git identity only; it does not scan the working tree with git status before showing the picker. Full checkpoints are still captured when launching the selected workstream.

Auto-wiring is on by default; opt out with ai-memory run --no-autowire or AI_MEMORY_RUN_AUTOWIRE=false. You can still wire agents by hand with install-hooks / install-mcp (e.g. for a harness you never launch through ai-memory run).

ai-memory uninstall --apply removes everything ai-memory installed, and only what it installed. It also clears ai-memory run's auto-wire record, so the next managed launch wires that harness again; to keep it unwired, launch with --no-autowire or set AI_MEMORY_RUN_AUTOWIRE=false. Install commands are idempotent and write timestamped backups next to any file they touch.

NixOS

This flake ships a NixOS module (nixosModules.default) with a systemd.services.ai-memory unit: a dedicated ai-memory system user (nologin, no linger) plus a hardened systemd sandbox (ProtectSystem = "strict", empty capability sets, MemoryDenyWriteExecute, RestrictAddressFamilies, and the rest; see nix/systemd-sandbox.nix). Packaged FHS units under packaging/systemd/ keep their existing lighter hardening. The flake exports packages for x86_64-linux, aarch64-linux, and aarch64-darwin. Intel macOS remains supported by the release tarball and Homebrew, but not by the pinned Nixpkgs revision.

{
  inputs.ai-memory.url = "github:akitaonrails/ai-memory";

  outputs = { nixpkgs, ai-memory, ... }: {
    nixosConfigurations.myhost = nixpkgs.lib.nixosSystem {
      system = "x86_64-linux";
      modules = [
        ai-memory.nixosModules.default
        {
          services.ai-memory = {
            enable = true;
            # enableWeb = true;  # off by default — the web UI is opt-in
            # enableApi = true;  # API-only companions; no browser UI
            settings = {
              allowed_hosts = [ "localhost" "127.0.0.1" "::1" "homelab.example" ];
              log_level = "info";
            };
            # Loopback (default): secrets optional; missing env file is tolerated.
            # Non-loopback: set one of ageSecret, sopsSecret, or environmentFile.
            # ageSecret = "ai-memory-env";  # config.age.secrets.<name> (agenix)
            # sopsSecret = "ai-memory/env"; # config.sops.secrets.<name> (sops-nix)
          };
        }
      ];
    };
  };
}

Declarative non-secret config lives in services.ai-memory.settings (a small typed set for common keys, plus freeformType for the rest of config.toml). The module renders a generated TOML file and passes --config. Top-level bind, port, and enableWeb win over duplicate settings keys. Anything in settings (including llm_headers) lands in a world-readable Nix store path, so do not put API keys there.

Secrets such as AI_MEMORY_AUTH_TOKEN never go in settings or the world-readable Nix store. This includes llm_headers, which can carry API credentials; set AI_MEMORY_LLM_HEADERS in ageSecret, sopsSecret, or environmentFile instead. These three secret sources are mutually exclusive. Non-loopback binds require one; loopback may omit them and tolerates a missing environment file (systemd EnvironmentFile=-…). Put TLS in front of a LAN/WAN bind; see docs/https-via-proxy.md.

All options and defaults are in nix/nixos-module.nix. The module is entirely opt-in: nix build, nix run, nix develop, and the CLI are unchanged if you don't import it.

git is a runtime dependency. Hook capture and ai-memory doctor run it to read the repository a session works in. The module puts pkgs.git on the service's PATH. The package itself leaves the binary unwrapped, because a wrapper renames the running process and the live-process guard in reset, restore, reindex and uninstall --purge-data looks for a process named ai-memory. If you install the package without the module (nix profile install, home.packages), install git next to it.

Everyday use

Day to day, you mostly do not think about ai-memory. Hooks capture prompts, tool calls, and session boundaries; session end turns them into readable wiki pages; the next session starts with a handoff.

  • Ask "where did we leave off?" to continue from the pending handoff.
  • Import a local PDF, DOCX, PPTX, XLSX, Markdown file, or VTT/SRT transcript as attributed, sanitized memory with the optional ai-memory-importer document command.
  • Ask "have we discussed X?" or "search memory for Y" to query the wiki.
  • Narrow a large wiki before ranking with memory_query filters such as path_prefix: "procedures/", tag: "rust", kind: "decision", or tier: "procedural".
  • Inspect content-free per-workload LLM call, outcome, latency, and usage telemetry with ai-memory status --json; it diagnoses the configured provider but does not route different workloads to different models.
  • Ask "catch me up" for a prose digest of recent project activity, or run ai-memory recent (--global for every project) to list the newest pages.
  • Search Chinese, Japanese and Korean text without spaces: zero-LLM search matches unspaced Han, Kana and Hangul substrings.
  • Run ai-memory bootstrap once when adopting an existing project with months of history.
  • Start the server with --enable-web for a read-only browser view of the wiki, a link graph at /web/graph, a root/operator managed-workstream overview at /web/workstreams, and a JSON API under /api/v1. On a server with a bearer token and no user accounts (every fresh install), the browser asks for a username and password: any username, and the contents of <data_dir>/auth-tokens/default as the password.
  • Investigate Claude Code and Codex response-token usage in the project dashboard, and pick a Light, Dark or System theme. See Investigate token usage for capture coverage, cache accounting and the investigation flags. You can drill down from a project to an agent, its sessions and individual responses. The web agent inbox lets an operator queue requests for registered agents and read the received and sent history. Token filters run on the full authorized ledger, with native turn and tool context when reported. Pages show their sources, declared contradictions and recall explanations, and the feature guide shows the effective installation states in the web UI.
  • Back up host-side harness configuration with ai-memory backup-agents -o agent-assets.tar.gz; inspect a restore with ai-memory restore-agents -i agent-assets.tar.gz, then add --apply only after reviewing the active skills, plugins, instructions, and destinations.

Search modes, entities, feedback, briefings, and the web API are covered in docs/usage.md and docs/use-cases.md.

Interface language

Use ai-memory --language pt-BR status or set AI_MEMORY_LANGUAGE=pt-BR for Brazilian Portuguese. The web interface follows the browser's language and offers an independent language selector. See interface languages for configuration, translation boundaries and contributor instructions.

Teams and multiple machines

Run the server somewhere reachable, such as a homelab box or a LAN host, and point every machine and every teammate at it. Knowledge is shared per project; personal handoffs stay personal; every write is attributed and audited. Multi-user auth (passwords, API credentials) is built in.

Start with docs/users.md for accounts and ownership, and docs/deploy.md for the server itself. It includes measured capacity numbers and the one rule you must follow: one server per data directory, never two.

Two opt-in HTTP surfaces build on the same browser sign-in, and both are off by default. serve --enable-session-management lets signed-in users inspect sessions and purge the ones they own (docs/session-management.md). serve --enable-self-service-keys lets them issue and revoke their own aim_ API keys (docs/self-service-keys.md).

Security

The server binds to loopback only by default. A fresh ai-memory init also mints a root bearer token into the data dir, which the hooks, the CLI and the ai-memory mcp-bridge stdio bridge read from there; it is never written into a harness config. An install created before that default (and the Docker quick-start) runs without auth until ai-memory auth enable, and ai-memory status says so. From there, hardening is incremental: a bearer token for the LAN, per-user accounts, OIDC device auth for hooks, TLS via a reverse proxy. Capture is sanitized at a typed privacy boundary before anything is stored, and per-repository [capture] rules can exclude paths or invert to allowlist mode. A repository can also route its capture to a different server than the one the hooks were installed against. Human login beyond loopback requires an HTTPS posture by default. Operators who explicitly accept plaintext passwords, cookies, credentials, and memory traffic on a private LAN can opt in with serve --allow-insecure-human-auth; the server never enables that exception implicitly.

The full model is in docs/security.md, docs/users.md, and docs/https-via-proxy.md. For data-flow, identity/SSO, and offline-install questions specifically, see DATA_HANDLING.md, docs/sso.md, and docs/airgapped-install.md.

LLM providers

Optional. Everything works with zero LLM calls; adding a provider upgrades session summaries and enables semantic search. Anthropic, OpenAI (including OAuth), Codex CLI credential reuse, GitHub Copilot, Gemini, OpenCode (Go and Zen), the Cursor Agent CLI (cursor), and any OpenAI-compatible endpoint (Ollama, LM Studio, vLLM) are supported for consolidation; OpenAI, Voyage, Gemini, and keyless OpenAI-compatible endpoints for embeddings. Configuration lives in docs/llm-providers.md.

For optional synthesized query answers, operators can set [query_answer] max_context_tokens to limit admitted evidence while retaining all retrieval hits. Known newer corrections take priority, and whole snippets are preferred over sentence-bounded fragments. It is disabled by default. See the configuration reference for the conservative counting rule and omission receipt.

Architecture

One Rust binary runs an MCP/HTTP server and owns one data directory:

<data_dir>/
├── wiki/    # markdown source of truth, git-versioned
├── raw/     # immutable sanitized managed-workstream transcript segments
├── db/      # SQLite indexes, including FTS5, entities, and embeddings
├── models/  # reserved for local embedding models
└── logs/    # rolling tracing output

Hooks POST observations to the server. The server serializes writes through one SQLite writer, compiles session observations into markdown pages, and serves retrieval through FTS5, entity-match and graph-neighbor RRF, optional vector RRF, an observation-evidence stream that lifts a session's page when its captured turns match (on by default), bounded source-authority adjustment, and bounded raw-observation fallback for non-global searches.

See docs/ARCHITECTURE.md for the data-flow diagram, crate breakdown, schema notes, and invariants.

Docs

For users

File What it is
docs/testing-dashboard.md Dashboard behavior tests, real-browser CI and mutation probes that prove regression guards fail.
docs/cookbook.md Task-oriented cheat sheet. "I want to do X" → how: recall prior work, keep a project rule, import an existing knowledge base, get two agents/repos working together. Start here.
docs/install.md Installation cookbook. Every agent CLI, every alternative (curl, source build, no-docker, no-auth), and the server-on-a-different-machine walkthrough.
docs/usage.md Handoffs, proactive memory queries, slim routing snippet + managed Agent Skills, web UI, raw-wiki inspection, and the rules, memory and profile precedence.
docs/cross-project-profile.md The cross-project profile. Your usual choices delivered to every project as defaults: defaults per deployment, every setting, per-project opt-outs, multi-user opt-in and privacy, CLI.
docs/managed-workstreams.md Optional ai-memory run continuity across harnesses: auto harness selection, native resume, argument forwarding, ledger search, privacy, and recovery.
docs/agent-messaging.md Cross-project agent-to-agent messaging: a directed, claim-once inbox/queue plus the on-start "you have mail" notice.
docs/marker-file.md Default repository-path project naming plus .ai-memory.toml workspace/project routing for multi-client trees, mono-repos, worktrees, and work/personal separation, plus per-repository server profiles.
docs/auto-scope.md [auto_scope] modes for shared servers: the default per_actor isolation, session-aware per_session isolation, and the pre-v1.39 single slot.
docs/macos.md macOS install paths: menu bar app, native release tarball, source build, Docker wrapper, launchd, and current limitations.
docs/windows.md Windows install modes: full WSL2, native Windows with Docker Desktop, prebuilt native release zip, native source builds, and caveats.
docs/mcp-install.md Per-client MCP and lifecycle notes, handoff-injection limits, and community bridge guidance.
docs/programmatic-memory.md Use ai-memory from any tool: MCP write/query/handoff calls, scope rules and incremental reads.
docs/deploy.md Homelab deploy: bin/deploy, bearer-token auth, pointers to the TLS guide.
docs/users.md Multi-user attribution and human login. Four-rung bearer ladder, password sessions, ai-memory user / api-key walkthrough, brownfield migration.
docs/management-ui.md Optional server-rendered console: feature gates, user and session management, MCP keys, public deployment, and frontend checks.
docs/https-via-proxy.md HTTPS via a reverse proxy. When you need TLS and when you don't, with copy-paste Caddy / nginx / Cloudflare Tunnel templates and the "secure when you're not" failure modes.
docs/lifecycle-ops.md Read before purge / rename / merge / backup / restore / reset / reindex / restore-page. Safety matrix, lossless project-identity merge, per-project disk layout, retained-version recovery, and operator workflows.
docs/backup.md Backing up the wiki + data dir to a remote git repository: what to include, what to exclude, scheduled push pattern, restore, and security posture. Companion to docs/lifecycle-ops.md (which covers the on-box ai-memory backup snapshot).
docs/design-backup-agent-assets.md Host agent-asset backup/restore: supported paths, filtering, redaction limits, archive bounds, active-content warning, and rollback behavior.
docs/llm-providers.md Provider configuration for consolidation and embeddings.
docs/security.md The full security model.
docs/support-matrix.md The full agent/platform matrix with notes.
docs/use-cases.md Scenario walkthroughs.
DATA_HANDLING.md Data-flow reference for security/legal review. What's stored, what's local-only, the two opt-in external paths, and how deletion/retention work.
docs/sso.md Enterprise identity: the OIDC device-auth flow, its scope, and how to front the server with an OIDC-aware gateway.
docs/airgapped-install.md Offline/air-gapped install: self-contained build, checksum-verified release binaries, and offline local embedding models.
docs/upgrading-to-3.0.md Upgrading a 2.x install to 3.0: what changed, the removed token commands and their replacements, upgrade steps, and rollback.
docs/MIGRATION-2.0.md Upgrading an existing store to 2.0: the backup-gated automatic migration and how to restore.
docs/benchmarks/ Published retrieval-quality numbers with provenance, reproducible from the in-repo harness.
docs/okf.md The wiki is natively an Open Knowledge Format (OKF v0.2) bundle; design and field mapping.

For contributors

File What it is
docs/ARCHITECTURE.md Operational summary: data flow, crate layout, cross-cutting invariants, schema.
docs/design-decisions.md The full v1 spec.
docs/managed-harness-contributions.md Protocol and acceptance bar for adding managed resume, transcript import, and startup context delivery to another harness.
docs/companion-crates.md Optional companion projects: the importer, external lifecycle relay, team-wiki sync, the TypeScript client SDK and the desktop installer (unsigned preview).
docs/external-lifecycle.md External lifecycle producers: per-execution native capture suppression, preserved handoffs, batch ingestion and stable retry identity.
docs/auto-improvement-loop.md Auto-improvement design notes: scheduled review, auto-approval default, manual review opt-in, pending proposal storage, and curator work.

Dated design-*, research-*, issues-*, desktop/, and benchmarks/ files are evidence and design records, not current operating instructions. Their status or snapshot banner says whether work shipped, remains proposed, or has been superseded. Use the user guides and ARCHITECTURE.md for current behavior; the older records remain only when current design rationale links to them.

Community articles

Written by users; not maintained here, so check them against the version you run.

The built-in web UI also has Documentation at /web/docs and a Changelog at /web/docs/changelog. The feature activation guide covers prerequisites and verification. Agents can read the same bundled guides through authenticated /api/v1/docs JSON or each guide's Markdown link.

License

MIT. See LICENSE.

Acknowledgements

This codebase is being built collaboratively with Claude Code (Anthropic Claude Opus 4.7) following the plan documented in docs/design-decisions.md.

View on GitHub

Recent activity

commits and pull requests

Releases and announcements

154 total
  1. v3.4.5v3.4.5Nov 10, 20262.1K downloads

    ## Checksums (SHA256) ``` 897759e08968b146405d53e5417653f1b5d28ea4254baba1bb5b6d3a367411b4 ai-memory-3.4.5-1.aarch64.rpm 14755b246e52a8c5969c1cea094d08002d8fe9e85924dae744858930efb33a0b ai-memory-3.4.5-1.x86_64.rpm 28862a1b83331ca71af1e526313672df340aca4de9aab2ecb82ed755b3ce7126 ai-memory-claude-plugin.zip a1199c3a9602590d71dd15d5efb3cbd1ffa1ca3a20ae635b85b2a44f060c6788 ai-memory-hooks.tar.gz 5b8b9030c247b091ac2bacbf181f52f8fdba9d4ed47cdef23faab874d4c94d9f ai-memory-install-hooks 956439346e5f67a743c242f82424e1a29227db971158116c5a0fe3bc185aa41f ai-memory-linux-aarch64.tar.gz 43af583f2c1c22949cecc89ad99027a076bd2510d7ba3dabff04e735e03eab76 ai-memory-linux-x86_64.tar.gz 7b5fd2fc39dca4b5e7a098fe49b411d849c770f1ba125b85a562c08ad2cd3ad6 ai-memory-macos-aarch64.tar.gz 6b5e885f61491a0dda0b6989e8d89f6a546354a635c4044eb87742dd30d54471 ai-memory-macos-x86_64.tar.gz 2166ba0cdd2e65029bd2350fe256abb97c9dbb7a346d8f588b625ae7527acef3 ai-memory-windows-x86_64.zip 6a91c44ffa2e85d3b5a6ce26a4ccff0286b91d08d276d2bb4d47c346b036ee8b ai-memory-wrapper.cmd 5e405aa237a2399f13084f71ae89545cbca77683c8251b4c4572cb51aedc8de4 ai-memory-wrapper.ps1 982cfeb1515a062fdb348e4622d130682660d30a1ce104d8ff0a1

  2. v3.4.4v3.4.4Nov 8, 20263.9K downloads

    ## Checksums (SHA256) ``` 333928cbc642ad7e649260a1ec1731a8cc182fb5a4cb109cfd5cede5f9cda651 ai-memory-3.4.4-1.aarch64.rpm 3c4a2a546ff959aa89897223bfd830b12c6542e261b4ddf9825fa9a20a53a108 ai-memory-3.4.4-1.x86_64.rpm 5a3f1142b9c6c642d9fd4b7035ac46e5a6526a26b6da3c24649aa8470d58088c ai-memory-claude-plugin.zip 00877f637c01853c95db033e3f75944df96b04fa2586ce5738e0218884903f3f ai-memory-hooks.tar.gz 5b8b9030c247b091ac2bacbf181f52f8fdba9d4ed47cdef23faab874d4c94d9f ai-memory-install-hooks 034c290de7e78b1c969a02135e054bc7a661bb8654c77939123bf0a6b5aa58fb ai-memory-linux-aarch64.tar.gz 2d69626c3f2ca7498b43da7fe733162ac798bffa7d088319bde1808c5d62ab59 ai-memory-linux-x86_64.tar.gz 498f07cd5581516f2987fe65b9e266d6f5a30066ec99a2e91a897e18f8507e64 ai-memory-macos-aarch64.tar.gz 6ec4661e298434e3c321e0d6c42da97fad5b6b6b03237ee42633c34ca40d3893 ai-memory-macos-x86_64.tar.gz 75844776d9250fd00daa6dd8d5852868163569d3e767daa991bc6e36b2706cce ai-memory-windows-x86_64.zip 6a91c44ffa2e85d3b5a6ce26a4ccff0286b91d08d276d2bb4d47c346b036ee8b ai-memory-wrapper.cmd 5e405aa237a2399f13084f71ae89545cbca77683c8251b4c4572cb51aedc8de4 ai-memory-wrapper.ps1 982cfeb1515a062fdb348e4622d130682660d30a1ce104d8ff0a1

  3. v3.4.3v3.4.3Nov 6, 20263.4K downloads

    ## Checksums (SHA256) ``` f4d3b69b8223d86d9d5a7c0ae59726eb4cfcfe19cd991ddc2ec155b77bbc597c ai-memory-3.4.3-1.aarch64.rpm dc2cf367cf669371363e6169509509ffb9e38bbf9542755fbadd6c378247af65 ai-memory-3.4.3-1.x86_64.rpm b737bd87c01bd32fe50cdb0faf8a301e7a09cea6bc11295d0b250ff6a98b257e ai-memory-claude-plugin.zip 08c017103f5d1d703b4574379cd4d05613039a3a6d62210b7a89cd158fc574e3 ai-memory-hooks.tar.gz 5b8b9030c247b091ac2bacbf181f52f8fdba9d4ed47cdef23faab874d4c94d9f ai-memory-install-hooks a2ade0507fdbf9c2bac7c62ef9d848d2481990a8fcea83a7ff41c28656f79161 ai-memory-linux-aarch64.tar.gz 2292e1e12895b48962513fee05ce535fadce5a63c9b83b2b3d9cb35fb0a4223e ai-memory-linux-x86_64.tar.gz e34d2252954a9e28f651d6631e3428e4a47766233add72f2d1e8a3491d1838e3 ai-memory-macos-aarch64.tar.gz 94245b4618ec79c1b921c95e6a9a4553a034279d00e95ad8e1a531d9d1870721 ai-memory-macos-x86_64.tar.gz 58ad3dc08322dff21b881190d4b2de1a93195b0e33d61d5372a0c563c71eac91 ai-memory-windows-x86_64.zip 6a91c44ffa2e85d3b5a6ce26a4ccff0286b91d08d276d2bb4d47c346b036ee8b ai-memory-wrapper.cmd 5e405aa237a2399f13084f71ae89545cbca77683c8251b4c4572cb51aedc8de4 ai-memory-wrapper.ps1 c91a788f20456d066f6678ede33184172916bd53046de730b9656

  4. v3.4.2v3.4.2Nov 5, 20264K downloads

    ## Upgrade notes - **Projects split by a git remote that arrived after capture began (#1993).** 3.4.1's repair renamed the two projects but left the repository identity on the archived one, so capture and later launches could still route there. Upgrade the server, then run `ai-memory repair-split --project-id <session project> --from-project-id <empty remote project>` for any pair repaired with 3.4.1 or renamed by hand. Newly found splits are repaired from the `ai-memory run` prompt. - **OMP and Pi users (#1990):** regenerate the extension after upgrading (`ai-memory upgrade`, or `ai-memory install-hooks --agent omp --apply` / `--agent pi`) so ranged reads and `@`/`file://` paths of `ignore_paths` files are dropped. - **Restore no longer undoes a session purge (#1989).** Restoring a purged session's summary is now refused; git history and backups remain the recovery path. ## Notes - **ai-jail:** checked against ai-jail 2.15.0, the latest release. This release adds its `--map` / `--rw-map` folder mounts and documents that `--github` now also shares the `gh` token. - **Benchmarks carried forward:** nothing in v3.4.1..v3.4.2 touches retrieval. The store reader change is the #1989 r

  5. v3.4.1v3.4.1Nov 5, 20261.3K downloads

    ## Checksums (SHA256) ``` 9be365c6ed4b4166b8ab48c3f8212c22dcafb131d83eafd5a3fd6d949103620b ai-memory-3.4.1-1.aarch64.rpm 78dfc7b4469d0844e0bb152161628b80d718fec0728f62ab6d708054760f2fdb ai-memory-3.4.1-1.x86_64.rpm 04ac561b4c4fe8054a94fd80b8436f6f8490dd2b286893cfd79dd97e17342970 ai-memory-claude-plugin.zip 39e78b1f8ec21cd3281cfa9bd770d04ab844576652fc31bd07b54224b9cf03a5 ai-memory-hooks.tar.gz 5b8b9030c247b091ac2bacbf181f52f8fdba9d4ed47cdef23faab874d4c94d9f ai-memory-install-hooks 978dddc23968b51d328f44f3a6eac52df31539e23e3489aa1b68f748da134ea4 ai-memory-linux-aarch64.tar.gz 31ea9fa9d6d7cd02ce08514f0495b5861743304d4592d7a3c39df51bb836d775 ai-memory-linux-x86_64.tar.gz 2dec383e72860b26ab9c28150cbf6191e158c80a5fe7fe0356b24de2df4e58a2 ai-memory-macos-aarch64.tar.gz 50198069c23efcec1a91287e2255229239ebab25651c43017a565cddcf0a3a92 ai-memory-macos-x86_64.tar.gz 0b8006363d0d64ef149e565832f61a4b192f9cdc774785582ec55dca1ccc2972 ai-memory-windows-x86_64.zip 6a91c44ffa2e85d3b5a6ce26a4ccff0286b91d08d276d2bb4d47c346b036ee8b ai-memory-wrapper.cmd 5e405aa237a2399f13084f71ae89545cbca77683c8251b4c4572cb51aedc8de4 ai-memory-wrapper.ps1 c91a788f20456d066f6678ede33184172916bd53046de730b9656

Code frequency

additions and deletions
+160.6K-160.6KWeek of 2026-05-17: +44,136 linesWeek of 2026-05-17: -4,313 linesWeek of 2026-05-24: +44,491 linesWeek of 2026-05-24: -9,324 linesWeek of 2026-05-31: +16,269 linesWeek of 2026-05-31: -1,984 linesWeek of 2026-06-07: +5,816 linesWeek of 2026-06-07: -1,353 linesWeek of 2026-06-14: +19,483 linesWeek of 2026-06-14: -3,160 linesWeek of 2026-06-21: +13,145 linesWeek of 2026-06-21: -1,020 linesWeek of 2026-06-28: +7,751 linesWeek of 2026-06-28: -2,163 linesWeek of 2026-07-05: +7,221 linesWeek of 2026-07-05: -819 linesWeek of 2026-07-12: +13,769 linesWeek of 2026-07-12: -1,368 linesWeek of 2026-07-19: +28,985 linesWeek of 2026-07-19: -6,137 linesWeek of 2026-07-26: +43,341 linesWeek of 2026-07-26: -6,675 linesWeek of 2026-08-02: +13,156 linesWeek of 2026-08-02: -1,613 linesWeek of 2026-08-09: +7,127 linesWeek of 2026-08-09: -720 linesWeek of 2026-08-16: +12,647 linesWeek of 2026-08-16: -1,478 linesWeek of 2026-08-23: +9,298 linesWeek of 2026-08-23: -652 linesWeek of 2026-08-30: +73,105 linesWeek of 2026-08-30: -33,505 linesWeek of 2026-09-06: +15,797 linesWeek of 2026-09-06: -1,877 linesWeek of 2026-09-13: +20,375 linesWeek of 2026-09-13: -1,781 linesWeek of 2026-09-20: +69,051 linesWeek of 2026-09-20: -9,365 linesWeek of 2026-09-27: +60,277 linesWeek of 2026-09-27: -5,712 linesWeek of 2026-10-04: +82,790 linesWeek of 2026-10-04: -9,170 linesWeek of 2026-10-11: +160,636 linesWeek of 2026-10-11: -23,409 linesWeek of 2026-10-18: +66,216 linesWeek of 2026-10-18: -9,490 linesWeek of 2026-10-25: +53,447 linesWeek of 2026-10-25: -10,097 linesWeek of 2026-11-01: +50,879 linesWeek of 2026-11-01: -6,125 linesWeek of 2026-11-08: +8,156 linesWeek of 2026-11-08: -1,134 linesMay 17, 2026Nov 8, 2026
+947.4K lines added, -154.4K removed over the last year.

Commits per week

last 52 weeks
5560Week of 2025-11-16: 0 commitsWeek of 2025-11-23: 0 commitsWeek of 2025-11-30: 0 commitsWeek of 2025-12-07: 0 commitsWeek of 2025-12-14: 0 commitsWeek of 2025-12-21: 0 commitsWeek of 2025-12-28: 0 commitsWeek of 2026-01-04: 0 commitsWeek of 2026-01-11: 0 commitsWeek of 2026-01-18: 0 commitsWeek of 2026-01-25: 0 commitsWeek of 2026-02-01: 0 commitsWeek of 2026-02-08: 0 commitsWeek of 2026-02-15: 0 commitsWeek of 2026-02-22: 0 commitsWeek of 2026-03-01: 0 commitsWeek of 2026-03-08: 0 commitsWeek of 2026-03-15: 0 commitsWeek of 2026-03-22: 0 commitsWeek of 2026-03-29: 0 commitsWeek of 2026-04-05: 0 commitsWeek of 2026-04-12: 0 commitsWeek of 2026-04-19: 0 commitsWeek of 2026-04-26: 0 commitsWeek of 2026-05-03: 0 commitsWeek of 2026-05-10: 0 commitsWeek of 2026-05-17: 96 commitsWeek of 2026-05-24: 190 commitsWeek of 2026-05-31: 86 commitsWeek of 2026-06-07: 26 commitsWeek of 2026-06-14: 74 commitsWeek of 2026-06-21: 54 commitsWeek of 2026-06-28: 37 commitsWeek of 2026-07-05: 46 commitsWeek of 2026-07-12: 42 commitsWeek of 2026-07-19: 96 commitsWeek of 2026-07-26: 106 commitsWeek of 2026-08-02: 45 commitsWeek of 2026-08-09: 20 commitsWeek of 2026-08-16: 72 commitsWeek of 2026-08-23: 59 commitsWeek of 2026-08-30: 162 commitsWeek of 2026-09-06: 92 commitsWeek of 2026-09-13: 97 commitsWeek of 2026-09-20: 214 commitsWeek of 2026-09-27: 278 commitsWeek of 2026-10-04: 316 commitsWeek of 2026-10-11: 556 commitsWeek of 2026-10-18: 465 commitsWeek of 2026-10-25: 374 commitsWeek of 2026-11-01: 347 commitsWeek of 2026-11-08: 156 commitsNov 16, 2025Nov 8, 2026
4.1K commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 14 commitsSun 1:00 — 15 commitsSun 2:00 — 11 commitsSun 3:00 — 16 commitsSun 4:00 — 11 commitsSun 5:00 — 3 commitsSun 6:00 — 2 commitsSun 7:00 — 6 commitsSun 8:00 — 4 commitsSun 9:00 — 1 commitsSun 10:00 — 12 commitsSun 11:00 — 28 commitsSun 12:00 — 35 commitsSun 13:00 — 43 commitsSun 14:00 — 37 commitsSun 15:00 — 26 commitsSun 16:00 — 37 commitsSun 17:00 — 18 commitsSun 18:00 — 15 commitsSun 19:00 — 16 commitsSun 20:00 — 24 commitsSun 21:00 — 27 commitsSun 22:00 — 20 commitsSun 23:00 — 20 commitsMon 0:00 — 6 commitsMon 1:00 — 3 commitsMon 2:00 — 13 commitsMon 3:00 — 11 commitsMon 4:00 — 3 commitsMon 5:00 — 2 commitsMon 6:00 — 7 commitsMon 7:00 — 6 commitsMon 8:00 — 12 commitsMon 9:00 — 20 commitsMon 10:00 — 12 commitsMon 11:00 — 26 commitsMon 12:00 — 50 commitsMon 13:00 — 45 commitsMon 14:00 — 47 commitsMon 15:00 — 59 commitsMon 16:00 — 52 commitsMon 17:00 — 23 commitsMon 18:00 — 24 commitsMon 19:00 — 31 commitsMon 20:00 — 34 commitsMon 21:00 — 32 commitsMon 22:00 — 33 commitsMon 23:00 — 33 commitsTue 0:00 — 15 commitsTue 1:00 — 10 commitsTue 2:00 — 18 commitsTue 3:00 — 11 commitsTue 4:00 — 6 commitsTue 5:00 — 5 commitsTue 6:00 — 5 commitsTue 7:00 — 23 commitsTue 8:00 — 4 commitsTue 9:00 — 19 commitsTue 10:00 — 19 commitsTue 11:00 — 42 commitsTue 12:00 — 58 commitsTue 13:00 — 69 commitsTue 14:00 — 61 commitsTue 15:00 — 56 commitsTue 16:00 — 35 commitsTue 17:00 — 23 commitsTue 18:00 — 22 commitsTue 19:00 — 14 commitsTue 20:00 — 16 commitsTue 21:00 — 22 commitsTue 22:00 — 14 commitsTue 23:00 — 39 commitsWed 0:00 — 17 commitsWed 1:00 — 24 commitsWed 2:00 — 24 commitsWed 3:00 — 0 commitsWed 4:00 — 1 commitsWed 5:00 — 4 commitsWed 6:00 — 1 commitsWed 7:00 — 4 commitsWed 8:00 — 3 commitsWed 9:00 — 10 commitsWed 10:00 — 27 commitsWed 11:00 — 25 commitsWed 12:00 — 30 commitsWed 13:00 — 43 commitsWed 14:00 — 50 commitsWed 15:00 — 40 commitsWed 16:00 — 29 commitsWed 17:00 — 36 commitsWed 18:00 — 53 commitsWed 19:00 — 77 commitsWed 20:00 — 47 commitsWed 21:00 — 34 commitsWed 22:00 — 42 commitsWed 23:00 — 19 commitsThu 0:00 — 26 commitsThu 1:00 — 25 commitsThu 2:00 — 38 commitsThu 3:00 — 5 commitsThu 4:00 — 17 commitsThu 5:00 — 7 commitsThu 6:00 — 0 commitsThu 7:00 — 5 commitsThu 8:00 — 3 commitsThu 9:00 — 28 commitsThu 10:00 — 20 commitsThu 11:00 — 55 commitsThu 12:00 — 32 commitsThu 13:00 — 51 commitsThu 14:00 — 31 commitsThu 15:00 — 42 commitsThu 16:00 — 25 commitsThu 17:00 — 28 commitsThu 18:00 — 40 commitsThu 19:00 — 35 commitsThu 20:00 — 43 commitsThu 21:00 — 37 commitsThu 22:00 — 10 commitsThu 23:00 — 41 commitsFri 0:00 — 28 commitsFri 1:00 — 17 commitsFri 2:00 — 9 commitsFri 3:00 — 1 commitsFri 4:00 — 1 commitsFri 5:00 — 5 commitsFri 6:00 — 4 commitsFri 7:00 — 5 commitsFri 8:00 — 13 commitsFri 9:00 — 8 commitsFri 10:00 — 21 commitsFri 11:00 — 52 commitsFri 12:00 — 64 commitsFri 13:00 — 49 commitsFri 14:00 — 49 commitsFri 15:00 — 36 commitsFri 16:00 — 27 commitsFri 17:00 — 21 commitsFri 18:00 — 25 commitsFri 19:00 — 57 commitsFri 20:00 — 45 commitsFri 21:00 — 20 commitsFri 22:00 — 31 commitsFri 23:00 — 33 commitsSat 0:00 — 27 commitsSat 1:00 — 22 commitsSat 2:00 — 4 commitsSat 3:00 — 1 commitsSat 4:00 — 7 commitsSat 5:00 — 7 commitsSat 6:00 — 8 commitsSat 7:00 — 0 commitsSat 8:00 — 6 commitsSat 9:00 — 14 commitsSat 10:00 — 42 commitsSat 11:00 — 48 commitsSat 12:00 — 51 commitsSat 13:00 — 45 commitsSat 14:00 — 32 commitsSat 15:00 — 63 commitsSat 16:00 — 49 commitsSat 17:00 — 27 commitsSat 18:00 — 17 commitsSat 19:00 — 26 commitsSat 20:00 — 23 commitsSat 21:00 — 24 commitsSat 22:00 — 17 commitsSat 23:00 — 32 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.

Who is committing

last 52 weeks
Maintainer commits3,622 (61%)
Community commits2,317 (39%)

5,939 commits in total over the last year.

DateListRankStars gained
Oct 28, 2026weekly#7+2,838
Oct 27, 2026weekly#7+2,838
Oct 26, 2026weekly#7+3,254
Oct 25, 2026weekly#11+3,541
Oct 24, 2026weekly#7+3,449
Oct 23, 2026weekly#8+3,322
Oct 22, 2026weekly#8+2,833
Oct 21, 2026daily#1+666
Oct 20, 2026daily#1+666
Oct 19, 2026daily#1+666
Oct 18, 2026daily#4+178
Sep 29, 2026weekly#11+1,224
Sep 28, 2026weekly#11+1,224
Sep 25, 2026weekly#13+1,208
Sep 24, 2026weekly#13+1,208
  • ultraworkers/claw-code

    An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

    194.8K stars · Rust

  • farion1231/cc-switch

    A cross-platform desktop All-in-One assistant for Claude Code, Codex, OpenCode,DeepSeek Harness and more. Only official website: ccswitch.io

    153.9K stars · Rust

  • openai/codex

    Lightweight coding agent that runs in your terminal

    135K stars · Rust

  • rust-lang/rust

    Empowering everyone to build reliable and efficient software.

    121.8K stars · Rust

  • denoland/deno

    A modern runtime for JavaScript and TypeScript.

    108.9K stars · Rust

  • pbakaus/impeccable

    The design vocabulary for your coding agent. Steer with polish and bolder, review with critique and audit, catch AI slop before it ships.

    108.7K stars · Rust