Install the "memory-to-skill" agent skill from https://github.com/zilliztech/memsearch/tree/main/plugins/codex/skills/memory-to-skill into .claude/skills/memory-to-skill/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "memory-to-skill", then confirm the skill loads.
Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
skills CLI
$ npx skills add zilliztech/memsearch --skill memory-to-skill -a codex
Project install goes to .agents/skills/; add -g for ~/.codex/skills/.
Install the "memory-to-skill" agent skill from https://github.com/zilliztech/memsearch/tree/main/plugins/codex/skills/memory-to-skill into .agents/skills/memory-to-skill/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "memory-to-skill", then confirm the skill loads.
Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
skills CLI
$ npx skills add zilliztech/memsearch --skill memory-to-skill -a cursor
Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.
Install the "memory-to-skill" agent skill from https://github.com/zilliztech/memsearch/tree/main/plugins/codex/skills/memory-to-skill into .cursor/skills/memory-to-skill/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "memory-to-skill", then confirm the skill loads.
Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
skills CLI
$ npx skills add zilliztech/memsearch --skill memory-to-skill -a gemini-cli
Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.
Install the "memory-to-skill" agent skill from https://github.com/zilliztech/memsearch/tree/main/plugins/codex/skills/memory-to-skill into .gemini/skills/memory-to-skill/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "memory-to-skill", then confirm the skill loads.
Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
skills CLI
$ npx skills add zilliztech/memsearch --skill memory-to-skill -a github-copilot
Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.
Install the "memory-to-skill" agent skill from https://github.com/zilliztech/memsearch/tree/main/plugins/codex/skills/memory-to-skill into .github/skills/memory-to-skill/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "memory-to-skill", then confirm the skill loads.
GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
skills CLI
$ npx skills add zilliztech/memsearch --skill memory-to-skill -a opencode
OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
Install the "memory-to-skill" agent skill from https://github.com/zilliztech/memsearch/tree/main/plugins/codex/skills/memory-to-skill into .opencode/skills/memory-to-skill/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "memory-to-skill", then confirm the skill loads.
OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
Skill name
memory-to-skill
GitHub stars
2.7k
Token cost
~2k tokens
SKILL.md length
937 words
Files
6 (incl. references)
Skills in repo
4
Repo updated
First seen
Licence
MIT
At a glance
Turn workflows from your MemSearch memory into reusable skills.
The user asks to make/create/extract/distill a skill from what they just did
SKILL.md covers Intent routing, A. Capture what you just did…, B. Review & install candidates… and C. Mine history for recurring…, plus 3 more sections
Calls git
Review skill candidates
What it does
Memory To Skill is an agent skill from zilliztech/memsearch. Turn workflows from your MemSearch memory into reusable skills. Use when the user asks to make/create/extract/distill a skill from what they just did or from past work, review skill candidates, install a distilled skill, or 'turn this into a skill'. Manages MemSearch procedural-memory candidates under .memsearch/skill-candidates/, not the host agent's own skills system.
Its SKILL.md is about 2k tokens, which your agent loads only when the skill is triggered. The skill folder holds 6 other files, including reference files (for example `references/claude-code.md`, `references/codex.md` and `references/dsh.md`).
It sits in AI & LLM Engineering. It works with Milvus and DeepSeek. The repository describes itself as: A persistent, unified memory layer for all your AI agents (e.g. Claude Code, Codex, DSH), backed by Markdown and Milvus. The licence is MIT.
When your agent uses it
The user asks to make/create/extract/distill a skill from what they just did
Review skill candidates
Install a distilled skill
Turn this into a skill
Example prompts
“turn this into a skill”
“/memory-to-skill”
What it can do on your machine
Read from SKILL.md and the folder at commit 2a4652f. 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
Shell commands in SKILL.md call:
git
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.
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
Memory To Skill loads about 2k tokens when it runs, and up to ~2.9k if it reads all its reference files. Until then it costs about 97 tokens; SKILL.md has 937 words of instructions outside code blocks.
Always· name and description, kept in context so the agent knows when to use it
~97
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
~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.
Download SKILL.mdSave it as .claude/skills/memory-to-skill/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
memory-to-skill
description
Turn workflows from your MemSearch memory into reusable skills. Use when the user asks to make/create/extract/distill a skill from what they just did or from past work, review skill candidates, install a distilled skill, or 'turn this into a skill'. Manages MemSearch procedural-memory candidates under .memsearch/skill-candidates/, not the host agent's own skills system.
You manage MemSearch's procedural memory: skills distilled from the work you
repeat — a third layer beside the daily journals (episodic) and PROJECT.md /
USER.md (semantic). State once that this is MemSearch skill distillation, not
the host agent's built-in skills system.
Stages: 0 memory journals → 1 candidate (.memsearch/skill-candidates/,
a git-tracked store that keeps evolving) → 2 installed (an agent skill dir).
Candidates are never installed automatically; installing is always a human step.
User requests may stop at candidate creation/review, or continue to installation
in the same turn after explicit approval; match the requested stage.
The plugins.<platform>.memory_to_skill.* config key prefix and the install-path
notes are platform-specific — see your platform reference file:
Claude Code → references/claude-code.md
Codex → references/codex.md
OpenClaw → references/openclaw.md
OpenCode → references/opencode.md
DeepSeek Harness → references/dsh.md
Intent routing
"make/turn this into a skill", "from what we just did" → A. Capture now.
"mine my history / find recurring workflows" → C. Distill from history.
"enable / configure / how eager" → D. Configure.
Unclear or empty → run B's list; if empty, offer A or C.
A. Capture what you just did (0→1→2)
You already have the context, so draft the skill yourself — do not call the
background distiller for this. Write a SKILL.md body (markdown, no
frontmatter): imperative numbered steps for the recurring task, concrete commands
and paths, no secrets, self-contained.
Be exact — do not guess. You have the live session for what you just did, so use the real commands, paths, and output, not approximations. If a detail is uncertain, verify it (re-read the relevant files or the transcript) or keep that step general — a wrong command is worse than a vague one. Then persist it as a candidate:
bash
printf '%s' "## <title>\n\n1. ...\n2. ..." | memsearch skills add \
--name "<short-slug>" \
--description "<what it does AND when it should trigger — lead with the verbs a user types>" \
--body-file -
add handles slugging, standard frontmatter, meta.json, and the git commit — no
LLM is involved. Then show it to the user; install it only if the user asked for
that or explicitly approves (see B). Finally, check whether background
distillation is on; if not, offer to enable it (so recurring workflows get
captured automatically going forward) — do not force it.
B. Review & install candidates (1→2)
bash
memsearch skills status # pending candidate versions needing install
memsearch skills list # add -j for sources / installed paths
git -C .memsearch/skill-candidates log --oneline -5 2>/dev/null || true
skills status compares each candidate's current SKILL.md content hash with
the hash recorded by the last skills install. It does not inspect live agent
skill directories. A pending installed skill means the candidate source evolved
after the last deliberate install; reinstall only after reviewing the candidate.
Before recommending or installing, skim the candidate's body: if a step looks uncertain or loosely summarized, re-check it against the source (open the transcript if needed) or flag it to the user and let them decide — installing copies the candidate as-is, so this is the last chance to catch a wrong step.
When showing candidates, mention the store's recent git history when it helps
explain whether a candidate is new, evolved, removed, or re-created.
Treat installation as an interactive checkpoint. Show the candidate, apply any
requested tweaks before installing, and confirm the install destination with the
user. Resolve install targets from config first: if paths is a non-empty
list, present those paths as the proposed destinations and pass each entry as a
--path after confirmation. If it is empty, ask the user where to install; do
not silently fall back to a default path.
Replace <platform> with your platform key prefix (see the reference file).
After installation, remind the user to start a fresh agent session or reopen the
conversation so the newly installed skill is loaded.
If the list is empty, background distillation is likely off or has not run.
Offer the user a choice: capture from recent work now (A), distill from
history (C), or enable the background pass (D).
Show full SKILL.md (339 more words)Show less
C. Mine history for recurring workflows (0→1)
To pull skills out of past work (not just the current session), read the recent
journals yourself — they live in .memsearch/memory/*.md — and look for
multi-step procedures that recur across several sessions. Draft each genuinely
reusable one and persist it with memsearch skills add (one call per skill), the
same way as A. Use your own judgment: only propose procedures that recur and
generalize, not one-offs from a single day.
Drill into the original before drafting. The journal bullets are a lossy summary; the exact commands, flags, and paths live in the original transcript. Each journal entry has an anchor naming the transcript file. Run the transcript drill (see the memory-recall skill's platform reference for the exact command) to get the original turns with their tool calls. Write the skill from that. If the shown excerpt feels incomplete, skim nearby turns in the same original source before committing to exact commands or paths. Only if that command fails (unknown format) fall back to reading the raw file directly. If you cannot confirm a detail, keep the step general or omit it — never fabricate.
The background pass mines automatically when enabled, starting from the summaries; doing it here on demand lets you inspect the original transcripts more deliberately, so the result can be more accurate.
D. Configure
See your platform reference file for the exact plugins.<platform>.memory_to_skill.* commands:
bash
memsearch config get plugins.<platform>.memory_to_skill.enabled 2>/dev/null || echo "false"
# enable the background pass globally (do not enable silently)
memsearch config set plugins.<platform>.memory_to_skill.enabled true
# how eagerly history-mining distils (default 3; lower = more eager)
memsearch config set plugins.<platform>.memory_to_skill.min_occurrences 3
# pre-set install targets (otherwise you are asked at install time)
memsearch config set plugins.<platform>.memory_to_skill.paths '[".agents/skills"]'
Since v0.4.11, project-local .memsearch.toml accepts only allowlisted local
indexing keys. Do not use --project for plugins.* settings such as
memory_to_skill.enabled, min_occurrences, or paths; put them in global
config instead.
Note: enabled only gates the background (session-end) pass. The explicit
commands above (skills add, skills install) always work, and you can mine history (C) directly.
Install paths
See your platform reference file for the platform-specific skill directory and
the recommended install target.
Guardrails
Never enable the feature, change install paths, or install a candidate without
the user's go-ahead.
Do not hand-edit the store; create candidates with memsearch skills add and let
the git-tracked store at .memsearch/skill-candidates/ keep history.
Memory To Skill 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.
Orchestrate DeepSeek Oracle multi-agent workflows by routing user intents to specialist oracle skills, enforcing safety gates, and composing one unified answer with follow-up questions and action…
Installs OpenCode as an optional NanoClaw agent runtime, reaching OpenRouter, OpenAI, Google, DeepSeek and others through OpenCode's own configuration.
Gives text-only models sight by running the modlens CLI on an image path or URL and returning structured JSON evidence with transcribed text, layout and semantics.
Turn workflows from your MemSearch memory into reusable skills. Memory To Skill is an agent skill from zilliztech/memsearch. Turn workflows from your MemSearch memory into reusable skills.
When should I use Memory To Skill?
Memory To Skill fits situations like: the user asks to make/create/extract/distill a skill from what they just did; review skill candidates; install a distilled skill; turn this into a skill.
How do I install Memory To Skill in Claude Code?
Run `npx skills add zilliztech/memsearch --skill memory-to-skill -a claude-code`. Or copy the skill folder (plugins/codex/skills/memory-to-skill in zilliztech/memsearch) into .claude/skills/memory-to-skill in your project. Claude Code loads it when a task matches its description.
How do I install Memory To Skill in Codex?
Run `npx skills add zilliztech/memsearch --skill memory-to-skill -a codex`. Or copy the skill folder (plugins/codex/skills/memory-to-skill in zilliztech/memsearch) into .agents/skills/memory-to-skill in your project. Codex loads it when a task matches its description.
Can I use Memory To Skill 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 zilliztech/memsearch --skill memory-to-skill -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/memory-to-skill, .gemini/skills/memory-to-skill, .github/skills/memory-to-skill and .opencode/skills/memory-to-skill in your project.
What does Memory To Skill need to run?
Going by SKILL.md and its folder, Memory To Skill needs the command-line tools its instructions call (git).
Does Memory To Skill access the network?
SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.
Is Memory To Skill 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 Memory To Skill use?
Memory To Skill 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 Memory To Skill 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 919 tokens, read only when the agent opens those files.
What are the alternatives to Memory To Skill?
Skills that share tags, products or a category with Memory To Skill: Oracle Agent Team Orchestrator (Bald0Wang/DeepSeek-Oracle, 187 stars), Dsh Playbook (ZSeven-W/dsh-crew, 156 stars), OpenCode Agent Provider for NanoClaw (nanocoai/nanoclaw, 31k stars) and Phx Investigate (oliver-kriska/claude-elixir-phoenix, 565 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Memory To Skill?
zilliztech (a GitHub organization) maintains it in zilliztech/memsearch, which has 2,727 GitHub stars. The repository holds 4 skills in this directory. The repository was last updated on September 24, 2026.
Source: zilliztech/memsearch on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.