Elite Longterm Memory

Name: Elite Longterm Memory
Author: nextfrontierbuilds

nextfrontierbuilds/elite-longterm-memory

2.3k installs
16 repo stars
Updated January 30, 2026
nextfrontierbuilds/elite-longterm-memory

elite-longterm-memory combines WAL session state, LanceDB, git-notes, MEMORY.md, SuperMemory, and Mem0 for agent persistence.

About

The elite-longterm-memory skill unifies six memory approaches into a layered architecture for AI agents that must survive compaction and session restarts. Hot RAM uses SESSION-STATE.md with write-ahead log discipline before responding. Warm store uses LanceDB vectors via memory-lancedb plugin with auto-recall and tagged memory_store commands requiring OPENAI_API_KEY. Cold store uses git-notes-memory python scripts for silent structured decisions on branches. Curated archive keeps MEMORY.md and dated daily logs under memory/ for human-readable long-term recall. Optional Layer five syncs via SuperMemory API and layer six adds Mem0 automatic fact extraction for token reduction. Setup steps create SESSION-STATE.md, enable clawdbot.json memorySearch and plugin config, initialize git-notes sync, and verify MEMORY.md structure. Agent instructions cover session start reads, silent git-notes on decisions, and preference capture during conversation. Requires memory-lancedb plugin and documents env keys for OpenAI, SuperMemory, and Mem0 when enabled.

Six layers: SESSION-STATE, LanceDB vectors, git-notes, MEMORY.md, SuperMemory, Mem0.
Write to SESSION-STATE.md before responding on concrete user details.
LanceDB auto-recall with tagged memory_store and importance thresholds.
Git-notes remember decisions silently without announcing storage.
Optional SuperMemory cloud backup and Mem0 auto fact extraction.

Elite Longterm Memory by the numbers

2,339 all-time installs (skills.sh)
+5 installs in the week ending Aug 4, 2026 (Skillselion tracking)
Ranked #422 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
Security screen: MEDIUM risk (skills.sh audit)
Data as of Aug 4, 2026 (Skillselion catalog sync)

At a glance

elite-longterm-memory capabilities & compatibility

Capabilities: multi layer hot warm cold memory architecture · lancedb plugin configuration and memory_store re · git notes structured decision storage · memory.md curated archive and daily logs · optional cloud backup and mem0 auto extraction
Use cases: memory · orchestration
Pricing: Bring your own API key

From the docs

What elite-longterm-memory says it does

Never lose context. Never forget decisions. Never repeat mistakes.

SKILL.md

Write BEFORE responding. Triggered by user input, not agent memory.

SKILL.md

Store a decision (SILENT - never announce)

SKILL.md

