atuin-memory
Check, store, and retrieve project memories from atuin kv. Use when starting work on a project, recalling previous context, storing plans or specs, or when the user mentions memory, atuin, or project context.
Best use case
atuin-memory is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Check, store, and retrieve project memories from atuin kv. Use when starting work on a project, recalling previous context, storing plans or specs, or when the user mentions memory, atuin, or project context.
Teams using atuin-memory should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/atuin-memory/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How atuin-memory Compares
| Feature / Agent | atuin-memory | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Check, store, and retrieve project memories from atuin kv. Use when starting work on a project, recalling previous context, storing plans or specs, or when the user mentions memory, atuin, or project context.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Project Memory with Atuin
Store and retrieve project context using atuin kv to persist across sessions.
## Project Detection
Reuse these variables in all commands:
```bash
PROJECT=$(basename "$(git rev-parse --show-toplevel 2>/dev/null)" 2>/dev/null || basename "$PWD")
BRANCH=$(git branch --show-current 2>/dev/null)
BRANCH=${BRANCH:-main}
```
## Before Starting Work
```bash
echo "=== $PROJECT ($BRANCH) ==="
# Discover what memories exist for this project
atuin kv list --namespace "project-metadata" | grep -F "$PROJECT-" || echo "(no memories found)"
```
Then retrieve relevant memories:
```bash
# Empty output means memory doesn't exist
atuin kv get --namespace "project-metadata" "$PROJECT-$BRANCH-plan"
atuin kv get --namespace "project-metadata" "$PROJECT-$BRANCH-spec"
atuin kv get --namespace "project-metadata" "$PROJECT-$BRANCH-todo"
```
## Acting on Retrieved Memories
<memory-actions>
<on-retrieval>
- Check if stored plan/spec/todo still matches git state and current goals
- Briefly summarize what you found so user can correct misunderstandings
- Raise blockers, gaps, or open questions before proceeding—don't assume, ask
- Pick up from first incomplete todo item; if none exist, start fresh
</on-retrieval>
<on-completion>
- Update stored state after completing work so next session can resume cleanly
</on-completion>
</memory-actions>
## Storing Memories
For multi-line content, write to a temp file first to avoid shell escaping issues:
```bash
# 1. Write content to temp file
# 2. Store from temp file
atuin kv set --namespace "project-metadata" --key "$PROJECT-$BRANCH-plan" "$(cat /tmp/plan.md)"
# 3. Verify storage succeeded
atuin kv get --namespace "project-metadata" "$PROJECT-$BRANCH-plan" | head -5
```
For short single-line values, store directly:
```bash
atuin kv set --namespace "project-metadata" --key "$PROJECT-$BRANCH-status" "in-progress"
```
## Key Naming
| Key Pattern | Purpose |
|-------------|---------|
| `{project}-{branch}-plan` | Implementation plans |
| `{project}-{branch}-spec` | Specifications/designs |
| `{project}-{branch}-todo` | Task state |
| `{project}-{branch}-session-$(date +%Y-%m-%d)` | Session summaries (use current date) |
## Deleting Memories
```bash
# Delete a specific key
atuin kv delete --namespace "project-metadata" "$PROJECT-$BRANCH-plan"
# Verify deletion (should return empty)
atuin kv get --namespace "project-metadata" "$PROJECT-$BRANCH-plan"
```
## Quick Reference
**Argument syntax is inconsistent across subcommands — pay attention to positional vs flag arguments:**
| Operation | Command | Notes |
|-----------|---------|-------|
| List all | `atuin kv list --namespace "project-metadata"` | |
| Get | `atuin kv get --namespace "project-metadata" "key"` | KEY is **positional** |
| Set | `atuin kv set --namespace "project-metadata" --key "key" "value"` | KEY is **`--key` flag**, VALUE is **positional** |
| Delete | `atuin kv delete --namespace "project-metadata" "key"` | KEY is **positional** (not `--key`) |
<constraints>
- Store artifacts in atuin, not local markdown files
- Use /tmp for any temporary files needed during storage
- Never commit metadata files to git
</constraints>Related Skills
ac-memory-manager
Manage persistent memory for autonomous coding. Use when storing/retrieving knowledge, managing Graphiti integration, persisting learnings, or accessing episodic memory.
moai-foundation-memory
Persistent memory across sessions using MCP Memory Server for user preferences, project context, and learned patterns
memory
Save and retrieve experiment context using the local Obsidian vault. Use to preserve context across sessions and reduce context window usage.
memory-safety-patterns
Implement memory-safe programming with RAII, ownership, smart pointers, and resource management across Rust, C++, and C. Use when writing safe systems code, managing resources, or preventing memory...
helix-memory
Long-term memory system for Claude Code using HelixDB graph-vector database. Store and retrieve facts, preferences, context, and relationships across sessions using semantic search, reasoning chains, and time-window filtering.
agentMemory
A hybrid memory system that provides persistent, searchable knowledge management for AI agents.
agent-memory-systems
Memory is the cornerstone of intelligent agents. Without it, every interaction starts from zero. This skill covers the architecture of agent memory: short-term (context window), long-term (vector stores), and the cognitive architectures that organize them. Key insight: Memory isn't just storage - it's retrieval. A million stored facts mean nothing if you can't find the right one. Chunking, embedding, and retrieval strategies determine whether your agent remembers or forgets. The field is fragm
agent-memory-skills
Self-improving agent architecture using ChromaDB for continuous learning, self-evaluation, and improvement storage. Agents maintain separate memory collections for learned patterns, performance metrics, and self-assessments without modifying their static .md configuration.
agent-memory-mcp
A hybrid memory system that provides persistent, searchable knowledge management for AI agents (Architecture, Patterns, Decisions).
agent-memory
Long-term memory store for AI agents - save, search, and manage persistent memories across sessions. Load this skill for complete command reference.
memorylane
Zero-config persistent memory for Claude with automatic cost savings. Use when you need to remember project context, reduce API token costs, track learned patterns, manage memories across sessions, or curate/clean up memories. Automatically compresses context 6x and saves 84% on API costs. Keywords: memory, remember, recall, context, cost savings, reduce tokens, learn, patterns, insights, curate, clean up memories, review memories.
ai-runtime-memory
AI Runtime分层记忆系统,支持SQL风格的事件查询、时间线管理,以及记忆的智能固化和检索,用于项目历史追踪和经验传承