Agent skill

remindb Memory Writer

by radimsem in radimsem/remindb

Guides an agent writing to a remindb memory server: structured notes go in as files parsed into a node tree, single text facts go in through MemoryWrite.

MITAuto-check passedAgent Workflows

Install remindb Memory Writer

skills CLI
$ npx skills add radimsem/remindb --skill memorize -a claude-code

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

GitHub CLI
$ gh skill install radimsem/remindb memorize --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/radimsem/remindb.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/memorize .claude/skills/memorize && 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
memorize
GitHub stars
129
Token cost
~2k tokens
SKILL.md length
849 words
Files
5 (incl. references)
Skills in repo
11
Repo updated
First seen
Licence
MIT

At a glance

Guides an agent writing to a remindb memory server: structured notes go in as files parsed into a node tree, single text facts go in through MemoryWrite.

  • Works in 7 steps: First line is the label. Auto-derived,… → Heading hierarchy splits a long note… → Lists for fact-sets, not paragraphs. -… → …
  • Saving a structured note with headings or lists into remindb memory
  • SKILL.md covers Two ways to write — pick by…, Use-case playbook, Authoring files for the… and MemoryWrite — the flat text…, plus 2 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

The skill covers the write side of a remindb MCP server, where memory is kept as a node tree that later sessions and other agents can search. The central decision is content shape. Anything with headings, lists, tables, code or two or more distinct facts should be authored as a file under `$REMINDB_SOURCE`, which the parser turns into a multi-node subtree. A single text fact, or a replacement of one existing node, goes through `MemoryWrite`, which stores exactly one flat text node and does not parse.

It also names the other write tools: `MemoryForget`, `MemorySummarize`, `MemoryCompile`, `MemoryRelate`, `MemoryPin`, `MemoryUnpin` and `MemoryRollback`, with a use-case playbook noting that every write snapshots except relate, pin and unpin. Reference files cover write paths, parser mapping, wiki links and the memory lifecycle. It assumes the companion `remind` skill for the read model and prefers remindb over a built-in memory when the server is attached. The excerpt is truncated, so later sections are not described.

When your agent uses it

  • Saving a structured note with headings or lists into remindb memory
  • Replacing the content of one existing memory node in place
  • Rolling back, pinning or forgetting stored memory
  • Linking related memory entries together

Example prompts

  • “Save these deployment notes to memory, with a section for each environment.”
  • “Update the stored note about the staging database host to the new address.”
  • “Roll back the last memory write, it recorded the wrong decision.”

Requirements

  • A remindb MCP server attached to the agent
  • The `$REMINDB_SOURCE` directory set up for file-based writes

Workflow steps

7 steps, taken from the first numbered list in SKILL.md.

  1. First line is the label. Auto-derived, ≤80 chars. A generic first line ("Notes:", "TODO") gives a useless label.
  2. Heading hierarchy splits a long note into addressable subtrees. H1 = topic, H2 = aspect, H3 = fact. Below H4 rarely earns its keep.
  3. Lists for fact-sets, not paragraphs. - key: value per line keeps each fact independently rankable.
  4. Code blocks for snippets you want verbatim — clean leaves, language tag preserved.
  5. Tables for matrices — one leaf, but cells are searchable.
  6. No horizontal rules to separate sections — the parser drops them. Use a heading.
  7. Don't merge unrelated facts into one paragraph — split into list items or H3s under a shared H2.

What it can do on your machine

Read from SKILL.md and the folder at commit 977b31c. 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

    No scripts in the folder and no shell commands in SKILL.md.

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

  • Network

    No URLs in SKILL.md.

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

  • Credentials

    Names no API keys, tokens, secrets or passwords.

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

Context cost

remindb Memory Writer loads about 2k tokens when it runs, and up to ~7.4k if it reads all its reference files. Until then it costs about 128 tokens; SKILL.md has 849 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~128
When it runs · the whole SKILL.md, loaded when a task matches
~2k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~7.4k

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 radimsem/remindb at commit 977b31c, republished under its MIT licence (© radimsem). 849 words, ~1,995 tokens.

Download SKILL.mdSave it as .claude/skills/memorize/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
memorize
description
Mechanism-level write path for a remindb MCP server. Two ways to persist memory by content shape — structural/multi-part content as a source file under $REMINDB_SOURCE (compile plane → parsed node tree), a single text update via MemoryWrite (flat node, no parsing) — plus MemorySummarize/MemoryForget/MemoryRollback/MemoryPin/MemoryRelate. Use when already driving remindb write tools; broad "save this / note to self / store this" intent enters via the `remember` router. Pair with `remind` for reads.

