Skip to main content
skill CX Codex

remember · langchain-ai — Claude Code skill: what it does, how to install

Reads back through the conversation and saves best practices and agreed rules to AGENTS.md or a new skill. Fires on phrases like "remember this" and "update memory".

MIT 236 installs ★ 31,501 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add langchain-ai/deepagents --skill remember -a claude-code
Open on GitHub

What remember does

The skill goes over the current conversation and pulls out what is worth keeping. Best practices come first: approaches that worked, mistakes to avoid, the quality bar you set, and the reasoning behind a choice. Coding conventions, architecture decisions, workflows and your corrections of the agent's behavior get saved too.

Each item is sorted by type. Simple preferences and rules go into memory, either the global $DEEPAGENTS_HOME/agent/AGENTS.md or the project file .deepagents/AGENTS.md. A multi-step process becomes a new skill at $DEEPAGENTS_HOME/agent/skills/<skill-name>/SKILL.md, optionally with scripts/, references/ and assets/ folders. The agent writes files with edit_file or write_file and ends with a list of what went where.

It is built for deepagents-code, and the paths come from there. In another agent, an AGENTS.md at those locations may never get read.

What it helps with

  • record why one approach was picked over another
  • log a mistake as an anti-pattern so it does not come back
  • turn a worked-out process, such as code review, into its own skill
  • store code style conventions in the project's .deepagents/AGENTS.md
  • pin down your corrections to the agent's behavior

Example prompts for the agent

  • Remember this: save our architecture decision and its reasons to .deepagents/AGENTS.md.
  • Save what we learned in this chat and turn the review process into a skill.
  • Update memory with what we agreed on in this conversation.

How to install remember

1Skills CLI (Vercel)

npx skills add langchain-ai/deepagents --skill remember -a claude-code

2Manually: put the files in place

~/.claude/skills/remember/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/remember/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about remember

How do I install remember in Claude Code?

Run npx skills add langchain-ai/deepagents --skill remember -a claude-code. The skill file ends up at ~/.claude/skills/remember/SKILL.md.

What does remember do?

It reviews the conversation, picks out best practices, conventions and decisions, and writes them to AGENTS.md memory or packages them as a new skill. At the end it lists what was saved and where.

When does remember create a skill instead of editing AGENTS.md?

Preferences and simple rules, global or per project, go to AGENTS.md. A skill is created when the conversation produced a multi-step process or method worth repeating.

Source text

SKILL.md · MIT
---
name: remember
description: "Review the current conversation and capture valuable knowledge — best practices, coding conventions, architecture decisions, workflows, and user feedback — into persistent memory (AGENTS.md) or reusable skills. Use when the user says: (1) remember this, (2) save what we learned, (3) update memory, (4) capture learnings."
license: MIT
compatibility: designed for deepagents-code
---

Review our conversation and capture valuable knowledge. Focus especially on **best practices** we discussed or discovered—these are the most important things to preserve.

## Step 1: Identify Best Practices and Key Learnings

Scan the conversation for:

### Best Practices (highest priority)
- **Patterns that worked well** - approaches, techniques, or solutions we found effective
- **Anti-patterns to avoid** - mistakes, gotchas, or approaches that caused problems
- **Quality standards** - criteria we established for good code, documentation, or processes
- **Decision rationale** - why we chose one approach over another

### Other Valuable Knowledge
- Coding conventions and style preferences
- Project architecture decisions
- Workflows and processes we developed
- Tools, libraries, or techniques worth remembering
- Feedback I gave about your behavior or outputs

## Step 2: Decide Where to Store Each Learning

For each best practice or learning, choose the right destination:

### -> Memory (AGENTS.md) for preferences and guidelines
Use memory when the knowledge is:
- A preference or guideline (not a multi-step process)
- Something to always keep in mind
- A simple rule or pattern

**Global** (`$DEEPAGENTS_HOME/agent/AGENTS.md`): Universal preferences across all projects
**Project** (`.deepagents/AGENTS.md`): Project-specific conventions and decisions

### -> Skill for reusable workflows and methodologies
**Create a skill when** we developed:
- A multi-step process worth reusing
- A methodology for a specific type of task
- A workflow with best practices baked in
- A procedure that should be followed consistently

