MemSkill: learning how to remember instead of hard coding memory operations

What MemSkill replaces and what it leaves alone

MemSkill is a framework for learning and evolving memory skills for long-horizon agents. The claim in the project description is that it replaces static, hand designed memory operations with a data driven loop where skills are learned, refined and reused from task feedback, enabling more adaptive memory construction across settings.

The framing matters because most agent memory systems work by having an engineer decide, in advance, what to extract from a conversation, how to chunk it, what to consolidate and what to drop. Those decisions are baked into prompts and pipelines, and they do not improve as the agent sees more data. MemSkill's bet is that the procedure of remembering is itself learnable, and that a procedure learned once transfers.

The five highlights describe the mechanism. Skill-conditioned memory construction composes a small set of relevant skills for each span and constructs memories in one pass. Skill evolution from hard cases periodically mines challenging examples to refine existing skills and propose new ones. A reusable skill bank maintains a shared, evolving collection of skills that supports transfer across datasets and base models. High-throughput evaluation uses multi-API-key round robin for stable parallel calls. And scalable training and runs come from multi-threading and multi-processing.

The audience is research teams working on long-horizon agent memory. The project was accepted by NeurIPS 2026, the paper is on arXiv as 2602.02474, and there is a project page, a DeepWiki entry and a Hugging Face collection holding the released controller weights.

Meta-memory, not the memories themselves

There is one distinction in the overview that decides whether the project makes sense to you, and it is stated in capitals because it is the most common misreading.

The skills evolved by MemSkill are not experiential or procedural memory, and they are not insights themselves. They are a form of meta-memory, and the overview spells out what that covers: what kinds of memory to extract, how to remember and where to focus, and what to preserve or forget. The reason it is called memory skills is that they capture the way or skill of remembering rather than the remembered content.

So a skill is not a fact about the user's preferences and not a procedure the agent should execute. It is a rule about how to build memory in a particular situation, learned from feedback.

That distinction is what makes transfer possible. If a skill were a fact, it would only apply to the dataset it was learned on. Because a skill is a way of remembering, a skill learned on one dataset and one base model can be reused on another, which is exactly what the reusable skill bank highlight claims.

It also explains the hard cases mining. A failure is not evidence that a particular memory is wrong, it is evidence that the procedure that produced it was wrong in that situation. Mining failures gives you a training signal for the procedure rather than for the content.

Skill-conditioned construction and the skill bank

The mechanism has two halves that work together.

The first is skill-conditioned memory construction. For each span of input, the system selects a small set of relevant skills and uses them to construct memories in one pass. The selection is what makes the cost bounded: you are not running every possible memory operation against every span, you are composing a few of them per span.

The second is the skill bank, which is where the learning accumulates. It is described as a shared, evolving skill bank that supports transfer across datasets and base models, and the tree confirms there is a skills/ directory at the top level alongside a src/ directory and a prompts/ directory. So the skills are first class artefacts in the repository rather than something buried in code.

The evolution loop closes the circle. The system periodically mines challenging examples to refine existing skills and propose new ones, so a skill that underperforms in a particular kind of conversation gets adjusted, and a situation that no existing skill covers produces a candidate new skill. The rolling failure-case pool named in the checkpoint recovery notes is the visible implementation of that.

The released controller weights in the Hugging Face collection are what makes this usable without training from scratch, and the project is direct about the caveat: differences in experimental environments and settings may require some adaptation, and it recommends retraining and tuning key hyperparameters on a held-out validation split, especially chunk_size and the number of selected skills during inference, action_top_k.

Installing it and what the repository actually contains

The installation section in the documentation starts with a clone and a virtual environment:

# Clone the repository
git clone https://github.com/ViktorAxelsen/MemSkill
cd MemSkill

# Create and activate virtual enviro

The Python dependencies are pinned loosely in a requirements.txt, grouped by purpose:

# Core ML / utilities
numpy
tqdm
nltk
sentence-transformers
transformers
openai
tiktoken
json-repair
regex
wandb
scikit-learn

# Retrieval (optional, used if available)
faiss-cpu
langchain-community
langchain-core

The grouping tells you a lot. The core block is the model stack, with sentence-transformers and transformers for embeddings and generation, openai for the API calls, tiktoken for tokenisation, json-repair for parsing model output, wandb for experiment tracking, and scikit-learn. The retrieval block is marked optional and used if available, which is how the project supports a pluggable retriever rather than hard coding one.

The interactive environments and datasets block covers textworld, alfworld, gymnasium, gym and minigrid.

The top level layout shows the experiment matrix. There are train_locomo.sh and train_alfworld.sh, and matching eval_locomo.sh, eval_alfworld.sh, eval_hp.sh and eval_longmemeval.sh. The Python entry points are main.py, alfworld_replay.py, eval_utils.py, llm_utils.py and rag_utils.py, and there is a data/ directory, a docs/ directory and a LICENSE file.

