Top Papers of Last Week (ending July-21)
Read time: 11 min
📚 Browse past editions here.
( I publish this newletter daily. Noise-free, actionable, applied-AI developments only).
⚡Top Papers of the week (ending July-21)
🗞️ "Chain of Thought Monitorability: A New and Fragile Opportunity for AI Safety"
🗞️ "Your LLM Knows the Future: Uncovering Its Multi-Token Prediction Potential"
🗞️ "How Many Instructions Can LLMs Follow at Once?"
🗞️ "Mixture-of-Recursions: Learning Dynamic Recursive Depths for Adaptive Token-Level Computation"
🗞️ "Lizard: An Efficient Linearization Framework for LLMs"
🗞️ "Artificial Finance: How AI Thinks About Money"
🗞️ Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity
🗞️ One Token to Fool LLM-as-a-Judge
🗞️ A Survey of Context Engineering for Large Language Models
🗞️ "Chain of Thought Monitorability: A New and Fragile Opportunity for AI Safety"
Reading the model’s thoughts can reveal danger before the answer appears. Because, long reasoning chains in an LLM leave text footprints that a simple monitor can scan.
Most AI-safety checks look at model outputs, not the reasoning behind them. The paper argues that peeking at chain‑of‑thought text lets monitors spot mischief early.
Transformer models store long reasoning steps as plain text tokens that humans can read. Monitors have already caught reward hacking and prompt injection by flagging lines like 'let's hack.'
Yet the trick fails if training makes thoughts shorter, hidden, or moved into latent space. Extra reinforcement learning, direct thought supervision, or new architectures could erase this visibility.
So the authors urge developers to track a monitorability score each run and halt when it sinks. They outline research tasks like measuring readability and red‑teaming models that know they're watched.
Bottom line, transparent reasoning is a fragile safety budget that needs guarding.
🗞️ "Your LLM Knows the Future: Uncovering Its Multi-Token Prediction Potential"
Multi‑token masks plus gated LoRA cut LLM latency without hurting accuracy, code output 5X faster.
Large language models can already guess several words ahead, this paper shows how to cash in on that foresight for 5× faster code and math generation with no drop in answer quality.
🚀 What problem are they poking at?: Autoregressive models speak one token at a time, so every extra word forces another full pass through the network. That single‑step habit slows reading back code, proofs, or long chat replies. The authors noticed the model’s hidden states quietly predict whole phrases anyway, sitting unused in the logits list.
🧩 Mask tokens pull the future forward: They append k special mask tokens to the prompt, ask the frozen network to fill them, then fine‑tune only small adapters. The trick makes the model treat the masks as “next 8 words” placeholders instead of blanks, producing 9 fresh tokens in one shot.
🪟 Gated LoRA keeps the old brain intact: Regular LoRA alters every forward pass and hurts accuracy. Their gated LoRA routes updates only through the masks, leaving standard next‑token paths untouched. A plot on page 8 shows accuracy staying flat with the gate while standard LoRA drifts downward.
⚡ Sampler head stitches a smooth phrase: Raw multi‑token logits can clash. A tiny 2‑layer MLP looks at the current hidden vector plus the token it just chose, nudging the next pick so the sentence flows. Because the MLP is external, the base model stays frozen and cheap to store.
📈 Speculative decoding without backtracking pain: Linear speculative decoding fails if any predicted word is wrong. They interleave masks between speculative words, a scheme they call quadratic decoding, so at least one new chunk is always verifiable next round. Acceptance rates jump, especially when k ≥ 4.
🔬 Training cocktail in plain sight: During 50K supervised‑fine‑tune steps, Cross‑entropy teaches both regular and mask outputs. A latent consistency loss pulls each mask’s hidden state toward the later true token, so masks imitate real autoregressive states. Because gradients never touch non‑mask tokens, the base model’s original responses remain stable.
⏩ Speed gains you can measure: Table 1 on page 9 reports acceptance rates. With 8 masks the model averages 3.17 tokens per step, and on GSM8K math it rides up to 5.22 tokens per step, a direct ≈5× wall‑clock gain. Coding tasks show similar numbers. General chat still lands a neat 2.5×, matching human‑quality scores.
🥡 Bottom line: The paper proves you can graft a tiny mask‑aware head onto an existing 8B model, keep quality, and cut inference time by up to 80%, all with a handful of extra parameters.
🗞️ "How Many Instructions Can LLMs Follow at Once?"
Brilliant paper for optimizing your prompt-design. 💡
Keep crucial rules early in your prompt, break huge lists into chunks, and expect misses past 150 no matter how fancy the engine. This paper checks what happens when the rules or instruction list reaches 500.
IFScale, the benchmark, asks a model to write a business report while slipping in up to 500 exact keywords. Because scoring is plain keyword matching, the team charts accuracy for 20 models from 7 vendors.
Results show three decay shapes. Reasoning models like o3 stay near 100% until about 150 rules then drop fast, gpt‑4.1 drifts down in a straight line, and smaller llama versions plunge early.
Even the strongest system lands at 68% with 500 rules. The study also spots a primacy bias, so early keywords get more love once the list grows, and omissions overwhelm partial matches.
More rules stretch response time, meaning teams must juggle speed against recall.
🗞️ "Mixture-of-Recursions: Learning Dynamic Recursive Depths for Adaptive Token-Level Computation"
This is quite a landmark paper from GoogleDeepMind.
📌 2x faster inference because tokens exit the shared loop early.
📌 During training it cuts the heavy math, dropping attention FLOPs per layer by about half, so the same budget trains on more data.
Shows a fresh way to teach LLMs to plan steps inside their own reasoning loop, instead of hard-coding a single chain. Second, it proves the mixer idea scales. By jumbling several small recursive experts and letting the model pick which one to call next, the team pushes accuracy on math and coding benchmarks without ballooning parameter count.
Mixture-of-Recursions (MoR) keeps 1 stack of layers in memory, loops it for tough tokens, and still beats a much bigger vanilla model in accuracy and speed . It does this by letting a tiny router choose how many loops each token gets, then it saves cache only for the tokens that stay active.
Fewer weights, fewer FLOPs, less memory, yet better perplexity across 135M‑1.7B scales.
🪐 The Big Picture
Scaling Transformers usually means stacking more layers and paying the price in memory and compute. MoR flips that habit. It shares 1 compact block, runs it up to 4 times depending on token difficulty, and skips the loop early when the router says “done”.
🔗 Sharing Layers To Shrink Memory Recursive Transformers tie weights across depth, but past work still fed every token through every loop. MoR keeps the weight tying idea yet adds “Middle‑Cycle” sharing, so only the first and last layers stay unique while everything in between reuses a mini trio of layers each loop . That choice keeps gradients stable and drops unique parameters by about 3× without losing expressiveness. Because the same weights repeat, Fully‑Sharded Data Parallel only gathers them once per step, cutting communication too.
🗞️ "Lizard: An Efficient Linearization Framework for LLMs"
Lizard, a linearization framework that transforms pretrained Transformer-based LLMs (LLMs) into flexible, subquadratic architectures for infinite-context generation.
Lizard shows a transformer can keep almost all its smarts while replacing softmax with cheaper gated linear plus tiny sliding window attention. The project fixes the long‑context problem where standard attention blows up in time and memory.
Softmax compares every pair of tokens so cost rises with the square of length. Lizard learns a per‑token gate that smoothly forgets, processes tokens recurrently, and keeps only a constant‑size state even at 32,000 tokens.
A short window and 4 summary tokens handle local detail, while the gate keeps global clues so quality stays high beyond the 2,048 training length. The team first trains these new pieces to mimic the frozen teacher’s attention maps, then applies LoRA fine‑tuning on 20M tokens.
Results: 61.2 on 5‑shot MMLU for the 8B model, just 5.4 below the teacher and up to 18 above previous linear methods, with a 32% faster kernel and flat memory. So Lizard swaps a handful of extra parameters for infinite context and near‑teacher accuracy.
🗞️ "Artificial Finance: How AI Thinks About Money"
Money habits differ worldwide, yet nobody knows which habits shape LLM advice. This study asked 7 major chatbots and humans from 53 countries the same 14 finance questions.
Each model answered 100 times, researchers kept the median answer for every prompt, and compared it with the INTRA survey medians. When the authors ran that check on the 14 finance questions, every large language model landed in the same tight group, and the only human data that fell into that pocket came from Tanzania
The models almost always choose, or price, the gamble right at that average. In plain terms, they treat a risky $100 at 50% chance exactly the same as a sure $50.
Most real people are risk-averse. They prefer a smaller certain gain over a larger but shaky one, so their bids usually drop below the average. The paper notes that the models skip that human caution and act risk-neutral, which is uncommon in the survey data.
On time choices several models returned discount factors above 1, which violates basic discounting logic. Gemini's present bias score topped 1 too, meaning it liked waiting more than receiving cash now. Across loss tasks bots priced insurance close to strict math, while humans overpaid for safety.
The Tanzania tie likely reflects East African raters who guide model training feedback. So current chatbots act as cool calculators but still carry hidden cultural fingerprints and occasional math slips.
🗞️ Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity
This study finds AI can slow veteran developers by 19% instead of speeding them up. 🤯
🔍 What they tested
Researchers followed 16 long‑time contributors as they tackled 246 real GitHub issues inside million‑line projects. Each ticket was flipped into “AI‑allowed” (Cursor Pro, Claude 3.5/3.7, GPT‑4o, etc.) or “AI‑blocked”. Before starting, devs predicted a 24% boost, and even after finishing, they still guessed 20%. Stopwatch data said the opposite: jobs with AI ran 1.19× longer.
🐢 Why the drag shows up
- Prompting overhead. When AI was on, coders typed less, Googled less, but burned time crafting prompts, waiting for model output, and auditing suggested patches.
Only 44% of generated diffs were kept; the rest were scrapped or heavily rewritten
. Screen labels show about 9% of active minutes went to cleaning AI code and 4% to pure waiting
. The slowdown held across alternative estimators, early vs. late tickets, and different models (Claude 3.5, 3.7, GPT‑4o).
- Deep repo quirks. Each maintainer had about 5 years and 1,500 commits in their repo, so their personal context outclassed the model’s window.
- Messy scale. Repos averaged 1.1M lines; models often touched the wrong files or missed hidden rules.
- Over‑confidence loop. Because helpers felt helpful, devs kept using them even while the clock said otherwise.
- Tacit style rules. The models lacked unwritten performance and compatibility habits the teams follow.
🗞️ One Token to Fool LLM-as-a-Judge
Many AI teams let a big model score answers instead of rigid rules. The paper shows that single words like "Solution" or even a colon trick these scoring models into calling wrong answers correct, in some tests 80% of the time.
These tricks break training loops that depend on honest scores, because the learner starts printing the same magic token and stops solving the task. The authors call the tokens "master keys" and run them across math and general question sets with GPT‑4o, Claude‑4, Qwen, and other models, all fail often.
The judge trips because it watches surface cues instead of checking facts. To patch the hole, they add 20000 fake answers that hold only these empty lead‑ins to the training data of a 7B verifier.
After one pass of fine‑tuning, the new "Master‑RM" almost never falls for any of the keys while still matching GPT‑4o on normal grading. The fix is cheap and it generalizes, showing that solid judging just needs the right negatives.
🗞️ A Survey of Context Engineering for Large Language Models
Beautiful Survey paper on Context Engineering on 1400 research papers. 165 pages of comprehensive taxonomy decomposing Context Engineering into its foundational Components and the sophisticated Implementations.
LLMs stumble when the prompt is messy, so this survey maps every tool for cleaning, stretching, and storing context. The authors show that smart context handling, not just bigger models, drives more accurate and reliable answers.
🗺️ Why define “context engineering” at all?
Today, prompt tricks, retrieval add-ons, long-attention tweaks, and memory hacks grow in separate silos. That split hides how they all chase one goal: feed the model the right bytes at the right moment.
So context engineering captures the full pipeline that creates, processes, and manages those bytes, then lines it up in one taxonomy.
🧩 Three foundational building blocks
1. Context Generation & Retrieval covers everything from Chain-of-Thought templates to RAG assemblies that pull fresh facts.
2. Context Processing tackles long sequence tricks like FlashAttention and Mamba so the model can scan 1M-token logs without choking.
3. Context Management stores or compresses old exchanges with methods such as Hierarchical Memory or KV Cache pruning to fit future calls.
That’s a wrap for today, see you all tomorrow.