Eidetic Engine CLI
The ee CLI gives agents durable local memory: rules, decisions and anti-patterns with scores and provenance
- 76 ★ on the repository
- Last commit
Extended access
Why this level
- The installer downloads and runs a release script, so read it before running
- Memory stores decisions and snippets of past sessions that may hold secrets
Install
- Works in
Manual install
bash install.sh --easy-mode --verifyThe `install.sh` script from the v0.18.0 release with `EE_VERSION=v0.18.0`. It checks the SHA-256 and puts `ee` into `~/.local/bin`.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The installer downloads and runs a release script, so read it before running
- Memory stores decisions and snippets of past sessions that may hold secrets
This is third-party code. Review the repository files before installing.
What it does
Eidetic Engine is the `ee` CLI in Rust, a memory layer for coding agents. The agent keeps its own loop while `ee` stores facts, decisions, procedural rules, anti-patterns, session evidence and outcomes, indexes them with lexical and semantic search, links them with a graph and emits compact context packs with provenance. `ee pack "prepare release for this project" --workspace . --max-tokens 4000 --format markdown` returns matching release rules, verification commands and warnings. Search is hybrid: BM25 plus local vectors through Frankensearch, with the `potion-multilingual-128M` model by default. Every returned item shows component scores, freshness, confidence and supporting sources. Procedural rules lose confidence over time, and harmful feedback demotes faster than helpful feedback promotes. `ee preflight check --cmd "<command>"` looks up memory risks for a risky command and blocks nothing. The agent loop is built from `ee resume`, `ee orient`, `ee pack`, `ee recall`, `ee search`, `ee remember` and `ee outcome`. Every machine command prints versioned JSON with a `schema` field. The CASS import module mines excerpts from Claude Code, Codex, Cursor, Gemini and ChatGPT sessions. No cloud, no paid LLM API and no background process are needed.
Who it is for. Developers and teams whose agents work in the same repos and rediscover project rules in every session.
Good fit when
- An agent keeps stepping on branch and release traps a previous session already hit
- Before a risky command you want a memory warning from `ee preflight check`
- Recurring lessons need to be mined from old Claude Code and Codex sessions through CASS import
- Task context must fit a token budget: `--max-tokens 4000`
- Memory results need grading: `ee outcome` raises or lowers a rule weight
Not a fit when
- You need a simple rules note: an `AGENTS.md` file is enough
- You want an always-on memory server with MCP: `ee` is a one-shot command with no daemon
- You cannot download the embedding model once on first run
Example request
Build a context pack for the task "prepare a release", add warnings for risky commands and remember the finding as a rule.Limitations
The installer downloads a release and puts `ee` into `~/.local/bin`, repairs `PATH`, installs shell completions and checks the SHA-256 of the binary. The default build downloads the embedding model once, and without it a deterministic fallback remains. Personalized PageRank is wired but not yet available in production. The license is MIT with a rider for OpenAI and Anthropic. The project changes fast, the README version is 0.18.0, and the repo itself weighs hundreds of megabytes because of task logs and reports.
How to disable. Delete the `~/.local/bin/ee` binary and the workspace data directory that `ee` created next to the project. Remove the shell completions from your profile.
FAQ
How do I install ee?
Download `install.sh` from the v0.18.0 release, set `EE_VERSION=v0.18.0` and run `bash install.sh --easy-mode --verify`. The script checks the checksum and puts `ee` into `~/.local/bin`.
Does it need an API key or a cloud?
No. Embeddings run locally through Frankensearch and no paid language-model API is required.
What does the agent loop look like?
`ee resume`, `ee orient`, `ee pack`, then `ee search` and `ee recall` during the task, `ee remember` for new lessons and `ee outcome` to grade usefulness.
Does ee block dangerous commands?
No. `ee preflight check --cmd` only looks up memory warnings and returns them to the agent, and the decision stays with it.
Where does ee take past experience from?
From items you add with `ee remember` and from importing the `cass` corpus of Claude Code, Codex, Cursor, Gemini and ChatGPT sessions.
Discussion
No questions or reviews yet.
Related
CLI toolsThe lwc CLI in Rust: persistent agent memory as a source-grounded wiki on SQLite, for Claude Code, Codex, Cursor and more
A CLI for AI agents: tasks with acceptance criteria, evidence of done, cross-session memory and docs without duplicates
A Go CLI that configures the AI coding agents you already use: it gives them shared memory, a workflow and deterministic steps without replacing the agents them
A CLI that reads local Claude Code, Codex and Hermes sessions, finds repeated failures and stages fixes for manual review
Local memory for AI agents in plain Markdown files: it keeps only what you approve and serves it through MCP
Local memory for agents in a single Rust binary: stores, searches by meaning and keyword, works with no network and no keys
README in short
Covers the purpose of agent memory, a script install with signature checking, search and graph capabilities, the agent command loop and the CASS integration.