跳到正文
研踪PaperTrail
← 研踪 PaperTrail
正在查看已观测的 v1。查看最新 v2 →

arXiv:2611.21885 · v1

Language Models Can Rewrite Their Own Weights

首次提交 2026-11-17 04:55
版本更新 2026-11-17 04:55
雷达观测 2026-11-18 19:44
arXiv ↗PDF ↗

摘要

Language models are trained once, frozen and deployed: improving one again takes another training run, and a prompt, a scaffold or extra computation at inference is gone once the task ends. A frontier model has been shown to edit the weights of a much smaller one. We ask whether a model can rewrite its own weights to make itself better, and find that it can, by its own reasoning, with no gradients and no training; we call this self-rewriting. Given its weights, graded answers and the ability to run itself, a 27B model diagnoses its failure and edits the weights behind it. It surpasses itself: its own edit makes it 6.6 points more accurate on 490 problems it never saw, in a test fixed in advance, and another session's edit also makes it significantly better. It keeps getting better: it submits an edit only when its own tests support it, each edit replacing the last, and over its first eight such sessions its accuracy only rises. Unlike test-time scaling, the gain persists in its weights and adds no cost per answer; unlike training, it needs no pre- or post-training infrastructure, only an open model and hours on one GPU. It repairs a damaged copy of itself: it locates the corrupted matrix and rewrites it with values of its own, never reading the undamaged weights; found on text math problems alone, the repair lifts the copy on six image benchmarks it never saw from 7% to 70% accuracy, 83% of the undamaged model's. And the ability emerges with scale: across four sizes of one family, the 2B model makes no edit and the 4B and 9B models break themselves; only the 27B model works on itself as a human would, comparing its hidden states on answers that finish and on answers that run out of tokens, weakening the direction that separates them. Like a human, a model need not separate training from inference; improving a language model may come to take a conversation rather than a training run.

AI 论文解读

基于摘要 · 非全文审阅

此版本尚未生成 AI 解读。解读由后台任务生成并按论文版本保存,登录后共享已有结果。

版本差异

仅对比实际观测的元数据,不代表 PDF 正文或实验变化。版本可能不连续;带删除线为移除,下划线为新增。

摘要变化

LanguageA modelslanguage aremodel is trained once, frozen and deployed:frozen. improvingMaking oneit againbetter takes another training run, andor a prompt, a scaffoldharness or extra computation at inference that is gone once the task ends. A frontierWe modelshow hasa beenthird shownway: to edit the weights of a muchour smallerknowledge one.for Wethe askfirst whethertime, a modellanguage canmodel rewriterewrites its own weights to make itself better, and find that it can, by its own reasoning and becomes better, with no gradients and no training;. weWe call this self-rewriting: the model is its own optimizer. GivenIn earlier work, a frontier model edited a much smaller one; here an open 27B model, given its weights, its graded answers and the ability to run itself, a 27B model diagnoses its own failure and editsrewrites the weights behind it. It surpasses itself: its own edit makes it 6.6 points more accurate on 490 problems it never saw, in a test fixed in advance, and another session's edit also makes it significantly better. It keeps getting better: it submitstests anits editedits onlyon whenpractice itsproblems ownand testssubmits supportonly itwhat works, each edit replacingimproving on the last, and over its first eight suchconsecutive sessions its accuracy only rises. Unlike test-time scaling,It therepairs gaina persistsdamaged incopy itsof weightsitself, andlike addsa nobroken costrobot perthat answer;fixes unlikeitself training,without itbeing needsrebuilt: nothe pre-copy orsolves post-trainingalmost infrastructurenothing, onlyyet anwith openno modelretraining and hours on onewithout GPU.ever Itreading repairsthe aoriginal damagedweights, copythe ofmodel itself:brings it locatesback theto corruptedover matrix80% andof rewritesthe itoriginal withaccuracy valueson ofimage itstasks own,it never readingsaw. And the undamagedability weights;emerges foundwith onscale: textin mathone problemsmodel alonefamily, the repair lifts the copy on six image benchmarks itsmaller nevermodels sawmake fromno 7%edit toor 70%break accuracythemselves, 83%and ofonly the undamagedlargest model's.improves Andand therepairs abilityitself. emergesUnlike withtest-time scale:scaling, acrossself-rewriting fourwrites sizesits ofgain oneinto familythe weights, theat 2Bno modelcost makesper noanswer; editunlike andtraining, theit 4Bruns andonly 9Bforward modelspasses, breakas themselves;serving onlydoes. theThe 27Bwall modelbetween workstraining onand itselfinference asis a humanlimit would,of comparingour itstools, hiddennot statesa onproperty answersof thatintelligence. finishWe andbelieve onself-rewriting answersis thata runnecessary outstep oftoward tokens,recursive weakeningself-improvement: thea directionmodel that separates them., Likelike a human, a model needdoes not separate training from inference; improvingcould akeep languageupgrading itself for life, with no larger model, mayno comeharness toor takeprompt aengineering, conversationand ratherno thanpre- aor post-training run.

