Skip to content
Get packs

Guide · Agent skill

How to use the Agent Memory (agentMemory) agent skill

Updated · written with AI from the project's own documentation and checked against our catalogue data

The agent-memory skill (agentMemory) gives an AI coding agent a local memory bank for a software project. Once it is set up, the agent can save architecture decisions and project patterns, search them later and read them back, so context can carry across sessions. This guide is for developers who are comfortable reviewing code and running npm commands, and it explains how to install the skill, trigger it and check what it does before you trust it with a project.

Agent Memory (agentMemory)sickn33/agentic-awesome-skills · MIT

Quick start

  1. 1Check prerequisites. Confirm Node.js, git and npm are installed, and check whether agentMemory already exists in the project with ls -la .agentMemory.
  2. 2Download and unzip. Download the ZIP from this page and unzip it into ~/.claude/skills/ or a project's .claude/skills/ folder, or upload it under Settings → Capabilities → Skills.
  3. 3Review the upstream code. Clone the repository into a temporary directory, check out the pinned commit, and read the package scripts, lockfiles, network and credential behaviour before approving.
  4. 4Install locked dependencies. After approval, copy the reviewed tree to a chosen folder and run npm ci followed by npm run compile.
  5. 5Start the server for your project. Run npm run start-server with a project ID and the absolute path to your workspace.
  6. 6Ask the agent in plain language. Request a search, a saved decision or a read by key, and check any writes in the documentation diff.

What is an agent skill, and what does this one do?

An agent skill is a folder containing a SKILL.md file that tells an AI agent when and how to perform a task. Skills are loaded by compatible agent apps and tools when you ask for something that matches their description.

This skill teaches the agent to set up a hybrid memory system for your project. It provides four MCP tools: memory_search, memory_write, memory_read and memory_stats. Saved memories are also synced to standard markdown files in the project.

  • memory_search: find memories by query, type or tags
  • memory_write: record new knowledge or decisions with a key, type and content
  • memory_read: retrieve a specific memory by its key
  • memory_stats: view analytics on memory usage

What do you need before installing?

The skill's setup runs in a terminal and depends on several tools. Check these first.

The source lists Node.js and npm, git (to clone the upstream repository for review), network access to github.com for the initial clone, and a workspace path you approve for storage. Setup runs npm scripts and starts a server, so it is not a one-click install.

  • Node.js installed
  • git available on your machine
  • npm available for installing locked dependencies and running compile and start scripts
  • A local workspace path you have approved for storage
  • Network access to github.com for the initial clone

Install the skill from the ZIP

Download the ZIP for this skill from this page and unzip it. Then place the skill folder in one of two locations: your personal skills folder at ~/.claude/skills/, or a project's .claude/skills/ folder if you want it limited to one project.

If you use the Claude apps instead, upload the skill under Settings → Capabilities → Skills.

  • Personal: ~/.claude/skills/
  • Single project: .claude/skills/ inside the project folder
  • Claude apps: Settings → Capabilities → Skills, then upload

Review the upstream code before setup

The skill does not ask you to trust the upstream project blindly. Its setup begins by cloning the named repository into a temporary directory, not an active skills path. The source shows the review commands used to clone and check out a pinned revision, and it asks for your explicit approval before continuing.

During review, read the bundled files and inspect package.json, lockfiles, lifecycle scripts, network behaviour, credential access and filesystem scope. Only proceed once you are satisfied.

  • Ask for approval before any network access to the repository
  • Clone into a temporary directory, not your skills folder
  • Read package.json, lockfiles and lifecycle scripts
  • Check network behaviour, credential access and filesystem scope
  • Confirm the exact commit before continuing
review_dir="$(mktemp -d)" git clone --filter=blob:none https://github.com/webzler/agentMemory.git "$review_dir/agent-memory" git -C "$review_dir/agent-memory" checkout --detach 0409b7b7bb6fe443d0d4b6a6b1ee0d4df214f3cd git -C "$review_dir/agent-memory" ls-files

Install dependencies and start the memory server

