Rainman retweeted
It’s a hot week for looped Transformers. For example, @Princeton and the University of Pennsylvania proposed an elegant architecture.
Their new Recurrent Looped Transformer (RLT) lets a Transformer carry forward a running state, updating it after each token.
Why is it interesting?
→ A longer sequence creates a longer chain of computation, and RLT doesn't need more layers per token for this.
▪️ RLT's workflow looks like this:
Its distinctive feature is how it separates reading the input from updating that state.
The job is divided into 2 parts:
1. A causal encoder builds input memory
It processes known prompt tokens in parallel and creates cached keys and values shared across decoder layers.
2. A recurrent decoder updates the running state.
It combines the current encoder output with the previous decoder output, attends to recent activations and shared encoder memory, then passes the updated state forward.
On sequences longer than those used in training, RLT reached:
- 100% on parity at 256 bits, after training on at most 40.
- 97% on swap tracking at eight times the training length vs. under 1% for stan
- Up to 93% on modular arithmetic, vs. 33%.
And one interesting detail: different tasks preferred different layer splits. How much computation goes into reading vs. updating may matter as much as the total depth.
Rainman retweeted
Recommended paper from Sakana AI on recursive self-improvement.
They propose an interesting way to scale recursive self-improvement through multi-agent self-supervision.
In this line of research, self-improvement loops usually need an external verifier, so open-ended tasks without a checker are left out.
MASS removes that requirement.
One base model proposes multi-agent workflows, runs them and grades them, and an evolutionary search keeps the workflows that score best. The model is then fine-tuned on its own traces, and the improved model starts the next cycle as a better optimizer and grader.
Two cycles on Qwen3.6-27B raise performance per output token from 1.2 to 1.6x on four open-ended benchmarks.
A student trained on multi-agent traces also beats a single-agent student trained on 1.4x more tokens.
Paper: arxiv.org/abs/2610.12176
Chat with Paper: academy.dair.ai/papers/recur…
Rainman retweeted
Stanford's "CS25: Transformers United"
by Chris Manning, Steven Feng, et al.
Guest lectures from Hinton, Karpathy & researchers at OpenAI, DeepMind, Anthropic on Transformers and LLMs.
Course website: web.stanford.edu/class/cs25/
Videos: youtube.com/playlist?list=PL…
Rainman retweeted
To a large extent, our new open-sourced book ma-lab-berkeley.github.io/de…, subtitle of which is "A Mathematical Theory of Memory," is an attempt to provide a theoretical framework that explains the connection between Intelligence and Memory.
Intelligence must draw on memory. The mind must not simply compile data — as an algorithm now does more quickly than we can — but recall lived experiences, which contain depths of meaning that only the human soul can recognize, and connect more deeply with the goodness of these experiences. Everything that is good begins “with the Spirit” and thus possesses a breath, a dynamism and a sense of communion that, once experienced, are engraved upon the heart. vatican.va/content/leo-xiv/e…
Rainman retweeted
Banger paper from Meta Superintelligence Labs on self-improving agents.
(bookmark it)
It's hard to know exactly what drives self-improvement, since so many variables are at play (notes, skills, tool calls between runs, etc.).
Meta researchers explore and discuss a way to measure whether self-improvement pays off.
They call it agent plasticity. It is the gain on held-out tasks per dollar spent on learning, with model weights frozen and every run starting from a fresh context.
They find that the model that performs the best is often a different model from the one that learns most efficiently.
In chess, Go, and Hex, Claude Fable 5 reaches the highest final score, while GPT-5.6 Sol gains the most per dollar.
In NetHack, only Claude Opus 5.5 improves significantly, by 66 normalized points for about $1,073 of learning.
Another interesting finding is that slow learners often ignore artifacts they already wrote. Faster learners reuse their artifacts and still fail when an artifact is low quality.
Paper: arxiv.org/abs/2610.08902
Chat with Paper: academy.dair.ai/papers/agent…
Rainman retweeted
Great Paper from NVIDIA.
We’ve spent the last couple of years treating RAG and long context as two completely separate engineering headaches.
One is an external pipeline of bi-encoders and rerankers, the other is an expensive brute-force attention problem.
This paper makes a super compelling case that this split is mostly artificial.
Instead of bolting on external retrievers, they tap straight into the frozen LLM’s own internal representations to select evidence across both regimes.
The wild part is that the backbone stays completely frozen.
They only add around 500k trainable parameters.
On a massive 3B-token Wikipedia index, this tiny tweak beats traditional dense and hybrid retriever-reranker stacks across the board (HotpotQA recall jumps from 49% to 73% and 2Wiki leaps from 31% to 60%).
But it also solves the needle-in-a-haystack problem from the other direction.
On long-context benchmarks, using that same internal mechanism to aggressively prune distractors before generation pushes NoLiMA accuracy at 128k context from basically flatlining at 1% up to nearly 25%.
Because it strips out the fluff early, you get a massive drop in FLOPs and time-to-first-token past 32k tokens instead of watching your latency explode.
Great work by Edan Kinderman and the team.
Read the full paper here: arxiv.org/pdf/2610.08463
Rainman retweeted
Imagine showing an AI agent a six-tooth gear and asking it to write a program that reproduces it.
Everything looks good.
Then you change the input: eighteen teeth, please.
That’s where the interesting part begins. The agent has to work out how the output should change—and a program that simply reproduces the example falls apart.
This idea led to one of our two new papers: can the software scientists already use become a source of training exercises for AI agents? 🧪
In SWR, we run existing workflows, reveal some input–output examples, and keep others hidden. The agent reconstructs the behavior; the original software supplies the reference outputs for checking its work.
We built this around 500 workflows, from physical simulation to molecular and earth sciences. Training on verified solutions also improved performance on broader terminal-agent benchmarks.
Existing software becomes a teacher, with exercises that can actually be checked.
📄 Self-Supervised Scaling of Terminal Environments for Scientific Domains
But getting an agent to succeed leaves another problem: how much can it learn from that success?
A successful run can be messy. The agent may have needed reminders, recovery loops, or a carefully designed harness to get across the finish line.
Our second paper, Recursive Self-Rewrite, turns those experiences into fresh practice.
The same Qwen-3.8-27B model extracts a plan, critiques it for leaked answers, and uses the screened guidance to tackle the task again in a clean environment. Verified executions become training data.
Think of it as turning a messy lab notebook into a lesson the student can work through again.
The result surprised us: on Terminal-Bench 2, directly training on successful source trajectories lowered pass@3 from 57.0% to 53.4%. RSR training raised it to 74.2%—with the final model running under a general harness, without the private guidance.
📄 Scaling Trajectories for Complex Tasks through Recursive Self-Rewrite
Together, these papers explore a simple idea: better agent training can start with resources we already have.
Software gives us exercises.
Experience gives us lessons.
The work is making both teachable.
Rainman retweeted
The next frontier would be agents that get smarter as you use them. 🚀 Our new ServeLearnBench puts continual self-improvement to the test—and reveals what’s holding it back.
How well can agents continually self-improve from serving experience? We’re excited to introduce our new benchmark, 𝐒𝐞𝐫𝐯𝐞𝐋𝐞𝐚𝐫𝐧𝐁𝐞𝐧𝐜𝐡:
Real-world deployment is not a one-time test of capability. The knowledge agents need is often hidden and can change over time.
ServeLearnBench tests whether agents can infer, apply, and revise this knowledge from interaction.
Across 5 learning harnesses × 6 models, we find:
1. 𝐋𝐚𝐫𝐠𝐞 𝐥𝐞𝐚𝐫𝐧𝐢𝐧𝐠 𝐠𝐚𝐩𝐬 𝐫𝐞𝐦𝐚𝐢𝐧. Agents can solve tasks when the hidden policy is given, but struggle to discover it from experience.
2. 𝐍𝐨 𝐟𝐫𝐞𝐞 𝐥𝐮𝐧𝐜𝐡 𝐟𝐨𝐫 𝐚𝐝𝐚𝐩𝐭𝐚𝐭𝐢𝐨𝐧. Continual learning can be costly—and can even degrade already-correct behavior.
3. 𝐄𝐱𝐩𝐥𝐨𝐫𝐚𝐭𝐢𝐨𝐧 𝐢𝐬 𝐚 𝐤𝐞𝐲 𝐛𝐨𝐭𝐭𝐥𝐞𝐧𝐞𝐜𝐤. Better exploration strongly correlates with better adaptation.
Rainman retweeted
LLMs surprisingly store facts at the information-theoretically optimal rate. They do so in their MLP weights. How is this possible?
To answer this question, in our #COLM2026 paper, we show how MLPs can be constructed, without training, to store facts at the information theory optimal rate while remaining usable within transformer blocks for factual recall!
MLPs store facts in language models. Can we write them into Transformers without training?
New work w/ amazing team @garctrob @ronnygjunkins @EyubogluSabri, Atri Rudra & @HazyResearch gives a ✨closed-form✨ recipe for fact-storing, Transformer-ready MLPs. Accepted at COLM 2026!
Rainman retweeted
Researchers made RAG 10x smarter using quantum mechanics.
an independent researcher proposes replacing traditional vector databases with new architecture called "wave-based semantic memory."
his implementation is called “ResonanceDB”
Current vector databases rely on real-valued embedding spaces and cosine similarity to retrieve information..
but because cosine similarity is phase-insensitive, it fundamentally struggles with semantic polarity..
meaning if you search a standard database for "happy," it often conflates contrasts and returns "not happy" or "sad" just because the concepts sit close to each other in the vector space..
this wave-based approach completely rewrites how ai stores and retrieves knowledge..
instead of static vector points, it encodes meaning into complex-valued waveforms..
amplitude controls how salient a concept is, while the phase is used to express structural semantics like negation or epistemic shifts..
to find similar items, it doesn't calculate vector distance..
it uses a "resonance-based retrieval" metric derived entirely from constructive interference..
maximal resonance happens when waveforms align perfectly in-phase, while minimal resonance occurs at anti-phase..
this means the database structurally separates exact opposites like "happy" and "not happy" using pure wave mechanics rather than relying on clunky prompting..
and here is the absolute craziest part..
it doesn't even need a gpu.. the author built resonancedb to run entirely on a standard 12-core intel cpu using a java simd backend..
even without gpu acceleration, the database scales to millions of patterns while maintaining interactive millisecond latency..
Rainman retweeted
This is a great paper from AWS AI Labs.
They show that multi-agent coding teams raised their test pass rate by 28.2% and cut wall time by 16.5% without changing the model.
The authors achieve this by changing how the agents communicate.
In free-form agent teams, shared findings are just context. Agents can ignore them, and the harness never checks whether an implementation still matches the interface the team agreed on.
They introduce AECP, a protocol that requires agents to communicate only through structured artifacts, and the harness acts on them.
It supplies recorded findings when an agent opens relevant code, screens implementations against interface commitments, and makes affected agents revisit an agreement when it changes.
Results hold across Doc2Repo, NL2Repo, and CodeProjectEval with models including Opus-4.8 and DeepSeek-V4-Flash.
There is a security benefit too.
Malicious instructions relayed between agents reach another agent 0% of the time instead of 95%, and get acted on 0% of the time instead of 40%.
Paper: academy.dair.ai/papers/aecp-…
Rainman retweeted
New paper advised by Yann LeCun!
"H-JEPA: End-to-End Learning of Hierarchical World Models for Visual Planning"
Most world models plan in a single latent space and at one timescale, which makes long-horizon planning expensive and forces one representation to handle both low-level motion and high-level goals.
H-JEPA instead stacks JEPA world models across multiple timescales, with higher levels predicting farther into the future.
The highest level first figures out roughly where the agent should go, then each lower level turns that into increasingly concrete subgoals until the bottom level outputs actual actions.
On Visual AntMaze, this 3-level setup increases success from 18% to 73% while using less planner compute.
alphaxiv.org/abs/2610.06805
Rainman retweeted
Handbook on Understanding Harness Engineering for AI Agents [48-page PDF]: drive.google.com/file/d/1PT-…
Rainman retweeted
Great paper from ByteDance Seed on Block-Sparse Attention.
So many papers wave their hands and claim sparse attention scales linearly, but if you look under the hood, the block selection step almost always quietly ruins the party.
Sure, once you identify the top-K blocks, the attention computation itself is cheap.
But deciding which blocks deserve that attention usually means scoring every query against every key block across the sequence.
That leaves you stuck with an O(N^2) bottleneck anyway, which completely defeats the purpose once you push context lengths out to the extreme.
The authors tackle that search problem with a framework they call PISA.
Instead of doing a brute force sweep over every block candidate, they set up a coarse to fine pyramid of keys.
You do an initial, cheap check at the coarsest level using pooled keys, throw out the irrelevant chunks, and only drill down into finer granularities for the candidates that actually scored well.
By bounding the candidate set at each stage across O(\log N) levels, they pull the entire selection and compute cost down to genuine O(N \log N) complexity.
They implemented custom Triton kernels for both training and inference that fuse the hierarchical routing with the LogSumExp scoring, avoiding materializing the big query-key intermediate matrices entirely.
On standard benchmarks it holds parity with dense models, but where it actually shines is retrieval, which makes total sense given the hierarchical search setup.
It feels obvious in hindsight, hierarchical spatial search is an old concept in graphics and classical algorithms, but seeing it executed cleanly in modern attention kernels is really satisfying to read.
Definitely worth a look if you care about efficient long context architectures: arxiv.org/pdf/2609.31093
Rainman retweeted
Banger paper from Microsoft and colleagues.
If you run agents that search a large document collection, this one is worth your time.
(bookmark it)
They introduce CorpusMap, which resolves recurring entities across the collection in advance and gives each entity a page that links to every document that mentions it.
The original documents stay in place.
The agent reads a document, follows an entity to related documents, and avoids searching for the same evidence again.
Across 7 models and three benchmarks, answer quality goes up 6.4 to 11.7 points while input tokens drop 34% to 57%.
It also beats an LLM Wiki layer and three other navigation layers.
The map can be built without LLM calls and updated as new documents arrive.
Paper: arxiv.org/abs/2609.37226
Chat with Paper: academy.dair.ai/papers/follo…
Rainman retweeted
We’ve spent decades arguing about Recursive Self-Improvement in abstract theory, but Weco AI just posted an empirical result that demands serious attention.
The premise alone had me skeptical.
They built an agent (AIDE²) that literally writes code to rewrite its own source code, runs tests against hidden benchmarks, and keeps the versions that perform best.
Basically, pure self-editing research loops.
They let the thing run completely unattended for 8 days.
It managed to pull off 7 consecutive upgrades.
It invented a new search policy and novel ways to compress its own context memory so it wouldn't bog down.
Usually with these setups, you brace yourself for massive overfitting to the toy benchmark.
But what surprised me was the transfer.
They threw the discovered agent at 4 held out tasks including physics based weather forecasting, which wasn’t even in the training distribution.
And it matched or beat a human-engineered agent thats literally near the top of FML Bench.
The craziest part of the paper though is that Reward Hacking dropped from 55% to 32%.
They never explicitly told it to stop cutting corners.
It just somehow became 7% less prone to hacking the metric than the system built by human engineers.
Its a super intresting paper.
I would love to hear what other folks working on agent architectures think about this.
Read the full paper here: arxiv.org/pdf/2609.26457
Rainman retweeted
New paper from Microsoft and colleagues on evolving agent harnesses.
It's a really cool idea to evolve a harness from published research. Something I have also been testing for the past couple of months.
ScholarEvolve proposes harness changes based on published agent research rather than the agent's own failure logs.
It splits the harness into modules for tool use, memory management, and task execution.
It runs topic modeling over recent papers to identify distinct improvement strategies for each module, then implements and tests combinations.
New papers can be added over time.
With the model held fixed, Qwen3.5-27B goal completion on AppWorld Challenge rises from 49.6% to 63.6%, and GPT-5.4-mini on Tau2-Bench Telecom rises from 72.7% to 81.9%.
Paper: arxiv.org/abs/2609.40169
Chat with Paper: academy.dair.ai/papers/learn…
Rainman retweeted
Most LLMs force standard positional encodings to handle structural biases, completely corrupting the model's semantic representations in long contexts! 🐌
A new paper "You Need Better Attention Priors" from Stanford introduces GOAT to fix this! 👇
arxiv.org/abs/2601.15380
Rainman retweeted
Great paper from Microsoft and colleagues on optimizing agent harnesses.
Current harness optimizers change how the harness is updated but keep the training scenarios fixed, so feedback keeps coming from tasks that stop being informative as the harness improves.
This work adapts the scenarios as well.
ActiveSaddler groups recurring failures into failure patterns and treats each pattern as an arm in a non-stationary bandit.
It tracks how much the harness is still learning from each pattern and splits the budget between revisiting known weaknesses and finding new ones.
With the same optimizer, test Pass@1 improves by 4.4 points on GAIA2 and 7.5 points on Terminal-Bench 2.0 compared with a fixed scenario order.
Paper: academy.dair.ai/papers/activ…
Rainman retweeted
Scaling Trajectories for Complex Tasks through Recursive Self-Rewrite
paper: huggingface.co/papers/2610.0…