The training and evaluation surface is a set of flags

The news entries document what has changed, and the changes are all about the mechanics of running the system rather than about the idea.

The most recent substantive addition is --locomo-train-query-sampling-ratio, for training-time stratified test-query sampling on LoCoMo. The description is that it reduces evaluation cost during training by sampling LoCoMo test queries by category, while leaving the full evaluation protocol unchanged for eval-only runs and formal testing. That separation is the right design, because a training loop wants a cheap signal and a reported result wants the full protocol.

Interrupted training recovery arrived as --load-checkpoint, which restores key training state such as the controller and optimizer, the operation bank, the designer state including the rolling failure-case pool, and other resume critical metadata. The limitation is precise: recovery is supported only from checkpoints saved at outer-epoch boundaries. By default a resumed run continues logging to the original W&B run, and --resume-new-wandb-run gives you a fresh one instead.

Parallel memory extraction was improved for evaluation and cache building, with --inference-workers controlling concurrency at the sample level and --inference-session-workers controlling it within each sample at the chunk and span level. Two levels of parallelism matter here, because a single sample is itself split into spans.

The theme across all three is that a long training run is expensive and interruption is normal, so the framework has to be resumable and cheap to evaluate while it trains.

Where MemSkill is the wrong choice

The first limit is that this is a research framework, not a library with a stability promise. The package is Apache-2.0 licensed and the repository is not archived, with the last push on 2026-10-01, but there are no GitHub releases, so there is no version stream to depend on. The scripts are shell scripts that call a Python entry point, and the configuration is by command line flag rather than by a documented configuration file.

The second is the released weights. The project says the controller weights can now be used directly for inference on suitable datasets, and immediately qualifies that differences in experimental environments and settings may require adaptation, recommending retraining and tuning of chunk_size and action_top_k on a held-out validation split. If you need a memory subsystem whose behaviour you can specify precisely, the recommendation to retune it is a signal that it does not have that shape yet.

The third is the infrastructure assumption. The dependency list includes openai, and the high-throughput evaluation highlight is built around multi-API-key round robin, so the design assumes you have API access and keys to spend. The wandb dependency means the training loop expects an experiment tracking account as well. A team that has to run everything against a local model, or that has no budget for API calls at evaluation time, is outside the shape of this project.

The fourth is the domain. The shipped experiments are on LoCoMo, ALFWorld, LongMemEval and a dataset referenced as hp, all of which are long-horizon conversational or embodied benchmarks. The method is presented as general, but the shipped evidence is not.

Compare that with a hand written memory pipeline. The difference in approach is that a hand written pipeline gives you a memory system you can read, debug and predict, and MemSkill gives you one that improves with data. If the requirement is a memory system that behaves the same way next month, the hand written version is the safer engineering choice, and MemSkill is the research direction to evaluate if the behaviour has to adapt to many task types.

Licence, release status and how to read the project

MemSkill is released under the Apache-2.0 licence, with a LICENSE file at the repository root and the licence badge in the documentation. The Apache 2.0 terms permit use and modification including in commercial work, provided the copyright notice and licence text are kept with copies, and they include a patent grant. For a research artefact that other teams are expected to build on and retune, that is a sensible choice, and you should read the LICENSE file yourself for the exact terms.

The release status is best described through the paper record rather than through tags. The project was released in 2026-02, was featured as the Hugging Face paper of the day in 2026-02, was accepted by NeurIPS 2026 in 2026-09, and the repository publishes no GitHub releases. The last push was on 2026-10-01, so the tree is a few weeks old relative to today.

The documentation is organised as a project page, a DeepWiki entry, an arXiv paper, a Hugging Face paper page and a Hugging Face collection, and the README links to the commonly used configs section for the flags, which is where the operational detail lives. The repository also has a docs/ directory and a CHANGELOG-style news list in the README itself.

What to do first is narrow and cheap. Run one of the shipped evaluation scripts, for example eval_locomo.sh or eval_longmemeval.sh, and see the output for yourself. Then, if you intend to use the released controller weights, follow the project's own advice and tune chunk_size and action_top_k on a held-out split before you draw any conclusion, and keep the full evaluation protocol separate from anything you used during training.

Editorial conclusion

MemSkill fits a research team building long-horizon agents whose memory behaviour currently depends on hand written extraction and consolidation rules, and who want that behaviour learned from task feedback instead. It does not fit a production service that needs predictable memory semantics this month, because the controller weights are released with a warning that they may need adaptation and retuning, and the training pipeline assumes API access and W&B logging. Before building on it, reproduce one of the shipped evaluation scripts on a dataset you already know, retune chunk_size and action_top_k on a held-out split as the project recommends, and read the evaluation protocol before comparing any of your numbers with the paper's.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. README
4. ViktorAxelsen/MemSkill on GitHub