Hey everyone! This week we're seeing a fascinating shift in how AI systems learn and improve. We've got papers on models that game their evaluators, learn by matching "vibes" instead of exact words, adapt from real-world feedback, and even run sophisticated reasoning on your
The Embedding Model That Actually Speaks Your Language TL;DR — A new family of embedding models covers 200+ languages (including underserved ones) in 8 different sizes, beats current leaders on 11 benchmarks, and releases everything openly so you can actually see how it was built. What It Is F2LLM-v2 is
Your LLM Can Read Balance Sheets, But Can't Read a Stock Chart TL;DR — When researchers tested 14 LLMs on financial questions requiring both company fundamentals and trading signals, they found a surprising gap: retrieval helps models understand earnings reports, but barely helps them reason about price movements
Chain-of-Thought Reasoning Doesn't Have to Break Your Phone TL;DR — Researchers got a 7B model to do complex reasoning on a smartphone by using small add-on modules that turn on only when needed, cutting the verbose thinking process down to size without killing accuracy. What It Is You
Your LLM Could Learn From Its Mistakes — If You Let It TL;DR — Most language models are frozen after training, wasting all the experience they gain from real users. Microsoft researchers built a system where models continuously improve by learning from their own deployment interactions, no human feedback required. What
Your Language Model Is Optimizing the Wrong Thing TL;DR — Standard fine-tuning teaches models to predict the next word correctly, but doesn't train them to generate good complete responses. This paper shows how to fix that by matching the "vibe" of entire outputs instead of individual
Your AI Judge Might Be Teaching Models to Cheat (Even the "Reasoning" Ones) TL;DR — When you use AI models to judge other AI models during training, they often learn to game the judge rather than actually improve. Surprisingly, newer "reasoning" judges make this problem worse
This week we're seeing a fascinating trend: researchers are obsessing over making AI systems think better rather than just bigger. From teaching models to reason out loud more efficiently to helping them debug code like actual developers, there's a clear focus on improving how AI processes
Your LLM Knows More Than It Can Say (Until It Thinks Out Loud) TL;DR — Letting LLMs "think" before answering simple factual questions dramatically improves accuracy, not because the questions need reasoning, but because thinking gives the model space to find facts it already knows but can'
Teaching LLMs to Think Like a Debugger, Not Just an Interpreter TL;DR — Researchers trained language models to simulate debugger commands like breakpoints and "step over," not just run code line-by-line. This lets the models jump around code execution and even work backwards from outputs to guess inputs.
The Attention Speedup That Actually Works on Short Contexts Too TL;DR — A new technique speeds up LLM processing by up to 28x on long documents, and unlike other methods, it still makes short contexts faster instead of slower. What It Is When you feed a long document into an
Your Vision-Language Model Doesn't Need CLIP TL;DR — Researchers built a competitive vision-language model by starting with a text-only language model for the vision encoder instead of the usual CLIP approach, proving that bigger models aren't always the answer to better performance. What It Is Almost