Agent skill

Elite Longterm Memory

by aAAaqwq in aAAaqwq/AGI-Super-Team

Ultimate AI agent memory system for Cursor, Claude, ChatGPT & Copilot.

MITAuto-check passedAgent Workflows

Install Elite Longterm Memory

skills CLI
$ npx skills add aAAaqwq/AGI-Super-Team --skill elite-longterm-memory -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install aAAaqwq/AGI-Super-Team elite-longterm-memory --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/aAAaqwq/AGI-Super-Team.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/elite-longterm-memory .claude/skills/elite-longterm-memory && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
elite-longterm-memory
GitHub stars
105
Used in
2 other repos
Token cost
~2.9k tokens
SKILL.md length
598 words
Files
5
Skills in repo
152
Repo updated
First seen
Licence
MIT

At a glance

Ultimate AI agent memory system for Cursor, Claude, ChatGPT & Copilot.

  • Works in 8 steps: Create SESSION-STATE.md (Hot RAM) → Enable LanceDB (Warm Store) → Initialize Git-Notes (Cold Store) → …
  • Tasks that involve Agent memory
  • SKILL.md covers Architecture Overview, The 5 Memory Layers, Quick Setup and Agent Instructions, plus 7 more sections
  • Runs JavaScript scripts from its folder; calls python3, npm and git; needs OPENAI_API_KEY and MEM0_API_KEY

What it does

Elite Longterm Memory is an agent skill from aAAaqwq/AGI-Super-Team. Ultimate AI agent memory system for Cursor, Claude, ChatGPT & Copilot. WAL protocol + vector search + git-notes + cloud backup. Never lose context again. Vibe-coding ready.

Its SKILL.md is about 2.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files (for example `README.md`, `_meta.json` and `bin/elite-memory.js`).

It sits in Agent Workflows, covering Agent memory, Vector databases and Git workflow. It works with Git and OpenAI. The repository describes itself as: An installable, cross-framework AI organization: C-suite agents, expert subagents, curated skills, independent review, and one-command setup across 18 AI client/runtime adapters. The licence is MIT.

When your agent uses it

  • Tasks that involve Agent memory
  • Tasks that involve Vector databases
  • Tasks that involve Git workflow

Example prompts

  • “/elite-longterm-memory”

Requirements

  • Python 3
  • Node.js
  • A credential in OPENAI_API_KEY
  • A credential in SUPERMEMORY_API_KEY

Workflow steps

8 steps, taken from the step headings in SKILL.md.

  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
  6. Quick Win: Enable memory_search
  7. Recommended: Mem0 Integration
  8. Better File Structure (No Dependencies)

What it can do on your machine

Read from SKILL.md and the folder at commit 331ecd3. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships script files (JavaScript), which the agent can run.

    Shell commands in SKILL.md call:

    • python3
    • npm
    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • clawdhub.com
    • x.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • OPENAI_API_KEY
    • MEM0_API_KEY
    • SUPERMEMORY_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Elite Longterm Memory loads about 2.9k tokens when it runs. Until then it costs about 49 tokens; SKILL.md has 598 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~49
When it runs · the whole SKILL.md, loaded when a task matches
~2.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from aAAaqwq/AGI-Super-Team at commit 331ecd3, republished under its MIT licence (© aAAaqwq). 598 words, ~2,897 tokens.

Download SKILL.mdSave it as .claude/skills/elite-longterm-memory/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
elite-longterm-memory
description
Ultimate AI agent memory system for Cursor, Claude, ChatGPT & Copilot. WAL protocol + vector search + git-notes + cloud backup. Never lose context again. Vibe-coding ready.
version
1.2.3
author
NextFrontierBuilds
keywords
memory, ai-agent, ai-coding, long-term-memory, vector-search, lancedb, git-notes, wal, persistent-context, claude, claude-code, gpt, chatgpt, cursor, copilot…

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.

markdown
# 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.

bash
# 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.

bash
# 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: OpenClaw 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.

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

NEW: Automatic fact extraction

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

bash
npm install mem0ai
export MEM0_API_KEY="your-key"
javascript
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)
bash
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 ~/.openclaw/openclaw.json:

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)
bash
cd ~/clawd
git init  # if not already
python3 skills/git-notes-memory/memory.py -p . sync --start
4. Verify MEMORY.md Structure
bash
# Ensure you have:
# - MEMORY.md in workspace root
# - memory/ folder for daily logs
mkdir -p memory
5. (Optional) Setup SuperMemory
bash
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.

