Every paper, one deep dive at a time.

An Old Idea From Cognitive Psychology Reshapes How We Reward Reasoning Models

Training a Markdown File: When LLM Self-Improvement Borrows the Discipline of Neural Net Training

Reading a Model's Confidence Curve to Decide When Chain-of-Thought Is Worth It

Same Model, Organized Differently: How an Agent Architecture Beat Frontier Systems at Research Math

Growing Code and Proof Together: Verified Systems in Ten Hours Instead of a Year

How a Fifteen-Hundred-Dollar Training Run Matched Llama and Gemma on Reasoning

When Three LLMs Talk to Each Other, Their Ideas Quietly Stop Moving

A Robot Made Graphene Without Help, And Caught Itself Hallucinating

When the Model Is Fine and the Plumbing Is Broken: Fixing Agents at the Interface

When Models Know the Answer But Say the Wrong Thing Anyway

When Smarter Models Forecast Worse: The Hidden Failure Mode in LLM Predictions

The OS Trick That Makes Tree Search Practical for Coding Agents

An AI Just Solved a 1996 Erdős Problem—and the Simplest Agent Won

Why Giving an AI Agent More Tools Can Make It Worse at Using a Computer

One Loop to Optimize Them All: A Universal API for LLM-Driven Discovery

When Agent Memory Stops Being a Database and Starts Being a Skill

Why Web Agents Are Slow: A Compiler-Style Fix for Computer-Use Latency

Treating Hallucinations as Exploits: A Gate-Based Architecture for Agent Safety

When Helpful Agents Go Sideways: A 404 Error, Campus Security, and Why Alignment Misses This

When Splitting One Model Across Three Agents Doubles Its Accuracy

Firefly's Inversion: Building Verified Tool-Call Training Data by Working Backward

Why Upgrading Your AI Auditor to a Smarter Model Can Make Your System Less Safe

How Uber Caught 206 Leaked Credentials With an LLM-Powered Security Stack

Why LLM Judges Flip Their Verdicts When You Change the Question Format

When Models Learn the Monitor Exists, the Reasoning Trace Stops Being a Window

An AI Agent Swapped In Focal Loss And Beat A Human-Tuned Training Script

An Old Reinforcement Learning Tradeoff Sneaks Back Into LLM Agents

Why Parallel Sampling Plateaus, And What Evidence Graphs Do Instead

An AI Agent Reached for Root in Twelve Minutes, Without Being Attacked

How a 30B Open Model Reached Olympiad Gold With the Right Recipe

When Agent Benchmarks Lie: The Harness Problem in Open-Source AI

When the AI Optimizer Edits the Grade Book: Why Harnessing Evolution Needs a Wall

When a Frontier Model Talks Its Own Twin Into Climate Denial

How One Sentence and a Forged History Flip the Most Aligned Models

When 'This Is False' Doesn't Stick: Why Models Learn the Lie Anyway

An Agentic Scientific Computing System That Actually Remembers What It Learns

When the Iteration Teaches the Model to Skip the Iteration

Two Frozen Models Learn to Whisper: Coupling Through Hidden States

When Smarter Agents Get Fooled by Three Extra Nodes in a Database

How LLMs Get Persuaded: One Attention Head, A Tetrahedron, And A Single Dial

Why Hallucination Detectors Miss Stale Facts: A Geometric Story About What Models Know But Don't Say

Sparse Attention Was the Wrong Frame. Treat It as Geometry Instead.

Why Frontier Agents Ask for Clarification at Exactly the Wrong Moment

Catching Multi-Agent Deadlocks Before Deployment With a 40-Year-Old Tool

Echo: The Paper Arguing You Never Needed a KV Cache for Retrieval

A Sticky-Note for Every Layer: Letting Transformers Remember What They Were Just Thinking

When Your AI Assistant Won't Let Go of Old Facts About You

Why Your AI Agent Won't Stop Working — and Each Model Falls for a Different Trap

Why Forty-Eight Percent on FrontierMath Isn't the Real Story in DeepMind's New Math Paper

Teaching a Model to Hire Copies of Itself: Recursive Agent Optimization

When AI Agents Build the Serving Stack: A Bet on Bespoke Infrastructure

What RL Actually Does to Language Models, at the Token Level

The Missing Gradient Term That Predicts Sycophancy in RLHF

An AI Agent That Found 28 Zero-Days in Windows — And What Made It Work

Why a Small Agent Confidently Overwrites Memories It Doesn't Understand

Training the Model Spec Directly: An Alignment Lever Aimed at the Say-Do Gap

Ten Thousand Examples Beat the Full Industrial Pipeline for Search Agents

The Compliance Gap: Why AI Says Yes and Does No

When the Best Reward Model Trains the Worst Policy: Inside EvoLM

Language Models Compute the Rational Move, Then Override It

When the Agent Grades Its Own Homework: A Brutal New Benchmark for AI Workers

Why Your Coding Agent Stalls While the GPU Runs Hot

The Audit Number Isn't What You Think: Sycophancy and the Case Against Single-Prompt Bias Tests

Why a Constrained Pipeline Beat a Full Coding Agent at Finding Bugs 30-to-1

Why Search Keeps Rediscovering the Same Workflow, and What That Means

Why AI Coding Agents Keep Trying to Debug Without a Debugger

When RL Actually Teaches Agents Something New, And When It Doesn't

When Reward Climbs But Reasoning Goes Generic: Diagnosing Template Collapse in Agentic RL

How Two Silent Library Bugs Quietly Invalidated a Wave of Reasoning Papers

Why Long-Horizon AI Agents Get Stuck, and a Milestone-Based Fix That Helps

Exploration Hacking: When Models Sabotage Their Own RL Training

What Happens Inside Claude When It Decides to Blackmail Someone

Why a Debugger Designed for Humans Is the Wrong Tool for an AI Agent

The Sycophancy Circuit That Survives Alignment Training

How to Pick the Best of Sixteen Coding Agent Rollouts

An AI Ran a Real Optics Lab for 21 Hours and Found a Transformer-Shaped Pattern in Light

When AI Models Quietly Protect Each Other From Shutdown