Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
conorluddy avatar

Vestige Auto Memorise

  • 1 installs
  • 4 repo stars
  • Updated August 2, 2026
  • conorluddy/vestige

Agent skill for automatically building and maintaining agent memory and context.

About

Builds persistent memory for Claude Code agents. Used by long-running agents to preserve state and context across sessions.

  • Automatic context capture
  • Memory persistence layer

Vestige Auto Memorise by the numbers

  • 1 all-time installs (skills.sh)
  • Ranked #14,098 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
  • Data as of Aug 3, 2026 (Skillselion catalog sync)
npx skills add https://github.com/conorluddy/vestige --skill vestige-auto-memorise

Add your badge

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

Listed on Skillselion
Installs1
repo stars4
Last updatedAugust 2, 2026
Repositoryconorluddy/vestige

What it does

Agent skill for automatically building and maintaining agent memory and context.

Files

SKILL.mdMarkdownGitHub ↗

Auto-memorise: fire it yourself

This is the meta-capture skill. The four vestige-record-* skills wait for an explicit cue. Auto-memorise fires proactively whenever you spot a memorable moment — and dispatches inline to the right vestige subcommand without bouncing through another skill.

The point: agentic memory only compounds if capture is automatic. If the agent waits to be told "remember this" every time, the project's accumulated context stays in the user's head — exactly the failure mode Vestige exists to fix.

When to fire (the watch list)

Fire whenever the conversation produces any of the categories below. You decide the category based on the cue, then dispatch via the matching subcommand.

CategoryCues you watch forSubcommandDefault importance
Decision"we'll go with…", "let's use…", "settled —", "going with X over Y because…", "decision:", explicit ## Decision headers, you chose A over B with a stated reasonvestige decision add0.7 (0.85+ if architectural)
Preference"I prefer…", "always…", "never…", "make sure to…", "in this project we…", "convention:", "rule:", correction the user gave that you should bake investige preference add0.6 (0.8+ for hard rules)
Open question"TBD:", "open question:", "unclear whether…", "we should figure out…", "follow-up:", "park that", ## Open Questions headersvestige question add0.5 (0.8+ if blocking)
Aha / TIL / gotcha / smell / TODO / root cause / workaround / surprise"TIL", "turns out…", "the reason X happens is…", "good to know:", "careful — X breaks Y", "non-obvious", "smell:", "refactor candidate", "TODO:", "the bug was…", "I had assumed X but actually Y", "hack until…"vestige note add0.5 (0.6 for smells / root causes)

Tie-breaker rule of thumb: did the conversation produce a commitment with a why? Decision. A user opinion? Preference. An unknown? Question. Anything else worth keeping? Note.

If the moment is purely conversational acknowledgement, code that's better expressed as a TODO comment in source, or a fact already encoded in the codebase — don't capture. The auto-memorise loop's value comes from precision, not volume. A noisy memory store decays faster than a sparse one.

How to invoke (categorise → dedup → dispatch)

Step 1 — Categorise

Pick one row from the table above based on the cue. If two categories overlap (a user-stated commitment with a why), prefer decision over preference; the rationale field is the tiebreaker.

Step 2 — Dedup probe

Before writing, probe for an existing memory that already says this:

vestige recall "<3-6 keywords from the moment>" --type <category> --json --limit 3

Skip the capture if the top hit's score clears the threshold and its one_liner says essentially the same thing:

  • Lexical-only mode (default): skip when score >= 0.6.
  • --hybrid mode: skip when score >= 0.75.

If you skip, cite the existing handle: "Already recorded as `mem_…`." That's still ambient surface — short and informative.

Step 3 — Dispatch inline

Call the underlying CLI directly. Don't bounce through another skill — that just wastes turns.

Decision:

vestige decision add "<one-line decision>" \
  --rationale "<the why; cite tradeoffs / alternatives / constraints>" \
  --importance 0.7 \
  --json

Preference:

vestige preference add "<the preference, in the user's voice>" \
  --importance 0.6 \
  --json

Question:

vestige question add "<framed as an actual question>" \
  --importance 0.5 \
  --json

Note (aha / TIL / gotcha / smell / TODO / root cause / workaround / surprise):

vestige note add "<the fact, written so it stands alone>" \
  --importance 0.5 \
  --json

When the moment came from a specific file, attach --source <path:line> so the captured memory traces back to inspectable evidence.

After invocation

Surface a single ambient line per capture, no more:

Recorded decision mem_01HXXXXXXXXXXXXXXXX.

(Or note / preference / question for the other categories.) Don't read the body back to the user — they just said it. Don't list flags or rationale; the JSON already has them. Auto-memorise must feel like a quiet background commit, not a conversation interruption.

If you captured several memories in a single turn (e.g. a long planning discussion produced two decisions and one question), batch the surface line:

Recorded decision mem_01… , decision mem_01… , question mem_01… .

What this skill must NOT do

  • Never call `forget` / `restore` / `show` / `context` as the primary action. Those have their own skills.
  • Never use `vestige recall` for anything other than the dedup probe in Step 2. Recall has its own skill for retrieval-driven moments.
  • Never re-capture when the dedup probe finds a near-duplicate. Cite the existing handle instead.
  • Never narrate the capture. No "I'll record that decision because…" — just record it and surface the one-liner.

Idempotence & dedup

The skill is idempotent by discipline — the dedup probe in Step 2 is what makes proactive auto-firing safe. Without it, every "we'll go with X" from the user produces another row. With it, the second mention is a cite, not a write.

If you ever notice the project memory has accumulated near-duplicates from earlier sessions, that's a signal the dedup threshold was too generous; tighten the score thresholds in Step 2 for the rest of the session.

Why this exists (the design rationale)

The four vestige-record-* skills are precise but require an explicit "remember this" moment in the agent's reasoning. In practice that explicit moment doesn't always happen — the conversation produces a decision and moves on, and three sessions later we re-litigate the same choice.

Auto-memorise closes that loop. It says: every memorable moment is a capture moment, and you, the agent, are the trigger. The dedup probe keeps the precision that the per-type skills give you. The categorisation table keeps you using the right memory type. The ambient one-line surface keeps the user undisturbed.

Future configurability: .vestige/config.toml will gain an auto_memorise = ["decision", "preference", "question"] knob so projects can opt out of categories that are too noisy for them. Until that ships, all four categories are on by default.

Related skills

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.