Every time you tell an agent "always use Bun, not Jest" or "we follow conventional commits," that's a fact worth keeping. Memories are how kill9 does that — persistent knowledge that agents carry from session to session.
Open the Memories panel from the command palette (Cmd/Ctrl+K) by typing "Memories."
Overview
Without memories, every session starts from zero. Agents forget what they learned yesterday, ask the same questions, and make the same mistakes. Memories fix this. They store facts about your project, your preferences, and your decisions so agents don't need to be told twice.
Agents save memories automatically when they learn something important. You can also save memories manually when you want to make sure something sticks.
What you can do
With memories, you can:
- Set project conventions so every agent follows them without being told
- Record architectural decisions so agents reference them in future sessions
- Save tool preferences, library versions, and environment quirks
- Review and clean up outdated memories to keep agent quality high
- See statistics on which memories agents reference most
How it works
What memories are
A memory is a piece of persistent knowledge stored in a local database. When an agent starts a session, relevant memories are injected into its prompt automatically. The agent doesn't need to search for them or be reminded — they're just there.
This is what makes kill9 agents feel like team members who've been on the project for weeks, not chatbots meeting you for the first time.
Memory types
Memories are organized into five types:
- User preferences — your personal settings: editor preferences, testing frameworks, communication style. These travel with your user account across projects.
- Feedback — guidance on how agents should approach work: "always write failing tests first," "prefer simple solutions over clever ones." These shape agent behavior.
- Project context — facts about the current project: architecture patterns, dependency versions, deployment quirks. These are scoped to the project directory.
- References — pointers to external resources: wiki URLs, API endpoints, design system links. Agents can look these up when relevant.
- Conscience — project-specific principles and constraints: "never modify the database schema without an approved migration," "all public APIs must have rate limiting." These act as guardrails.
How agents use memories
When an agent starts a session, kill9 loads relevant memories based on the project, the agent's role, and the current context. The agent sees these memories as part of its instructions — it doesn't need to explicitly search or recall them.
If you've saved a memory that says "use Zod for all validation schemas," then when kdev writes a new endpoint, it uses Zod without being told. If you've saved a conscience memory that says "never commit directly to main," the agent uses a feature branch automatically.
The Memories panel
The Memories panel has two tabs:
Memory library — Browse all memories organized by type. Search by keyword, filter by category, and expand any memory to see its full content and when it was last referenced. Delete memories that are wrong, update ones that are partially correct, and add new ones manually.
Stats — See how your memory library is being used. Which memories agents reference most, how many memories you have by type, and usage trends over time.
Stale signals
Memories can become outdated. A memory about using React 17 isn't helpful after you've upgraded to React 19. A coding convention from six months ago might have been replaced by a new team standard.
The Memories panel shows a stale signal on memories that haven't been referenced recently or that conflict with newer information. These are visual flags — they don't delete anything automatically, but they tell you it's time to review.
Check stale memories periodically. Delete wrong ones, update partially correct ones, and keep the library clean. The quality of your memory library directly affects how well agents work.
Memory review
Memory review scans all your memories and produces a cleanup report. It classifies each memory as keep, update, archive, or delete based on how recently it was used and whether it conflicts with newer entries.
Run a memory review when your library gets large or when agents seem to be following outdated conventions.
Auto-extraction from conversations
Agents save memories automatically during sessions. When an agent learns something important — a decision you made, a convention you stated, a constraint you described — it saves it as a memory. You don't need to do anything.
This extraction happens through built-in hooks that run at the end of each agent turn. The agent identifies facts worth retaining and writes them to the memory store.
Manually saving memories
You can also save memories yourself. In the Memories panel, click the add button and fill in the type, name, and content. Be specific — "use Vitest for unit tests, not Jest" is better than "use Vitest."
You can also save memories from a chat by telling the agent: "Remember that we use pnpm, not npm." The agent saves it immediately.
Tips
- Review your memory library every few weeks. Outdated memories are worse than no memories — they make agents do the wrong thing confidently.
- Save project-specific conventions as "project context," not "user preferences." That way they're scoped correctly if you work on multiple projects.
- Use the "conscience" type for hard rules agents should never violate. These carry more weight in agent prompts than regular facts.
- Don't save everything. A memory should be something an agent needs to know across sessions. One-off facts don't need to be memories.
- If an agent keeps doing something wrong despite being told, check whether a conflicting memory exists. The agent might be following an old memory instead of your new instruction.
Related
- Chronicles — the project timeline (events, not facts)
- Work — where agents use memories in practice
- Core concepts — how memory fits into the system
- Hooks — how auto-extraction works under the hood