TriggerAction
User states preferenceWrite to SESSION-STATE.md → then respond
User makes decisionWrite to SESSION-STATE.md → then respond
User gives deadlineWrite to SESSION-STATE.md → then respond
User corrects youWrite 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..."
Show full SKILL.md (240 more words)Show less

Maintenance Commands

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

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

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

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

Why Memory Fails

Understanding the root causes helps you fix them:

Failure ModeCauseFix
Forgets everythingmemory_search disabledEnable + add OpenAI key
Files not loadedAgent skips reading memoryAdd to AGENTS.md rules
Facts not capturedNo auto-extractionUse Mem0 or manual logging
Sub-agents isolatedDon't inherit contextPass context in task prompt
Repeats mistakesLessons not loggedWrite to memory/lessons.md

Solutions (Ranked by Effort)

If you have an OpenAI key, enable semantic search:

bash
openclaw configure --section web

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

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

bash
npm install mem0ai
javascript
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

ProblemFix
Forgets preferencesAdd ## Preferences section to MEMORY.md
Repeats mistakesLog every mistake to memory/lessons.md
Sub-agents lack contextInclude key context in spawn task prompt
Forgets recent workStrict daily file discipline
Memory search not workingCheck 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 openclaw.json



Built by @NextXFrontier — Part of the Next Frontier AI toolkit

© aAAaqwq, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 4 other files in skills/elite-longterm-memory of aAAaqwq/AGI-Super-Team.

  • SKILL.md
  • README.md
  • _meta.json
  • bin/elite-memory.js
  • package.json

Open the folder on GitHubat commit 331ecd3

Used in 2 other repositories

We found 2 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 2 other GitHub owners. This page covers the copy in aAAaqwq/AGI-Super-Team, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Elite Longterm Memory next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Elite Longterm Memory compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Elite Longterm Memory this skillaAAaqwq/AGI-Super-Team1052 repos~2.9kAutomated safety check: PassMIT
Gccdavila7/claude-code-templates32k—~1.6kAutomated safety check: PassMIT
Beads Task Memorygastownhall/beads28k—~1.2kAutomated safety check: PassMIT
Session History Searchslopus/happy24k—~3.1kAutomated safety check: PassMIT
Session Catchup and Handoffposhan0126/dotclaude871—~811Automated safety check: PassMIT
Session Handoff Writercodewhale-hq/Codewhale41k—~1.2kAutomated safety check: PassMIT

Similar skills

  • Gcc

    davila7/claude-code-templates

    Git Context Controller (GCC) - Manages agent memory as a versioned file system under .GCC/.

    32k GitHub stars~1.6k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed
  • Beads Task Memory

    gastownhall/beads

    Tracks multi-session work with dependencies in the bd issue tracker so the agent can find ready tasks and recover its context after conversation compaction.

    28k GitHub stars~1.2k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed
  • Searches past Claude Code, Codex and Cursor sessions and summarizes what was worked on, tried or decided, using extraction scripts instead of reading raw logs.

    24k GitHub stars~3.1k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed
  • Session Catchup and Handoff

    poshan0126/dotclaude

    Rebuilds working context after /clear by reading a handoff note and the branch's git state, or writes that handoff note before a session ends.

    871 GitHub stars~811 tokensUpdated 1 mo ago
    Agent WorkflowsAuto-check passed
  • Session Handoff Writer

    codewhale-hq/Codewhale

    Writes a compact handoff note from real git and CI state so the next session or a teammate can pick up the work without rebuilding the context.

    41k GitHub stars~1.2k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed
  • Watchmen Setup

    firstbatchxyz/watchmen

    Sets up watchmen on the current machine: installs the CLI, hands off the init wizard, wires the plugin and statusline into Claude Code and Codex, and verifies with doctor.

    296 GitHub stars~1.2k tokensUpdated 1 mo ago
    Agent WorkflowsAuto-check: notes

More from aAAaqwq/AGI-Super-Team