npx skills add https://github.com/nextfrontierbuilds/elite-longterm-memory --skill elite-longterm-memory

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/nextfrontierbuilds/elite-longterm-memory.svg)](https://skillselion.com/skills/nextfrontierbuilds/elite-longterm-memory)

Installs	2.3k
repo stars	★ 16
Security audit	3 / 3 scanners passed
Last updated	January 30, 2026
Repository	nextfrontierbuilds/elite-longterm-memory ↗

How do I prevent agents from losing context, decisions, and preferences across compaction and restarts?

Combine WAL session state, LanceDB vectors, git-notes graph, MEMORY.md archive, optional SuperMemory cloud, and Mem0 auto-extraction for agent memory.

Who is it for?

Clawdbot or Moltbot agents needing durable multi-layer memory beyond a single chat window.

Skip if: Skip for simple one-shot tasks or teams without OpenAI key for vector recall.

When should I use this skill?

User asks about SESSION-STATE.md, LanceDB memory, git-notes remember, or elite agent memory setup.

What you get

Configured hot, warm, and cold memory layers with optional cloud backup and auto-extracted facts.

vector memory index
git-notes knowledge graph
WAL context log

By the numbers

Version 1.2.0
Combines 6 proven memory approaches

Files

SKILL.mdMarkdownGitHub ↗

Elite Longterm Memory 🧠

The ultimate memory system for AI agents. Combines 6 proven approaches into one bulletproof architecture.

Never lose context. Never forget decisions. Never repeat mistakes.

Architecture Overview

┌─────────────────────────────────────────────────────────────────┐
│                    ELITE LONGTERM MEMORY                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐             │
│  │   HOT RAM   │  │  WARM STORE │  │  COLD STORE │             │
│  │             │  │             │  │             │             │
│  │ SESSION-    │  │  LanceDB    │  │  Git-Notes  │             │
│  │ STATE.md    │  │  Vectors    │  │  Knowledge  │             │
│  │             │  │             │  │  Graph      │             │
│  │ (survives   │  │ (semantic   │  │ (permanent  │             │
│  │  compaction)│  │  search)    │  │  decisions) │             │
│  └─────────────┘  └─────────────┘  └─────────────┘             │
│         │                │                │                     │
│         └────────────────┼────────────────┘                     │
│                          ▼                                      │
│                  ┌─────────────┐                                │
│                  │  MEMORY.md  │  ← Curated long-term           │
│                  │  + daily/   │    (human-readable)            │
│                  └─────────────┘                                │
│                          │                                      │
│                          ▼                                      │
│                  ┌─────────────┐                                │
│                  │ SuperMemory │  ← Cloud backup (optional)     │
│                  │    API      │                                │
│                  └─────────────┘                                │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

The 5 Memory Layers

Layer 1: HOT RAM (SESSION-STATE.md)

From: bulletproof-memory

Active working memory that survives compaction. Write-Ahead Log protocol.

# SESSION-STATE.md — Active Working Memory

## Current Task
[What we're working on RIGHT NOW]

## Key Context
- User preference: ...
- Decision made: ...
- Blocker: ...

## Pending Actions
- [ ] ...

Rule: Write BEFORE responding. Triggered by user input, not agent memory.

Layer 2: WARM STORE (LanceDB Vectors)

From: lancedb-memory

Semantic search across all memories. Auto-recall injects relevant context.

# Auto-recall (happens automatically)
memory_recall query="project status" limit=5

# Manual store
memory_store text="User prefers dark mode" category="preference" importance=0.9

Layer 3: COLD STORE (Git-Notes Knowledge Graph)

From: git-notes-memory

Structured decisions, learnings, and context. Branch-aware.

# Store a decision (SILENT - never announce)
python3 memory.py -p $DIR remember '{"type":"decision","content":"Use React for frontend"}' -t tech -i h

# Retrieve context
python3 memory.py -p $DIR get "frontend"

Layer 4: CURATED ARCHIVE (MEMORY.md + daily/)

From: Clawdbot native

Human-readable long-term memory. Daily logs + distilled wisdom.

workspace/
├── MEMORY.md              # Curated long-term (the good stuff)
└── memory/
    ├── 2026-01-30.md      # Daily log
    ├── 2026-01-29.md
    └── topics/            # Topic-specific files

Layer 5: CLOUD BACKUP (SuperMemory) — Optional

From: supermemory

Cross-device sync. Chat with your knowledge base.

export SUPERMEMORY_API_KEY="your-key"
supermemory add "Important context"
supermemory search "what did we decide about..."

Layer 6: AUTO-EXTRACTION (Mem0) — Recommended

NEW: Automatic fact extraction

Mem0 automatically extracts facts from conversations. 80% token reduction.

npm install mem0ai
export MEM0_API_KEY="your-key"

const { MemoryClient } = require('mem0ai');
const client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY });

// Conversations auto-extract facts
await client.add(messages, { user_id: "user123" });

// Retrieve relevant memories
const memories = await client.search(query, { user_id: "user123" });

Benefits:

Auto-extracts preferences, decisions, facts
Deduplicates and updates existing memories
80% reduction in tokens vs raw history
Works across sessions automatically

Quick Setup

1. Create SESSION-STATE.md (Hot RAM)

cat > SESSION-STATE.md << 'EOF'
# SESSION-STATE.md — Active Working Memory

This file is the agent's "RAM" — survives compaction, restarts, distractions.