观测到的版本

相邻记录可能跳过中间版本;首次发现 v2 及以上也会标为版本更新。

v2 · 2026-11-18 16:57 · 最新观测版本

Language Models Can Rewrite Their Own Weights

A language model is trained once and frozen. Making it better takes another training run, or a prompt, a harness or extra computation at inference that is gone once the task ends. We show a third way: to our knowledge for the first time, a language model rewrites its own weights by its own reasoning and becomes better, with no gradients and no training. We call this self-rewriting: the model is its own optimizer. In earlier work, a frontier model edited a much smaller one; here an open 27B model, given its weights, its graded answers and the ability to run itself, diagnoses its own failure and rewrites the weights behind it. It surpasses itself: its own edit makes it 6.6 points more accurate on problems it never saw. It keeps getting better: it tests its edits on practice problems and submits only what works, each edit improving on the last, and over eight consecutive sessions its accuracy only rises. It repairs a damaged copy of itself, like a broken robot that fixes itself without being rebuilt: the copy solves almost nothing, yet with no retraining and without ever reading the original weights, the model brings it back to over 80% of the original accuracy on image tasks it never saw. And the ability emerges with scale: in one model family, the smaller models make no edit or break themselves, and only the largest improves and repairs itself. Unlike test-time scaling, self-rewriting writes its gain into the weights, at no cost per answer; unlike training, it runs only forward passes, as serving does. The wall between training and inference is a limit of our tools, not a property of intelligence. We believe self-rewriting is a necessary step toward recursive self-improvement: a model that, like a human, does not separate training from inference could keep upgrading itself for life, with no larger model, no harness or prompt engineering, and no pre- or post-training.

查看此版本解读 →查看此版本原文 ↗
v1 · 2026-11-17 04:55

Language Models Can Rewrite Their Own Weights

Language models are trained once, frozen and deployed: improving one again takes another training run, and a prompt, a scaffold or extra computation at inference is gone once the task ends. A frontier model has been shown to edit the weights of a much smaller one. We ask whether a model can rewrite its own weights to make itself better, and find that it can, by its own reasoning, with no gradients and no training; we call this self-rewriting. Given its weights, graded answers and the ability to run itself, a 27B model diagnoses its failure and edits the weights behind it. It surpasses itself: its own edit makes it 6.6 points more accurate on 490 problems it never saw, in a test fixed in advance, and another session's edit also makes it significantly better. It keeps getting better: it submits an edit only when its own tests support it, each edit replacing the last, and over its first eight such sessions its accuracy only rises. Unlike test-time scaling, the gain persists in its weights and adds no cost per answer; unlike training, it needs no pre- or post-training infrastructure, only an open model and hours on one GPU. It repairs a damaged copy of itself: it locates the corrupted matrix and rewrites it with values of its own, never reading the undamaged weights; found on text math problems alone, the repair lifts the copy on six image benchmarks it never saw from 7% to 70% accuracy, 83% of the undamaged model's. And the ability emerges with scale: across four sizes of one family, the 2B model makes no edit and the 4B and 9B models break themselves; only the 27B model works on itself as a human would, comparing its hidden states on answers that finish and on answers that run out of tokens, weakening the direction that separates them. Like a human, a model need not separate training from inference; improving a language model may come to take a conversation rather than a training run.

查看此版本解读 →查看此版本原文 ↗