Daily-Nerd/daimon — Daimon: Memory for AI Coding Agents
Transcript
QuickFacts
Welcome! Today we're exploring Daimon, a memory system for AI coding agents. Let's see how it helps agents remember where they left off.
PlainEnglish
Here's the core idea: when your AI session ends with an open question or a decision made, Daimon captures that state. Next time you start, it shows you what was left hanging so the agent resumes from where you actually were, not where it guesses you were.
PlainEnglish
Let's walk through the flow. Your session ends with open loops. Daimon writes a checkpoint capturing decisions and questions. Time passes — you might merge a pull request manually outside the tool. When the next session starts, Daimon shows a briefing reminding you what was unresolved. The agent resumes with context, not from scratch.
Architecture
Under the hood, Daimon is host-agnostic. Native hooks for Claude Code, Windsurf, and others fire on session events. These hooks shell out to the daimon command-line tool, which handles everything. The serializer extracts cognitive state via an LLM call. The store writes checkpoints to flat files. The briefing renderer reads those files deterministically. And the recall index lets you search past sessions. It's a clean pipeline — write on session end, read on session start.
Architecture
Let's trace what happens when a session ends. The host fires a SessionEnd event. The hook reads it and spawns a detached daimon serialize process — it's backgrounded so you never wait for the extraction. The CLI reads the transcript, passes it to the serializer, which calls the LLM with a prompt designed to extract open questions, decisions, beliefs, and uncertainties. The LLM returns structured JSON. The serializer stamps IDs and timestamps, then hands it to the store for an atomic write. The checkpoint is saved as a flat JSON file, and a project pointer is updated so the next session knows where to look.
Architecture
Now the flip side: session start. The host fires a SessionStart event. The hook shells out to daimon brief. The CLI reads the latest checkpoint for this project. The store loads it and also folds in the events log — that's where resolved items are tracked. The briefing renderer withholds anything marked resolved, builds sections by priority, and renders plain text. The CLI prints the briefing to stdout. The hook captures that output and returns it to the host, which injects it as context before the agent's first turn. The agent sees the reminder immediately.
PlainEnglish
Daimon marks every item with a trust class. Verbatim items are pinned to an exact quote from the transcript — immutable, never paraphrased, like a direct quote in a news article. Inferred items are the agent's interpretation or summary — allowed to evolve, synthesized rather than quoted. This distinction is load-bearing: you always know which memories are quotes and which are guesses.
Architecture
Carry-forward is how Daimon keeps unresolved items alive across sessions. It's deterministic — no LLM, just pure code. Here's the pipeline: load the previous checkpoint's unresolved items, merge them into the new checkpoint, deduplicate by term overlap so two wordings of the same question don't become two items, then expire old low-importance items by effective weight. That's importance times an exponential decay over time. The result: unresolved questions carry forward verbatim, but the list doesn't grow unbounded.
Architecture
Let's talk about recall. When you type a new prompt, Daimon can proactively suggest past sessions where you worked on the same topic. It uses a local SQLite FTS5 index — full-text search over all your checkpoints. The index is a derived cache, safe to delete anytime. Daimon rebuilds it from the flat files whenever the fingerprint changes. Recall ranks matches by relevance times effective weight. Superseded items are ranked down but never hidden — an overturned decision is still evidence. It's silent by default — it never floods you with irrelevant matches, and it won't suggest what the session-start briefing already covered.
QuickFacts
What's it built on? Python, stdlib-only at runtime. hatchling for the build, published to PyPI as daimon-briefing. Rich is an optional dependency for terminal UI — it degrades to plain text when absent. SQLite FTS5 for the recall index. LiteLLM is the default LLM backend, with a fallback to the claude CLI if you have it on your path. Vitni handles signed receipts if you opt in. The dev tooling is pytest for tests, ruff for linting, mypy for type checking. It's a tight, focused stack.
Community
Let's check the repo's pulse. This is an active project — commits today, forty-two in the last thirty days, over four hundred in the past year. It's maintained by a tight-knit team of three to five contributors. There are eight branches and twenty-two tags, indicating structured release management. If you're looking for a memory system for your agent workflow, this is a live, maintained project worth exploring.
How this was made
Lenzon read Daily-Nerd/daimon and generated this walkthrough automatically. The narration above is the transcript of what it says.
Explain a pull request from your own repo
Point Lenzon at a repo or a pull request and get a narrated walkthrough like this one.
Try it