# Test-time memory evolution beats test-time training on math tasks

> A UC Santa Barbara and UC Berkeley paper has a frozen model keep notes instead of retraining, and reports better scores on five math problems with up to 84.6% less compute.

URL: https://claudegpt.si/news/ttme-test-time-memory-evolution  
Published: 2026-10-31T10:50:32.454Z  
Author: ClaudeGPT Si Newsroom  
Section: Research  
Topics: Research, Test-time training, Agent memory, Qwen, AI agents  
Publisher: ClaudeGPT Si

## Key takeaways

- TTME keeps model weights fixed and stores lessons and strategies in an external memory, instead of training the model during the search.
- It scored better than test-time training on all five math tasks tested, against training results copied from the original papers.
- Under TTT-Discover with Qwen3-8B, it cut runtime by 47.7% to 58.4% and compute by 82.8% to 84.6%.

Researchers at UC Santa Barbara and UC Berkeley have a cheaper way to get the same kind of gains that [test-time training](https://arxiv.org/abs/2610.32046) gives AI models on hard math problems. Their method, Test-Time Memory Evolution (TTME), keeps the model frozen and lets it take notes on what worked. In the paper's tests it beat test-time training on all five math tasks, using about 84% less compute on the tasks where that was measured.

The paper, posted on arXiv on October 23, 2026, had 133 upvotes on Hugging Face daily papers. It matters because it asks whether the expensive part of a recent technique is needed at all.

## The problem: search that learns as it goes

Some recent systems try to discover new math by search. A language model writes a program, a verifier scores what the program produces, and the best programs are used as starting points for the next round. AlphaEvolve works this way, with large proprietary models.

Two newer frameworks, TTT-Discover and ThetaEvolve, add a twist. While the search runs, they train the model on its own attempts using reinforcement learning, which rewards the attempts that scored well. That is test-time training: the model's weights change during the task. The papers behind those frameworks report that this lets small open-weight models beat systems built on frontier models.

The cost is that you are training a model the whole time the search runs. The authors say this makes the approach hard to scale to larger models.

## What TTME does instead

TTME leaves the weights alone. After every few search steps, the same model reads the results and writes two kinds of notes into an external memory.

- **Guideline memory** holds practical lessons about writing code that runs and gets scored: when a lesson applies, what went wrong or right, and what to do. Lessons that keep recurring are kept, stale ones are dropped, and the list has a size limit.
- **Strategy memory** holds algorithmic ideas. The model looks at cases where a changed program scored better than its parent, extracts the idea behind the change, and groups similar ideas into a strategy entry.

When it is time to write new candidates, the model picks strategies that might help a given parent program and rewrites them as specific instructions for that program. Part of each parent's candidate budget is still spent with no instruction, to keep exploring. The authors used the same model for generation and for all the note-taking.

Everything else is unchanged. Each framework keeps its own rules for choosing parents and updating its archive, and its own verifier. Only the training step is swapped for memory.

## The results

The team tested five math construction tasks: Erdős's minimum overlap problem, three autocorrelation inequalities (AC1, AC2, AC3) and a maximal determinant problem. They used Qwen3-8B and gpt-oss-120b with TTT-Discover, and DeepSeek-R1-0528-Qwen3-8B with ThetaEvolve. The test-time training numbers are copied from the original papers, not rerun.

TTME gave a better final score than test-time training in every setting the paper reports. A few examples:

| Task (framework, model) | Better is | No TTT | Test-time training | TTME |
| --- | --- | --- | --- | --- |
| AC2 (TTT-Discover, gpt-oss-120b) | Higher | 0.953682 | 0.9591 | 0.960784 |
| AC1 (TTT-Discover, Qwen3-8B) | Lower | 1.505242 | 1.50525 | 1.504329 |
| AC3 (ThetaEvolve, Distill-Qwen3-8B) | Lower | 1.519277 | 1.4930 | 1.464224 |

Some gaps are tiny. On Erdős with Qwen3-8B, TTME scored 0.380927 against 0.380932 for training. These are record-chasing problems where improvements are small by nature, so the AC3 gap is the clearest win.

## Cost: less time and far less compute

The cost comparison covers only TTT-Discover with Qwen3-8B, on three tasks. Excluding the time spent running the verifier, TTME cut runtime by 47.7% to 58.4%. It cut compute by 82.8% to 84.6%. On AC1, for example, training used 29.47 exaFLOPs and TTME used 4.53. The memory-note calls to the model are included in TTME's count.

Under TTT-Discover, TTME passed the final test-time-training score within 25 steps on all three tasks and both models.

## What the ablations show

- Training and memory did not stack. On AC2 and Erdős, adding test-time training on top of TTME scored worse than TTME alone.
- Both memories matter. With gpt-oss-120b, removing either one gave worse scores on AC1, AC2 and Erdős than the full system, though on Erdős the gaps are in the sixth decimal place.
- Memory helped the search combine ideas. TTME more often picked a child program that merged an idea from another branch as the next parent: 24.7% of the time on AC2 versus 18.6% for training, and 10.2% versus 8.2% on AC1.

## Limits

The scope is narrow. All five tasks are math constructions that a program can check automatically, so the method may not carry over to problems without a clean score. The training baselines come from published papers rather than a new run under identical conditions, although the authors say they kept each framework's settings. The cost analysis covers one model and one framework. And the paper does not claim memory beats training in general. Its own wording is "in the evaluated discovery settings."

## Why it matters

Training a model during a task is heavy machinery. If a notebook the model writes for itself gets better results on this kind of problem, with a fraction of the compute, teams building search-and-verify agents have a cheaper thing to try first. It also fits a wider pattern of agents that improve through memory rather than retraining. Whether it holds on problems with noisier feedback is the open question.

The code is on [GitHub](https://github.com/yepengliu/TTME). The paper is [Can Test-Time Memory Evolution Outperform Test-Time Training for Scientific Discovery?](https://arxiv.org/abs/2610.32046)

## Frequently asked questions

### What is test-time training?

It means updating a model's weights while it works on a task, here with reinforcement learning on its own scored attempts. The frameworks in this paper, TTT-Discover and ThetaEvolve, use it to guide math search.

### What is test-time memory evolution?

TTME is a method that leaves the model frozen and keeps an external memory of implementation lessons and algorithmic strategies. The memory is updated from search results and put in the prompt for later attempts.

### Is TTME code available?

Yes. The authors released their code at github.com/yepengliu/TTME.

### Does TTME work outside math?

The paper does not test that. All five tasks are math constructions with an automatic verifier, so results on other problems are unknown.

## Sources

- [Can Test-Time Memory Evolution Outperform Test-Time Training for Scientific Discovery?](https://arxiv.org/abs/2610.32046), arXiv
- [Can Test-Time Memory Evolution Outperform Test-Time Training for Scientific Discovery? (full text)](https://arxiv.org/html/2610.32046), arXiv
- [TTME code repository](https://github.com/yepengliu/TTME), GitHub
- [Hugging Face daily papers](https://huggingface.co/papers), Hugging Face