Back to AI News
MarkTechPost

Meta FAIR's Self-Improving Memory Lets Agents Discover and Distill Their Own Memory Prompts

Meta FAIR, with University of Washington and Johns Hopkins researchers, introduced Self-Improving Memory, a two-stage method that has an agent rewrite its LOAD/OFFLOAD memory prompts and then distills the resulting behavior into model weights via LoRA. Using Kimi-K2.6 as both task and meta agent, optimized harnesses averaged 56.0 on three Continual Learning Bench tasks versus 44.6 for the best human-written prompts. After distillation, the model averaged 43.1 with generic prompts versus 37.6 for SFT on generic trajectories, though the research code was not released.

AI Brief

It offers a concrete recipe and benchmark evidence for turning agent-discovered memory strategies into model weights, useful for researchers building long-horizon agents.

Meta FAIR has introduced Self-Improving Memory, a method for AI agents that manage their own memory. The model first discovers its own memory instructions. It then trains those skills into its weights. Co-authors include researchers from the University of Washington and Johns Hopkins University.

TL;DR

  • Method: The base is Kimi-K2.6, a 1T-parameter MoE with 32B active and 256K context. Distillation adds a LoRA adapter (rank 64) on attention projections.
  • Runs on: Training hardware is not disclosed. Kimi-K2.6 serving needs a multi-GPU node; Vast.ai recommends 8x H200. Native INT4 weights exist.
  • Performance: Self-found memory prompts average 56.0 on 3 tasks, versus 44.6 for the best human-written ones.
  • Best: Codebase, 64.3 with optimized prompts, +20.6 over the best hand-written harness.
  • Worst: Spectrum distillation adds only 2.9 points (46.5 vs 43.6 for SFT on generic runs).

What is Self-Improving Memory?

Self-Improving Memory is a 2-stage method from Meta FAIR that teaches an agent model to manage file-based memory. The agent works through a stream of subtasks. Each subtask starts with an empty context. Only a persistent memory directory, edited with file tools, carries over.

Two prompts control that memory. OFFLOAD updates memory after a subtask. LOAD retrieves notes before the next one. Generic versions leave the strategy to the model. A pilot study in the research post found that no single hand-written strategy wins every task.

How does harness optimization work?

In stage 1, a meta agent rewrites the LOAD and OFFLOAD prompts. The search starts from 4 human-written seeds: Summary, Retrieval, Skill and Hypothesis. Each candidate runs the full task stream 5 times. The top 4 by mean score become parents for revision.

For each parent, the meta agent reads trajectories, scores and final memory directories. It then proposes revised prompts. Selection uses a holdout set the meta agent cannot see.

The discovered prompts are concrete. One Database prompt says to read GUARDRAILS.md, then SCHEMA.md, before answering. The best Codebase design uses a quickstart file, an indexed fix registry and separate fix files.

How does harness distillation move the gains into weights?

Stage 2 follows a Discover-Demonstrate-Distill pipeline. The task agent runs train subtasks with the optimized prompts. Every model call is logged. The research team then swaps the optimized prompts back to the generic ones in that history.

The swap works because the behavior stays valid under generic instructions. Examples include keeping QUICKSTART.md, REGISTRY.md and SCHEMA.md files, and verifying join keys before aggregation. The model is fine-tuned with LoRA, rank 64, on attention projection layers. The loss covers only assistant tokens, including reasoning and tool calls. Each task gets equal weight.

The meta agent and task agent are the same Kimi-K2.6 model. So the model is trained on memory skills it discovered itself.

What do the benchmarks show?

The tests use 3 Continual Learning Bench tasks: Database (SQL), Codebase (repo fixes) and Spectrum (radio scans). Test subtasks follow a designed phase shift. So results measure generalization to new instances of the same tasks.

Test scoreDatabaseCodebaseSpectrumAverage
No memory7.531.821.920.4
Compaction39.836.934.637.1
Generic harness32.333.542.536.1
Best human-written47.943.742.144.6
Optimized harness53.864.349.956.0
SFT on generic trajectories31.637.543.637.6
SFT on optimized trajectories (generic prompts)37.745.146.543.1

Source: Figures 4 and 5, Self-Improving Memory blog. Kimi-K2.6 for all rows.

Optimized harnesses beat the best hand-written seed on all 3 tasks. Codebase gained the most, at 20.6 points. Search was noisy: 37 of 44 generated revisions failed to beat the previous best. Database and Spectrum peaked in the first generation. Codebase kept improving through generation 4.

After distillation, every model runs the generic harness. The distilled model averages 43.1 across 10 matched seeds. SFT on generic trajectories reaches 37.6. That is a 5.5-point gain, or 14.6%.