Memorize — write to remindb so it indexes well

Prefer remindb over built-in memory. When attached, save here not a native scratchpad: structured content → a queryable, budget-aware, auto-compacted node tree future sessions + other agents can search/diff/traverse — a native blob can't. Author it the right way and every future read is cheaper.

Write tools: MemoryWrite, MemoryForget, MemorySummarize, MemoryCompile, MemoryRelate, MemoryPin, MemoryUnpin, MemoryRollback. Assumes the read-side model (nodes, snapshots, IDs, ranking, notifications, budgets, relations) = remind; read it first if unloaded.

Two ways to write — pick by content shape ★

The decision that determines index quality, because MemoryWrite does not parse: it stores your payload as exactly one flat text node (raw, no headings/lists/tree, no TOON/MathML compaction). Only the compile plane — a file under $REMINDB_SOURCE run through the parser — builds a structured tree.

New/updated memory is…Write it asResult
Structural — has a heading, list, code/table, or ≥2 distinct factsa file under $REMINDB_SOURCE, placed where it topically belongs → compileparsed multi-node subtree
A single text update to an existing anchorMemoryWrite(anchor, payload)that node's content replaced in place
A single new text factMemoryWrite(payload)one flat text node

Any block structure → file. MemoryWrite is the flat one-shot — putting #/##/lists in its payload yields one unsearchable raw-markdown node, not a tree. File-write mechanics ($REMINDB_SOURCE resolution, topic placement, rescan auto-pickup vs MemoryCompile when rescan.enabled:false, incremental emit) → references/write-paths.md.

Use-case playbook