All 152 skills in this repo
  • Content Creator

    aAAaqwq/AGI-Super-Team

    Create SEO-optimized marketing content with consistent brand voice.

    105 GitHub starsUsed in 3 repos~1.9k tokens
    Auto-check passed
  • Financial Calculator

    aAAaqwq/AGI-Super-Team

    Advanced financial calculator with future value tables, present value, discount calculations, markup pricing, and compound interest.

    105 GitHub starsUsed in 1 repo~1.5k tokens
    Auto-check passed
  • Frontend Design Ultimate

    aAAaqwq/AGI-Super-Team

    Create distinctive, production-grade static sites with React, Tailwind CSS, and shadcn/ui — no mockups needed.

    105 GitHub starsUsed in 2 repos~2.7k tokens
    Auto-check passed
  • Sysadmin Toolbox

    aAAaqwq/AGI-Super-Team

    Tool discovery and shell one-liner reference for sysadmin, DevOps, and security tasks.

    105 GitHub starsUsed in 2 repos~775 tokens
    Auto-check passed
  • Zsxq Smart Publish

    aAAaqwq/AGI-Super-Team

    Publish and manage content on 知识星球 (zsxq.com). An agent skill from aAAaqwq/AGI-Super-Team.

    105 GitHub stars~1.5k tokensUpdated 11 days ago
    Auto-check passed
  • Content Extract

    aAAaqwq/AGI-Super-Team

    Robust URL-to-Markdown extraction for OpenClaw workflows. An agent skill from aAAaqwq/AGI-Super-Team.

    105 GitHub starsUsed in 1 repo~650 tokens
    Auto-check passed

Works with

Categories

Questions about Elite Longterm Memory

What does Elite Longterm Memory do?

Ultimate AI agent memory system for Cursor, Claude, ChatGPT & Copilot. Elite Longterm Memory is an agent skill from aAAaqwq/AGI-Super-Team. Ultimate AI agent memory system for Cursor, Claude, ChatGPT & Copilot.

When should I use Elite Longterm Memory?

Elite Longterm Memory fits situations like: tasks that involve Agent memory; tasks that involve Vector databases; tasks that involve Git workflow.

How do I install Elite Longterm Memory in Claude Code?

Run `npx skills add aAAaqwq/AGI-Super-Team --skill elite-longterm-memory -a claude-code`. Or copy the skill folder (skills/elite-longterm-memory in aAAaqwq/AGI-Super-Team) into .claude/skills/elite-longterm-memory in your project. Claude Code loads it when a task matches its description.

How do I install Elite Longterm Memory in Codex?

Run `npx skills add aAAaqwq/AGI-Super-Team --skill elite-longterm-memory -a codex`. Or copy the skill folder (skills/elite-longterm-memory in aAAaqwq/AGI-Super-Team) into .agents/skills/elite-longterm-memory in your project. Codex loads it when a task matches its description.

Can I use Elite Longterm Memory in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add aAAaqwq/AGI-Super-Team --skill elite-longterm-memory -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/elite-longterm-memory, .gemini/skills/elite-longterm-memory, .github/skills/elite-longterm-memory and .opencode/skills/elite-longterm-memory in your project.

What does Elite Longterm Memory need to run?

Going by SKILL.md and its folder, Elite Longterm Memory needs JavaScript for the scripts in its folder, the command-line tools its instructions call (python3, npm and git) and credentials named OPENAI_API_KEY, MEM0_API_KEY and SUPERMEMORY_API_KEY. Our summary lists: Python 3; Node.js; A credential in OPENAI_API_KEY; A credential in SUPERMEMORY_API_KEY.

Does Elite Longterm Memory access the network?

SKILL.md names 2 domains. As links in the text: clawdhub.com and x.com. This is read from the text; nothing was executed.

Is Elite Longterm Memory safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Elite Longterm Memory use?

Elite Longterm Memory is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Elite Longterm Memory use?

About 2.9k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Elite Longterm Memory?

Skills that share tags, products or a category with Elite Longterm Memory: Gcc (davila7/claude-code-templates, 32k stars), Beads Task Memory (gastownhall/beads, 28k stars), Session History Search (slopus/happy, 24k stars) and Session Catchup and Handoff (poshan0126/dotclaude, 871 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Elite Longterm Memory?

aAAaqwq (a GitHub user) maintains it in aAAaqwq/AGI-Super-Team, which has 105 GitHub stars. The repository holds 152 skills in this directory. The repository was last updated on September 27, 2026.

Source: aAAaqwq/AGI-Super-Team on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.