reme-personal-memory

Portable file-first long-term memory for AI agents.

reme-personal-memory is a reusable skill plus workspace template for agents that need durable setup facts, stable preferences, and daily decision records without depending on a database or vector store.

Install in one command

npx skills add https://github.com/August1314/reme-personal-memory

Why people use this

• File-first and markdown-first, so the memory stays inspectable
• Portable across Claude Code, Codex, OpenClaw, and similar hosts
• Small protocol surface: SETUP.md, MEMORY.md, memory/YYYY-MM-DD.md
• Safe to publish as a template because it does not require personal runtime state

It defines a simple ReMe workspace contract built around three markdown targets:

• SETUP.md for stable setup and integration facts
• MEMORY.md for long-lived preferences and standing rules
• memory/YYYY-MM-DD.md for daily operational notes

The repository publishes the protocol, the skill, and a copyable template workspace. It does not ship private memory content, database integrations, or machine-specific paths.

Why This Exists

General-purpose agents are good at solving the task in front of them, but they are weak at preserving reusable setup knowledge across sessions. This skill gives Claude-, Codex-, and OpenClaw-like agents a shared, file-first contract for:

• cross-session setup memory
• durable tooling and integration notes
• stable user preferences and rules
• recent debugging and validation history

What This Skill Is For

Use it when an agent needs to:

• recall prior environment setup or integration topology
• store durable facts that should survive the current chat
• leave operational notes for future agents
• answer questions that depend on the user's established workflow

Do not use it for:

• temporary scratch notes
• disposable chain-of-thought
• high-volume logs
• private secrets that should not live in markdown

Repository Layout

reme-personal-memory/
├── SKILL.md
├── LICENSE
└── templates/
    └── reme-workspace/
        ├── SETUP.md
        ├── MEMORY.md
        └── memory/
            └── YYYY-MM-DD.md

Workspace Contract

A ReMe workspace root must contain:

• SETUP.md
  • stable entrypoints
  • install state
  • startup methods
  • integration topology
  • boundary conditions
• MEMORY.md
  • long-lived preferences
  • standing rules
  • durable facts
• memory/YYYY-MM-DD.md
  • daily changes
  • validation results
  • troubleshooting findings
  • decisions made that day

Recommended read order:

1. SETUP.md
2. MEMORY.md
3. memory/YYYY-MM-DD.md

Recommended write policy:

• write stable environment facts to SETUP.md
• write reusable user rules and durable facts to MEMORY.md
• write day-specific execution notes to memory/YYYY-MM-DD.md

Quick Start

1. Install the skill

If you are using the open skills ecosystem, install directly from GitHub:

npx skills add https://github.com/August1314/reme-personal-memory

If your runtime expects a local skill folder, copy this repository's SKILL.md into a skill folder named reme-personal-memory under your host's skill discovery directory.

Common locations:

• Claude Code: ~/.claude/skills/reme-personal-memory/SKILL.md
• Codex: ~/.codex/skills/reme-personal-memory/SKILL.md
• OpenClaw-like hosts: your host's configured skills directory

You can copy the file, copy the whole folder, or create a symlink if your host supports it.

2. Initialize a ReMe workspace

Copy templates/reme-workspace/ to a location you want to use as your long-term memory workspace. For example:

mkdir -p "$HOME/my-reme-workspace"
cp -R templates/reme-workspace/. "$HOME/my-reme-workspace/"

3. Bind the workspace in your local environment

The public skill defines the protocol, not your machine-specific binding. In practice, you should make sure your agents know where the ReMe workspace root lives.

Common binding patterns:

• reference the workspace path in local agent instructions
• keep a local wrapper skill that points to the real workspace root
• standardize on one known path inside your team or machine setup

Minimal Usage Examples

Typical read flow:

1. Read SETUP.md to understand the stable environment.
2. Read MEMORY.md for long-lived preferences and rules.
3. Read today's memory/YYYY-MM-DD.md if the task depends on recent work.

Typical write flow:

1. Update SETUP.md when entrypoints, startup methods, or topology change.
2. Update MEMORY.md when a rule or preference should persist long term.
3. Append to memory/YYYY-MM-DD.md when today's work changes setup, validation status, or debugging state.

Privacy and Scope

This repository should contain only:

• the skill definition
• template files
• installation guidance

It should not contain:

• personal memory content
• machine-specific incident history
• local filesystem paths from a real user environment
• secrets, tokens, or credentials

Non-Goals

This repository does not:

• manage vector stores or databases
• prescribe one ReMe product implementation
• automate installation for every host
• replace a full knowledge base

It provides a small, explicit, markdown-first memory protocol for agents.