Skills are more powerful than memory entries because they can encode **how** to do something well, not just **what** to remember.

## Step 3: Create Skills for Significant Best Practices

If we established best practices around a workflow or process, capture them in a skill.

**Example:** If we discussed best practices for code review, create a `code-review` skill that encodes those practices into a reusable workflow.

### Skill Location
`$DEEPAGENTS_HOME/agent/skills/<skill-name>/SKILL.md`

### Skill Structure
```
skill-name/
├── SKILL.md          (required - main instructions with best practices)
├── scripts/          (optional - executable code)
├── references/       (optional - detailed documentation)
└── assets/           (optional - templates, examples)
```

### SKILL.md Format
```markdown
---
name: skill-name
description: "What this skill does AND when to use it. Include triggers like 'when the user asks to X' or 'when working with Y'. This description determines when the skill activates."
---

# Skill Name

## Overview
Brief explanation of what this skill accomplishes.

## Best Practices
Capture the key best practices upfront:
- Best practice 1: explanation
- Best practice 2: explanation

## Process
Step-by-step instructions (imperative form):
1. First, do X
2. Then, do Y
3. Finally, do Z

## Common Pitfalls
- Pitfall to avoid and why
- Another anti-pattern we discovered
```

### Key Principles
1. **Encode best practices prominently** - Put them near the top so they guide the entire workflow
2. **Concise is key** - Only include non-obvious knowledge. Every paragraph should justify its token cost.
3. **Clear triggers** - The description determines when the skill activates. Be specific.
4. **Imperative form** - Write as commands: "Create a file" not "You should create a file"
5. **Include anti-patterns** - What NOT to do is often as valuable as what to do

## Step 4: Update Memory for Simpler Learnings

For preferences, guidelines, and simple rules that don't warrant a full skill:

```markdown
## Best Practices
- When doing X, always Y because Z
- Avoid A because it leads to B
```

Use `edit_file` to update existing files or `write_file` to create new ones.

## Step 5: Summarize Changes

List what you captured and where you stored it:
- Skills created (with key best practices encoded)
- Memory entries added (with location)

© langchain-ai · MIT · langchain-ai/deepagents

Similar skills

All skills for Agent setup: memory, context, orchestration →

remember by other authors comes first.

remember rohitg00 remember saves insights, decisions, and learnings to agentmemory long-term storage with concept tags so agents can retrieve them later. CX Codex +1 15,000installs remember official github remember turns lessons from coding sessions into domain-based memory instructions for GitHub Copilot. Useful when project guidance must persist across VS Code contexts. CX Codex +1 9,248installs remember Yeachan-Heo remember is a Claude Code skill that sorts session knowledge into the right place. It activates when useful findings need to be preserved or organized. CX Codex +1 695installs remember Alireza Rezvani remember saves key debugging findings and team conventions directly into project auto-memory. Useful when critical context must persist across Claude Code sessions. CX Codex +1 1,661installs remember mem0ai When you tell the agent to remember something, this skill makes it restate the fact clearly so Mem0 can save it for later sessions in the repository. CX Codex +1 161installs deep-agents-orchestration langchain-ai deep-agents-orchestration guides setup of orchestration in Deep Agents: subagent delegation, todo planning, and human approval interrupts. CX Codex +1 17,100installs deepagents-python-quickstart langchain-ai deepagents-python-quickstart scaffolds a minimal Deep Agent in Python from the live LangChain quickstart: asks for a model, keeps work in a fresh folder, swaps Tavily for provider-native search. CX Codex +1 5,900installs deepagents-setup-configuration soba-labs The deepagents-setup-configuration Claude Code skill scaffolds and checks Deep Agents projects in Python or JavaScript. It helps configure subagents, persistence, and human approval. CX Codex +1 ★ 106repo stars groove-utilities-memory-graduate andreadellacorte groove-utilities-memory-graduate promotes a stable workflow insight from .groove/memory/learned/ into AGENTS.md, so the rule applies to every future session without running prime. CX Codex +1 511installs claude-migrate-memory-to-doc daymade The claude-migrate-memory-to-doc skill exports Claude Code's private per-project memory into tool-agnostic documents so Codex, Cursor, and other AI editors read the same user profile and preferences. CX Codex +1 388installs

Project sponsors

Companies that keep this analytics open