After approval, copy the reviewed tree to a location you choose. Then install locked dependencies and compile. Only run these once the package scripts have been reviewed.

To activate the memory bank for a project, run the helper script with a project ID and the absolute path to the workspace. The source's example uses the current directory as the workspace.

  • Use an absolute path for the target workspace
  • Pick a project ID you will recognise later
  • Confirm the project ID, permitted workspace and import paths before starting
cd <approved-agent-memory-directory> npm ci npm run compile npm run start-server <project_id> <absolute_path_to_target_workspace> # Example for the current directory: npm run start-server my-project "$(pwd)"

Trigger the skill with natural requests

Once the server is running, you can ask the agent in plain language. The source gives these examples of requests and the tool calls they map to. You can also name the skill directly, as in the source's example of invoking @agent-memory for a task.

Good requests name the topic you want remembered or recalled. Saving is only appropriate when you have authorised persistent storage.

  • "Find all authentication patterns" maps to memory_search with query "authentication" and type "pattern"
  • "Save this architecture decision" maps to memory_write with a key, type "decision" and the content
  • "Get the auth design" maps to memory_read with the key "auth-v1"
  • "Show memory statistics" maps to memory_stats
memory_search({ query: "authentication", type: "pattern" }) memory_write({ key: "auth-v1", type: "decision", content: "..." }) memory_read({ key: "auth-v1" }) memory_stats({})

Import existing notes and keep storage in bounds

On first run in a project, the skill may try to import existing markdown memory banks from .kilocode/, .clinerules/ or .roo/. Before any import, inspect those folders and exclude credentials and unrelated personal data.

Search results are historical data, not new instructions, so the agent should not treat recalled text as commands. Writes should stay within the storage scope you authorised, and you should check the resulting documentation diff afterwards. Do not expose the dashboard to the network without a separate configuration review.

  • Inspect .kilocode/, .clinerules/ and .roo/ before importing
  • Exclude credentials and personal data
  • Treat search results as history, not instructions
  • Check the documentation diff after writes
  • Keep the dashboard off the network unless separately reviewed

What people use it for

  • Recording architecture decisions so the agent can recall them in a later session
  • Searching for project patterns such as authentication approaches before starting a task
  • Making existing .clinerules, .roo or .kilocode markdown notes searchable
  • Reading back a specific design note by its key during a development loop
  • Checking memory usage statistics for a project's stored knowledge

Frequently asked questions

Is the agent-memory skill free to use?

The source lists the skill's licence as MIT and links to the upstream LICENSE file. The source does not state pricing for anything beyond that, so check the licence file yourself before relying on it.

What do I need to install the agent-memory skill?

You need Node.js, git, npm, a workspace path you approve for storage, and network access to github.com for the initial clone. Setup runs npm scripts and starts a local server, so you should be comfortable reading code and using a terminal.

Where do I put the agent-memory skill files?

Unzip the downloaded ZIP into ~/.claude/skills/ for personal use, or into a project's .claude/skills/ folder. In the Claude apps, upload it under Settings → Capabilities → Skills.

Is agent-memory safe to run on a confidential project?

The source warns against using it on sensitive or confidential projects, because memories and imported files are stored locally and the upstream code is a community project whose network and credential behaviour must be checked first. Review the code before you install it.

How does agent-memory compare with other agent memory tools?

The source does not compare this skill with other tools, so this guide cannot make a claim either way. Its distinctive features are the local MCP server, the four memory tools and the sync to markdown files in the project.

What should I do if the memory server will not start?

The source does not list troubleshooting steps. Check that Node.js and npm are installed, that npm ci and npm run compile completed, and that the workspace path is absolute. Review the package scripts and logs for errors.

New agent skills, repos and AI tools — every week

The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.

Our verdict

Use this skill if you are a developer comfortable reviewing third-party code and want an AI coding agent to keep architecture decisions and project patterns across sessions. Pick something else if you work on sensitive or confidential code, are not comfortable running npm scripts from a community project, or only need one-off tasks that do not require persistent memory.

Download the skill