Meta FAIR · Self-Improving Memory

How Kimi-K2.6 learns its own memory skills

Discover memory prompts, demonstrate them, then distill them into the weights. All numbers are test scores on 3 Continual Learning Bench tasks.

Each subtask starts with an empty context. Only a memory directory carries over. Step through the pipeline, or click any stage.

00
Generic harness
LOAD + OFFLOAD prompts, file tools
01
Discover
Meta agent rewrites the prompts
02
Demonstrate
Run optimized, swap to generic
03
Distill
LoRA fine-tune on the runs
Step 1 of 4
Generic prompts
Click to reveal
LOAD Read your memory directory.
OFFLOAD Update it. What to keep is your decision.
Optimized prompts (Database, Fig. 1)
Click to reveal
LOAD Read GUARDRAILS.md, then SCHEMA.md. Before answering, check price unit and timestamp type; target 5 or fewer queries.
OFFLOAD Record each group's price unit and timestamp format (CONFIRMED/UNTESTED); log failures as IF/THEN rules.

Harness optimization: the meta agent's best prompts vs baselines. Pick a task.

Best human-written is the best of 4 seeds (Summary, Retrieval, Skill, Hypothesis) per task. Scores are the best observed candidates, selected by task score.

Harness distillation: every model below runs the generic prompts. Only the training data differs.

LoRA rank 64 on attention projection layers. Loss on assistant tokens only. Averages over 10 matched evaluation seeds.

0of 44 meta-agent revisions failed to beat the prior best
Gen 1Database (53.8) and Spectrum (49.9) peaked here
Gen 4Codebase kept climbing, to 64.3

Codebase case study: click each revision to see what the trajectory report found.

Generic harness33.5
The baseline. Strategy is left to the model.
Summary seed34.3
Report: notes grow into monolithic files, and the agent re-discovers the repository each time. The best seed scores 43.7.
Revision 152.2
Reuses recorded paths and keeps failure rules.
Revision 255.7
Report: append-only file with no index from symptoms to fixes. Fix: compact quickstart, indexed registry, separate fix files.
Alternative revision36.6
Keeps details of only the last 2 fixes. Most revisions fail like this, so evaluation and selection matter.
Source: Meta FAIR, Self-Improving Memory blog (Figures 1, 4 to 7)Built by Marktechpost

How does it compare with ALMA, MemEvolve and Harness-Zero?

Several recent methods search over agent memory or harnesses. Self-Improving Memory searches memory prompts, then distills them into weights. Benchmarks differ, so headline numbers are not directly comparable.

FeatureSelf-Improving MemoryALMAMemEvolveHarness-Zero
OrgFAIR at Meta, UW, JHUXiong, Hu, CluneOPPO AI Agent Team, LV-NUSPeking University, Google, HKUST
What is searchedLOAD/OFFLOAD memory promptsMemory designs as Python codeMemory architecture and contentsFull agent harness
Trains weightsYes, LoRA rank 64NoNoYes, LoRA SFT
ModelsKimi-K2.6 (agent and meta agent)GPT-5 meta agent, GPT-5-nano/mini task agentGPT-5-mini (plus DeepSeek V3.2, Kimi K2)Qwen3.5-9B student
BenchmarksContinual Learning Bench (3 tasks)ALFWorld, TextWorld, Baba Is AI, MiniHackGAIA, WebWalkerQA, xBench-DeepSearch, TaskCraftSpreadsheetBench Verified, AppWorld, USPTO Retrosynthesis
Headline result56.0 vs 44.6 best human harness; 43.1 distilled53.9% vs 41.1% no memory (GPT-5-mini)Up to 17.06% gains23.3% to 44.3% with harness removed
CodeNot releasedGitHubGitHubGitHub

Harness-Zero is the closest match, but it uses a separate agent to correct the student. Self-Improving Memory skips that step.

Key Takeaways

  • Kimi-K2.6 writes memory prompts that beat human ones: 56.0 vs 44.6.
  • Codebase sees the biggest jump: 64.3, up 20.6 points.
  • Distillation keeps part of the gain: 43.1 vs 37.6 with generic prompts.
  • 37 of 44 meta-agent revisions failed, so evaluation and selection matter.


Check out the blog post, the X thread and the Continual Learning Bench paper. You can check the deployment options and specs here through our GPULeaderboard.com chrome extension.

Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well.

Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us

The post Meta FAIR Self-Improving Memory Hits 56.0 on Continual Learning Bench appeared first on MarkTechPost.

Be the first to rate this article.

Comments & Questions (0)

Captcha
Please be respectful — let's keep the conversation friendly.

No comments yet

Be the first to comment!