## Current Task
[None]

## Key Context
[None yet]

## Pending Actions
- [ ] None

## Recent Decisions
[None yet]

---
*Last updated: [timestamp]*
EOF

2. Enable LanceDB (Warm Store)

In ~/.clawdbot/clawdbot.json:

{
  "memorySearch": {
    "enabled": true,
    "provider": "openai",
    "sources": ["memory"],
    "minScore": 0.3,
    "maxResults": 10
  },
  "plugins": {
    "entries": {
      "memory-lancedb": {
        "enabled": true,
        "config": {
          "autoCapture": false,
          "autoRecall": true,
          "captureCategories": ["preference", "decision", "fact"],
          "minImportance": 0.7
        }
      }
    }
  }
}

3. Initialize Git-Notes (Cold Store)

cd ~/clawd
git init  # if not already
python3 skills/git-notes-memory/memory.py -p . sync --start

4. Verify MEMORY.md Structure

# Ensure you have:
# - MEMORY.md in workspace root
# - memory/ folder for daily logs
mkdir -p memory

5. (Optional) Setup SuperMemory

export SUPERMEMORY_API_KEY="your-key"
# Add to ~/.zshrc for persistence

Agent Instructions

On Session Start

1. Read SESSION-STATE.md — this is your hot context 2. Run memory_search for relevant prior context 3. Check memory/YYYY-MM-DD.md for recent activity

During Conversation

1. User gives concrete detail? → Write to SESSION-STATE.md BEFORE responding 2. Important decision made? → Store in Git-Notes (SILENTLY) 3. Preference expressed? → memory_store with importance=0.9

On Session End

1. Update SESSION-STATE.md with final state 2. Move significant items to MEMORY.md if worth keeping long-term 3. Create/update daily log in memory/YYYY-MM-DD.md

Memory Hygiene (Weekly)

1. Review SESSION-STATE.md — archive completed tasks 2. Check LanceDB for junk: memory_recall query="*" limit=50 3. Clear irrelevant vectors: memory_forget id=<id> 4. Consolidate daily logs into MEMORY.md

The WAL Protocol (Critical)

Write-Ahead Log: Write state BEFORE responding, not after.

Trigger	Action
User states preference	Write to SESSION-STATE.md → then respond
User makes decision	Write to SESSION-STATE.md → then respond
User gives deadline	Write to SESSION-STATE.md → then respond
User corrects you	Write to SESSION-STATE.md → then respond

Why? If you respond first and crash/compact before saving, context is lost. WAL ensures durability.

Example Workflow

User: "Let's use Tailwind for this project, not vanilla CSS"

Agent (internal):
1. Write to SESSION-STATE.md: "Decision: Use Tailwind, not vanilla CSS"
2. Store in Git-Notes: decision about CSS framework
3. memory_store: "User prefers Tailwind over vanilla CSS" importance=0.9
4. THEN respond: "Got it — Tailwind it is..."

Maintenance Commands

# Audit vector memory
memory_recall query="*" limit=50

# Clear all vectors (nuclear option)
rm -rf ~/.clawdbot/memory/lancedb/
clawdbot gateway restart

# Export Git-Notes
python3 memory.py -p . export --format json > memories.json

# Check memory health
du -sh ~/.clawdbot/memory/
wc -l MEMORY.md
ls -la memory/

Why Memory Fails

Understanding the root causes helps you fix them:

Failure Mode	Cause	Fix
Forgets everything	`memory_search` disabled	Enable + add OpenAI key
Files not loaded	Agent skips reading memory	Add to AGENTS.md rules
Facts not captured	No auto-extraction	Use Mem0 or manual logging
Sub-agents isolated	Don't inherit context	Pass context in task prompt
Repeats mistakes	Lessons not logged	Write to memory/lessons.md

Solutions (Ranked by Effort)

1. Quick Win: Enable memory_search

If you have an OpenAI key, enable semantic search:

clawdbot configure --section web