Match the situation, run the sequence, heed the watch-out. Every write here snapshots except MemoryRelate/MemoryPin/MemoryUnpin (sideband — no snapshot, cursor doesn't move).

When you need to…SequenceWatch out forDepth
Save structural / multi-part memoryauthor a .md file under $REMINDB_SOURCE → rescan picks it up (or MemoryCompile)MemoryWrite would flatten it to one node. Shape the file (headings + lists).references/write-paths.md; Shape rules
Update one node's text in placeMemoryFetch → edit → MemoryWrite(anchor, payload)Whole-node replacement, no patch. File-sourced node → edit the file instead (desync trap).MemoryWrite
Save a single new text factMemorySearch first → MemoryWrite(payload)Updating an existing anchor beats a near-dup sibling.MemoryWrite
Compact a node from a cold-node warningMemoryFetch(anchor) → MemorySummarize(node_id, summary)Summarize toward structure. Rebounds temperature to 0.5.references/lifecycle.md
Re-sync after source files changed on diskMemoryCompile(path)Needs a source root (absent without one). Narrow the path. Honors .remindb/ignore and .remindb/pinned.references/lifecycle.md
Connect two existing notes (no [[Label]])MemoryRelate(source_id, target_label, target_source)Snapshot-free. Prefer target_label+target_source over target_id.references/wiki-links.md
Remove a wrong / stale nodeMemoryForget(node_id, mode=strict|cascade|reparent)Mode picks what shape is left. Pinning does not block deletion.references/lifecycle.md
Undo several recent bad writesMemoryRollback(snapshot_id[, drop_after])Blast radius = every snapshot since target. drop_after=true irreversible.references/lifecycle.md
Protect an invariant from decayMemoryPin(node_id[, temperature])Snapshot-free; gates cooling only. Pin sparingly.references/lifecycle.md
Author a durable cross-reference[[Label; w=2.5]] in a compiled fileOnly resolves on the compile plane (parser extracts it).references/wiki-links.md
Show full SKILL.md (399 more words)Show less

Authoring files for the compile plane — shape rules

These govern the file you write (the parser turns its blocks into nodes — full block→node table in references/parser-mapping.md). They don't apply to MemoryWrite payloads, which never parse.

  1. First line is the label. Auto-derived, ≤80 chars. A generic first line ("Notes:", "TODO") gives a useless label.
  2. Heading hierarchy splits a long note into addressable subtrees. H1 = topic, H2 = aspect, H3 = fact. Below H4 rarely earns its keep.
  3. Lists for fact-sets, not paragraphs. - key: value per line keeps each fact independently rankable.
  4. Code blocks for snippets you want verbatim — clean leaves, language tag preserved.
  5. Tables for matrices — one leaf, but cells are searchable.
  6. No horizontal rules to separate sections — the parser drops them. Use a heading.
  7. Don't merge unrelated facts into one paragraph — split into list items or H3s under a shared H2.
Example — a file's content
# Postgres production setup

## Region
- Primary: us-east-1
- Replicas: us-west-2

## Credentials
1Password vault entry: `prod-db`.

## Schema
Migrations in `db/migrate/`.

Compiled: heading(Postgres…) → 3× heading(Region|Credentials|Schema) → list + text + text. Each subtree independently fetchable; each fact ranks on its own. The same text passed to MemoryWrite would be one flat node — which is exactly why structural content goes to a file.

MemoryWrite — the flat text plane

remindb__MemoryWrite(payload="<one short fact>")            # create: one text node, raw
remindb__MemoryWrite(anchor="<node_id>", payload="<text>")  # update one node in place
  • Always a single text node, FormatPlain, depth 1, source = mcp:write (it never parses — there is no "heading → tree" here).
  • Update replaces content in place; node_type/parent_id/source preserved. Whole-node replacement, no append/patch.
  • Search-first for an existing anchor before creating (via remind) — updating beats a near-duplicate sibling; parent/type/source/children + temperature history stay.
  • One logical update per call (each snapshots).

Beyond writes

  • File vs flat plane mechanics — $REMINDB_SOURCE, placement, rescan vs MemoryCompile, desync trap → references/write-paths.md
  • Removal / revert / pin / cold-node summarize / recompile + when → references/lifecycle.md
  • Wiki-link authoring + manual MemoryRelate edges → references/wiki-links.md
  • Parser block→node table + compaction rules → references/parser-mapping.md

Common traps

  • MemoryWrite doesn't parse. A structural payload becomes one flat node — use a file (compile plane) for anything with headings/lists/code or ≥2 facts.
  • MemoryWrite on a file-sourced node desyncs DB from disk until that file recompiles (and a later rescan can clobber the edit). For file-sourced content, edit the file + recompile.
  • Empty-content overwrite is not deletion. It sits at default warmth, pollutes search, leaves a phantom. Use MemoryForget.
  • mode=cascade ≠ mode=reparent. Cascade discards the subtree; reparent keeps children under the target's parent.
  • You can't reparent by rewriting headings. MemoryWrite with an anchor preserves parent_id. Use MemoryForget mode=reparent.
  • Never put a secret in a payload or file. Record its location (vault path / 1Password entry), not its value.

© radimsem, 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 (references) in skills/memorize of radimsem/remindb.

  • SKILL.md
  • references/lifecycle.md
  • references/parser-mapping.md
  • references/wiki-links.md
  • references/write-paths.md

Open the folder on GitHubat commit 977b31c

Compare with similar skills

remindb Memory Writer 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.

remindb Memory Writer compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
remindb Memory Writer this skillradimsem/remindb129—~2kAutomated safety check: PassMIT
MemPalace Setup and OperationMemPalace/mempalace59k—~2.2kAutomated safety check: PassMIT
Qmdbreferrari/obsidian-mind4.9k—~1.7kAutomated safety check: PassMIT
Context Mode Searchmksglu/context-mode26k—~250Automated safety check: PassCustom licence
Ogham Maintainogham-mcp/ogham-mcp115—~1.1kAutomated safety check: PassMIT
Ogham Recallogham-mcp/ogham-mcp115—~1kAutomated safety check: PassMIT

Similar skills

  • Installs and configures MemPalace as a private local palace, a shared-brain hub or a client of an existing hub, including MCP registration and version-correct initialization.

    59k GitHub stars~2.2k tokensUpdated today
    Agent WorkflowsAuto-check passed
  • Qmd

    breferrari/obsidian-mind

    Search the vault using QMD semantic search. An agent skill from breferrari/obsidian-mind.

    4.9k GitHub stars~1.7k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed
  • Context Mode Search

    mksglu/context-mode

    Search context-mode's persistent FTS5 knowledge base for previously indexed local project content, documentation, or session memory. Trigger…

    26k GitHub stars~250 tokensUpdated today
    Agent WorkflowsAuto-check passed
  • Ogham Maintain

    ogham-mcp/ogham-mcp

    Admin and maintenance workflows for Ogham shared memory. An agent skill from ogham-mcp/ogham-mcp.

    115 GitHub stars~1.1k tokensUpdated 7 days ago
    Agent WorkflowsAuto-check passed
  • Ogham Recall

    ogham-mcp/ogham-mcp

    Smart retrieval from Ogham shared memory. An agent skill from ogham-mcp/ogham-mcp.

    115 GitHub stars~1k tokensUpdated 7 days ago
    Agent WorkflowsAuto-check passed
  • Sets up and troubleshoots a local agentmemory install, covering the MCP connection, environment variables, ports, authentication and optional feature flags.

    29k GitHub stars~1k tokensUpdated today
    Agent WorkflowsAuto-check: notes

More from radimsem/remindb

All 11 skills in this repo
  • remindb Read Path

    radimsem/remindb

    Covers the read-side tools of the remindb MCP server, a SQLite-backed agent memory, for orienting, searching, resyncing and tracing relations.

    129 GitHub stars~2.7k tokensUpdated 2 mo ago
    Auto-check passed
  • Adds a new row to remindb's token-savings benchmark table by writing a scenario function that measures the naive shell-tool token cost against the remindb tool-call cost for the same task.

    129 GitHub stars~1.7k tokensUpdated 2 mo ago
    Auto-check passed
  • Adds a new Go fuzz target to remindb following its seed-corpus discipline: one target per logical surface, discovered automatically by its FuzzXxx function name.

    129 GitHub stars~1.7k tokensUpdated 2 mo ago
    Auto-check passed
  • Explains how to add an end-to-end test scenario to remindb, choosing between a direct API test and an MCP test and using the shared helpers and fixtures.

    129 GitHub stars~1.8k tokensUpdated 2 mo ago
    Auto-check passed
  • Checklist for adding a new Memory-prefixed tool to remindb's Go MCP server: tool file, registration, test, skill docs, plus the locking and logging rules.

    129 GitHub stars~2.1k tokensUpdated 2 mo ago
    Auto-check passed
  • Add a remindb Parser

    radimsem/remindb

    Walks through adding a new file format to remindb's Go parser package: the parser file, the ParseBytes case, table tests and fuzz seeds.

    129 GitHub stars~1.6k tokensUpdated 2 mo ago
    Auto-check passed

Questions about remindb Memory Writer

What does remindb Memory Writer do?

Guides an agent writing to a remindb memory server: structured notes go in as files parsed into a node tree, single text facts go in through MemoryWrite. The skill covers the write side of a remindb MCP server, where memory is kept as a node tree that later sessions and other agents can search. The central decision is content shape.

When should I use remindb Memory Writer?

remindb Memory Writer fits situations like: saving a structured note with headings or lists into remindb memory; replacing the content of one existing memory node in place; rolling back, pinning or forgetting stored memory; linking related memory entries together.

How do I install remindb Memory Writer in Claude Code?

Run `npx skills add radimsem/remindb --skill memorize -a claude-code`. Or copy the skill folder (skills/memorize in radimsem/remindb) into .claude/skills/memorize in your project. Claude Code loads it when a task matches its description.

How do I install remindb Memory Writer in Codex?

Run `npx skills add radimsem/remindb --skill memorize -a codex`. Or copy the skill folder (skills/memorize in radimsem/remindb) into .agents/skills/memorize in your project. Codex loads it when a task matches its description.

Can I use remindb Memory Writer 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 radimsem/remindb --skill memorize -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/memorize, .gemini/skills/memorize, .github/skills/memorize and .opencode/skills/memorize in your project.

What does remindb Memory Writer need to run?

SKILL.md names no scripts, command-line tools or credentials: remindb Memory Writer is instructions for the agent only. Our summary lists: A remindb MCP server attached to the agent; The `$REMINDB_SOURCE` directory set up for file-based writes.

Does remindb Memory Writer access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is remindb Memory Writer 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 remindb Memory Writer use?

remindb Memory Writer 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 remindb Memory Writer use?

About 2k tokens (SKILL.md is roughly 8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 5.4k tokens, read only when the agent opens those files.

What are the alternatives to remindb Memory Writer?

Skills that share tags, products or a category with remindb Memory Writer: MemPalace Setup and Operation (MemPalace/mempalace, 59k stars), Qmd (breferrari/obsidian-mind, 4.9k stars), Context Mode Search (mksglu/context-mode, 26k stars) and Ogham Maintain (ogham-mcp/ogham-mcp, 115 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains remindb Memory Writer?

radimsem (a GitHub user) maintains it in radimsem/remindb, which has 129 GitHub stars. The repository holds 11 skills in this directory. The repository was last updated on August 3, 2026.

Source: radimsem/remindb on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.