This enables vector search over MEMORY.md + memory/*.md files.

2. Recommended: Mem0 Integration

Auto-extract facts from conversations. 80% token reduction.

npm install mem0ai

const { MemoryClient } = require('mem0ai');

const client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY });

// Auto-extract and store
await client.add([
  { role: "user", content: "I prefer Tailwind over vanilla CSS" }
], { user_id: "ty" });

// Retrieve relevant memories
const memories = await client.search("CSS preferences", { user_id: "ty" });

3. Better File Structure (No Dependencies)

memory/
├── projects/
│   ├── strykr.md
│   └── taska.md
├── people/
│   └── contacts.md
├── decisions/
│   └── 2026-01.md
├── lessons/
│   └── mistakes.md
└── preferences.md

Keep MEMORY.md as a summary (<5KB), link to detailed files.

Immediate Fixes Checklist

Problem	Fix
Forgets preferences	Add `## Preferences` section to MEMORY.md
Repeats mistakes	Log every mistake to `memory/lessons.md`
Sub-agents lack context	Include key context in spawn task prompt
Forgets recent work	Strict daily file discipline
Memory search not working	Check `OPENAI_API_KEY` is set

Troubleshooting

Agent keeps forgetting mid-conversation: → SESSION-STATE.md not being updated. Check WAL protocol.

Irrelevant memories injected: → Disable autoCapture, increase minImportance threshold.

Memory too large, slow recall: → Run hygiene: clear old vectors, archive daily logs.

Git-Notes not persisting: → Run git notes push to sync with remote.

memory_search returns nothing: → Check OpenAI API key: echo $OPENAI_API_KEY → Verify memorySearch enabled in clawdbot.json

---

Links

bulletproof-memory: https://clawdhub.com/skills/bulletproof-memory
lancedb-memory: https://clawdhub.com/skills/lancedb-memory
git-notes-memory: https://clawdhub.com/skills/git-notes-memory
memory-hygiene: https://clawdhub.com/skills/memory-hygiene
supermemory: https://clawdhub.com/skills/supermemory

---

Built by [@NextXFrontier](https://x.com/NextXFrontier) — Part of the Next Frontier AI toolkit

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');

const TEMPLATES = {
  'session-state': `# SESSION-STATE.md — Active Working Memory

This file is the agent's "RAM" — survives compaction, restarts, distractions.
Chat history is a BUFFER. This file is STORAGE.

## Current Task
[None]

## Key Context
[None yet]

## Pending Actions
- [ ] None

## Recent Decisions
[None yet]

---
*Last updated: ${new Date().toISOString()}*
`,

  'memory-md': `# MEMORY.md — Long-Term Memory

## About the User
[Add user preferences, communication style, etc.]

## Projects
[Active projects and their status]

## Decisions Log
[Important decisions and why they were made]

## Lessons Learned
[Mistakes to avoid, patterns that work]

## Preferences
[Tools, frameworks, workflows the user prefers]

---
*Curated memory — distill insights from daily logs here*
`,

  'daily-template': `# {{DATE}} — Daily Log

## Tasks Completed
- 

## Decisions Made
- 

## Lessons Learned
- 

## Tomorrow
- 
`
};

const commands = {
  init: () => {
    console.log('🧠 Initializing Elite Longterm Memory...\n');
    
    // Create SESSION-STATE.md
    if (!fs.existsSync('SESSION-STATE.md')) {
      fs.writeFileSync('SESSION-STATE.md', TEMPLATES['session-state']);
      console.log('✓ Created SESSION-STATE.md (Hot RAM)');
    } else {
      console.log('• SESSION-STATE.md already exists');
    }
    
    // Create MEMORY.md
    if (!fs.existsSync('MEMORY.md')) {
      fs.writeFileSync('MEMORY.md', TEMPLATES['memory-md']);
      console.log('✓ Created MEMORY.md (Curated Archive)');
    } else {
      console.log('• MEMORY.md already exists');
    }
    
    // Create memory directory
    if (!fs.existsSync('memory')) {
      fs.mkdirSync('memory', { recursive: true });
      console.log('✓ Created memory/ directory');
    } else {
      console.log('• memory/ directory already exists');
    }
    
    // Create today's log
    const today = new Date().toISOString().split('T')[0];
    const todayFile = `memory/${today}.md`;
    if (!fs.existsSync(todayFile)) {
      const content = TEMPLATES['daily-template'].replace('{{DATE}}', today);
      fs.writeFileSync(todayFile, content);
      console.log(`✓ Created ${todayFile}`);
    }
    
    console.log('\n🎉 Elite Longterm Memory initialized!');
    console.log('\nNext steps:');
    console.log('1. Add SESSION-STATE.md to your agent context');
    console.log('2. Configure LanceDB plugin in clawdbot.json');
    console.log('3. Review SKILL.md for full setup guide');
  },
  
  today: () => {
    const today = new Date().toISOString().split('T')[0];
    const todayFile = `memory/${today}.md`;
    
    if (!fs.existsSync('memory')) {
      fs.mkdirSync('memory', { recursive: true });
    }
    
    if (!fs.existsSync(todayFile)) {
      const content = TEMPLATES['daily-template'].replace('{{DATE}}', today);
      fs.writeFileSync(todayFile, content);
      console.log(`✓ Created ${todayFile}`);
    } else {
      console.log(`• ${todayFile} already exists`);
    }
  },
  
  status: () => {
    console.log('🧠 Elite Longterm Memory Status\n');
    
    // Check SESSION-STATE.md
    if (fs.existsSync('SESSION-STATE.md')) {
      const stat = fs.statSync('SESSION-STATE.md');
      console.log(`✓ SESSION-STATE.md (${(stat.size / 1024).toFixed(1)}KB, modified ${stat.mtime.toLocaleString()})`);
    } else {
      console.log('✗ SESSION-STATE.md missing');
    }
    
    // Check MEMORY.md
    if (fs.existsSync('MEMORY.md')) {
      const stat = fs.statSync('MEMORY.md');
      const lines = fs.readFileSync('MEMORY.md', 'utf8').split('\n').length;
      console.log(`✓ MEMORY.md (${lines} lines, ${(stat.size / 1024).toFixed(1)}KB)`);
    } else {
      console.log('✗ MEMORY.md missing');
    }
    
    // Check memory directory
    if (fs.existsSync('memory')) {
      const files = fs.readdirSync('memory').filter(f => f.endsWith('.md'));
      console.log(`✓ memory/ (${files.length} daily logs)`);
    } else {
      console.log('✗ memory/ directory missing');
    }
    
    // Check LanceDB
    const lancedbPath = path.join(process.env.HOME, '.clawdbot/memory/lancedb');
    if (fs.existsSync(lancedbPath)) {
      console.log('✓ LanceDB vectors initialized');
    } else {
      console.log('• LanceDB not initialized (optional)');
    }
  },
  
  help: () => {
    console.log(`
🧠 Elite Longterm Memory CLI

Commands:
  init     Initialize memory system in current directory
  today    Create today's daily log file
  status   Check memory system health
  help     Show this help

Usage:
  npx elite-longterm-memory init
  npx elite-longterm-memory status
`);
  }
};

const command = process.argv[2] || 'help';

if (commands[command]) {
  commands[command]();
} else {
  console.log(`Unknown command: ${command}`);
  commands.help();
}

{
  "name": "elite-longterm-memory",
  "version": "1.2.0",
  "description": "Ultimate AI agent memory system. Combines bulletproof WAL protocol, vector search, git-based knowledge graphs, cloud backup, and maintenance hygiene. Never lose context again.",
  "keywords": [
    "memory",
    "ai-agent",
    "long-term-memory",
    "vector-search",
    "lancedb",
    "git-notes",
    "wal",
    "persistent-context",
    "claude",
    "gpt",
    "clawdbot",
    "moltbot",
    "cursor",
    "copilot",
    "ai",
    "llm",
    "automation",
    "context-management",
    "mem0",
    "auto-extraction",
    "fact-extraction"
  ],
  "optionalDependencies": {
    "mem0ai": "^1.0.0"
  },
  "author": "NextFrontierBuilds",
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "https://github.com/NextFrontierBuilds/elite-longterm-memory"
  },
  "homepage": "https://github.com/NextFrontierBuilds/elite-longterm-memory",
  "bugs": {
    "url": "https://github.com/NextFrontierBuilds/elite-longterm-memory/issues"
  },
  "bin": {
    "elite-memory": "./bin/elite-memory.js"
  },
  "files": [
    "SKILL.md",
    "bin/",
    "templates/",
    "README.md"
  ]
}

Elite Longterm Memory 🧠

The ultimate memory system for AI agents. Never lose context again.

![npm version](https://www.npmjs.com/package/elite-longterm-memory) ![npm downloads](https://www.npmjs.com/package/elite-longterm-memory) ![License: MIT](https://opensource.org/licenses/MIT)

---

Works With

Built for: Clawdbot • Moltbot • Claude Code • Any AI Agent

---

Combines 7 proven memory approaches into one bulletproof architecture:

✅ Bulletproof WAL Protocol — Write-ahead logging survives compaction
✅ LanceDB Vector Search — Semantic recall of relevant memories
✅ Git-Notes Knowledge Graph — Structured decisions, branch-aware
✅ File-Based Archives — Human-readable MEMORY.md + daily logs
✅ Cloud Backup — Optional SuperMemory sync
✅ Memory Hygiene — Keep vectors lean, prevent token waste
✅ Mem0 Auto-Extraction — Automatic fact extraction, 80% token reduction

Quick Start

# Initialize in your workspace
npx elite-longterm-memory init

# Check status
npx elite-longterm-memory status

# Create today's log
npx elite-longterm-memory today

Architecture

┌─────────────────────────────────────────────────────┐
│              ELITE LONGTERM MEMORY                  │
├─────────────────────────────────────────────────────┤
│  HOT RAM          WARM STORE        COLD STORE     │
│  SESSION-STATE.md → LanceDB      → Git-Notes       │
│  (survives         (semantic       (permanent      │
│   compaction)       search)         decisions)     │
│         │              │                │          │
│         └──────────────┼────────────────┘          │
│                        ▼                           │
│                   MEMORY.md                        │
│               (curated archive)                    │
└─────────────────────────────────────────────────────┘

The 5 Memory Layers

Layer	File/System	Purpose	Persistence
1. Hot RAM	SESSION-STATE.md	Active task context	Survives compaction
2. Warm Store	LanceDB	Semantic search	Auto-recall
3. Cold Store	Git-Notes	Structured decisions	Permanent
4. Archive	MEMORY.md + daily/	Human-readable	Curated
5. Cloud	SuperMemory	Cross-device sync	Optional

The WAL Protocol

Critical insight: Write state BEFORE responding, not after.

User: "Let's use Tailwind for this project"

Agent (internal):
1. Write to SESSION-STATE.md → "Decision: Use Tailwind"
2. THEN respond → "Got it — Tailwind it is..."

If you respond first and crash before saving, context is lost. WAL ensures durability.

Why Memory Fails (And How to Fix It)

Problem	Cause	Fix
Forgets everything	memory_search disabled	Enable + add OpenAI key
Repeats mistakes	Lessons not logged	Write to memory/lessons.md
Sub-agents isolated	No context inheritance	Pass context in task prompt
Facts not captured	No auto-extraction	Use Mem0 (see below)

Mem0 Integration (Recommended)

Auto-extract facts from conversations. 80% token reduction.

npm install mem0ai
export MEM0_API_KEY="your-key"

const { MemoryClient } = require('mem0ai');
const client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY });

// Auto-extracts facts from messages
await client.add(messages, { user_id: "user123" });

// Retrieve relevant memories  
const memories = await client.search(query, { user_id: "user123" });

For Clawdbot/Moltbot Users

Add to ~/.clawdbot/clawdbot.json:

{
  "memorySearch": {
    "enabled": true,
    "provider": "openai",
    "sources": ["memory"]
  }
}

Files Created

workspace/
├── SESSION-STATE.md    # Hot RAM (active context)
├── MEMORY.md           # Curated long-term memory
└── memory/
    ├── 2026-01-30.md   # Daily logs
    └── ...

Commands

elite-memory init      # Initialize memory system
elite-memory status    # Check health
elite-memory today     # Create today's log
elite-memory help      # Show help

Related skills

Setup Matt Pocock SkillsScaffold the per-repo configuration that Matt Pocock’s engineering agent skills rely on so they understand the issue tracker, triage labels, and domain documentation la495k196k

Lark AppsConnect Claude, Cursor or custom agents directly to Lark (Feishu) for messaging, document automation, approval workflows and enterprise data access.402k

CavemanSlash token usage by roughly 75% while keeping every technical detail intact when working with Claude Code, Cursor or similar agents.391k94.7k

Lark Skill MakerQuickly turn any Lark/Feishu OpenAPI call or multi-step workflow into a reusable agent skill with its own SKILL.md.386k16k

Running Claude Code Via Litellm CopilotRun Claude Code at a fraction of the cost by routing requests through LiteLLM to the GitHub Copilot Chat API.270k72

Codex PetGenerate a complete Codex Pet spritesheet and metadata from one reference image without needing an OpenAI key or Codex Pro.246k10

How it compares

Pick elite-longterm-memory over ad-hoc markdown memory files when agents need vector search, WAL durability, and git-versioned knowledge graphs in one maintained skill.

FAQ

When should I write SESSION-STATE.md?

Before responding when the user gives concrete details; triggered by user input, not agent memory alone.

Are git-notes stores announced?

No. Store decisions silently with python3 memory.py remember without announcing to the user.

What env keys are required?

OPENAI_API_KEY for LanceDB vectors; SUPERMEMORY_API_KEY and MEM0_API_KEY are optional for cloud and auto-extraction layers.

Is Elite Longterm Memory safe to install?

skills.sh reports 3 of 3 security scanners passed. Review the Security Audits panel on this page before installing in production.

AI & Agent Buildingagentsautomation

About

Elite Longterm Memory by the numbers

elite-longterm-memory capabilities & compatibility

What elite-longterm-memory says it does

Add your badge

How do I prevent agents from losing context, decisions, and preferences across compaction and restarts?

Who is it for?

When should I use this skill?

What you get

By the numbers

Files

Elite Longterm Memory 🧠

Architecture Overview

The 5 Memory Layers

Layer 1: HOT RAM (SESSION-STATE.md)

Layer 2: WARM STORE (LanceDB Vectors)

Layer 3: COLD STORE (Git-Notes Knowledge Graph)

Layer 4: CURATED ARCHIVE (MEMORY.md + daily/)

Layer 5: CLOUD BACKUP (SuperMemory) — Optional

Layer 6: AUTO-EXTRACTION (Mem0) — Recommended

Quick Setup

1. Create SESSION-STATE.md (Hot RAM)

2. Enable LanceDB (Warm Store)

3. Initialize Git-Notes (Cold Store)

4. Verify MEMORY.md Structure

5. (Optional) Setup SuperMemory

Agent Instructions

On Session Start

During Conversation

On Session End

Memory Hygiene (Weekly)

The WAL Protocol (Critical)

Example Workflow

Maintenance Commands

Why Memory Fails

Solutions (Ranked by Effort)

1. Quick Win: Enable memory_search

2. Recommended: Mem0 Integration

3. Better File Structure (No Dependencies)

Immediate Fixes Checklist

Troubleshooting

Links

Elite Longterm Memory 🧠

Works With

Quick Start

Architecture

The 5 Memory Layers

The WAL Protocol

Why Memory Fails (And How to Fix It)

Mem0 Integration (Recommended)

For Clawdbot/Moltbot Users

Files Created

Commands

Links

Related skills

How it compares

FAQ

When should I write SESSION-STATE.md?

Are git-notes stores announced?

What env keys are required?

Is Elite Longterm Memory safe to install?

This week in AI coding