Brief

Strip the Leakage, and the LLM Forecasting Edge Mostly Disappears

A 36-month leakage-controlled test shows a 7B RAG forecaster's median IC of +0.154 is largely explained by macro-analog retrieval, not LLM capability.

Robots That Play First Solve Tasks Better: 20-Point Gains Without Extra Instructions

Self-directed robot play before task assignment builds a reusable skill library that lifts downstream performance by up to 20.6 points, no finetuning required.

ContextRL Trains Models to Find the One Sentence That Actually Matters

A new auxiliary RL objective forces LLMs to select the context fragment that supports an answer, yielding +2.2% on long-horizon agent benchmarks and +1.8% on visual QA.

SAE Feature Clamping Gets a 95.8% Bypass Rate

Clamping SAE features suppresses one path to harmful behavior, not the behavior itself. Models recover through the unexplained reconstruction residual.

The Field's Go-To GUI Agent Dataset Actively Breaks Fine-Tuning

ProCUA-SFT shows AgentNet causes negative transfer in CUA fine-tuning, while 3.1M synthetic steps lift OSWorld from 26.3% to 45.0%.

Same Success Rate, Completely Different Failure Modes: Web Agent Eval Is Broken

WebStep's 1,800-task benchmark reveals that agents scoring identically on task success diverge sharply on where and how they fail mid-workflow.

Expert Exam Scores Don't Predict Medical LLM Reliability Under Pressure

MedMisBench shows LLM accuracy drops from 71.1% to 38.0% when misleading context is injected, exposing a structural gap in medical AI evaluation.

Frozen Safety Monitors Break After Fine-Tuning, Not After Quantization

Activation monitors trained on base models degrade sharply after LoRA fine-tuning but survive quantization, exposing a silent gap in most production safety stacks.

EvoTrainer: Fixing the Training Harness While Tuning the Policy Is a False Economy

EvoTrainer co-evolves LLM policies and training harnesses simultaneously, matching or beating human-engineered RL baselines across math, code, and SWE tasks.

Two Tokens Fix Hidden-State Recurrence: SWITCH Makes Latent Reasoning RL-Trainable

SWITCH adds discrete boundary tokens to latent chain-of-thought, making hidden-state recurrence compatible with standard on-policy RL and causally interpretable for the first time.

MiniMax Sparse Attention Cuts Million-Token Compute by 28x Without Quality Loss

MSA delivers 28.4x attention compute reduction and 14.2x prefill speedup at 1M context on a 109B model, matching full GQA quality.

The Safety Tool That Became a Jailbreak: GCD's Hidden Attack Surface

Grammar-constrained decoding, used to enforce code validity, suppresses LLM refusal tokens and enables a 30+ point jailbreak success rate lift.

CoT Fine-Tuning Quietly Destroys Long-Context Recall in Hybrid LLMs

Chain-of-thought SFT collapses Needle-In-A-Haystack retrieval in hybrid linear-attention models, and a training-free QK weight restore fixes it.

PPO's Ratio Clipping Has a Blind Spot. DRPO Fixes It.

DRPO replaces ratio-clipping in LLM RL with a smooth divergence regularizer, stabilizing off-policy training where PPO and GRPO break down.

On-Policy Distillation Breaks at the Prefix, Not the Token

Trajectory-Refined Distillation names the exact structural failure in on-policy distillation and fixes it at the trajectory level, not the token level.

MoE-to-Dense Conversion Beats Dense Pruning by 6.3 Points

A new framework converts trained Mixture-of-Experts models into standard dense networks, outperforming dense-to-dense pruning by 6.3 pp at matched parameter count.

The Part of Your LLM You Throw Away Is Quietly Corrupting Your Embeddings

EmbedFilter uses the unembedding matrix to remove high-frequency token bias from LLM embeddings, improving MTEB zero-shot performance while cutting index size.

Code2LoRA Matches Per-Repo Fine-Tuning at Zero Inference Token Cost

A hypernetwork generates repository-specific LoRA adapters on the fly, matching per-repo fine-tuning accuracy while adding zero inference-time token overhead.

AI's Deployment Gap Is an Evaluation Problem, Not a Capability Problem

ALE benchmarks AI agents on 1,000+ real economic workflows, where current top systems average a 2.6% full pass rate.

NTP's One-Hot Supervision Leaves Representation Space Broken by Design

NITP adds a dense continuous supervision signal in latent space during pre-training, lifting MMLU-Pro by 5.7% on a 9B MoE model with only 2% extra training FLOPs.

Agentic Inference Is Structurally Wasteful: LayerRoute Fixes It in 6 Minutes

LayerRoute trains a 1.1M-parameter LoRA adapter that skips 15% of FLOPs on tool calls while barely touching planning steps, cutting agentic compute waste without retraining.

On-Policy Distillation Without Logit Access: +28.64% on Math

OmniOPD removes the white-box teacher requirement from on-policy distillation, using chunk-level semantic verification to match or beat open-weight OPD baselines.

LoRA Has a Memory Ceiling, and Now You Can Calculate It

A new power law quantifies LoRA's exact parametric memory capacity, giving teams a principled ceiling instead of trial-and-error rank tuning.

Safety Benchmarks May Be Measuring Evaluation Awareness, Not Alignment

Models fine-tuned on texts describing evaluation practices score significantly safer on benchmarks without any change in actual deployment behavior.

Safety Benchmarks May Measure Test-Awareness, Not Alignment

Models fine-tuned on evaluation meta-knowledge score safer on six safety benchmarks, exposing a new confounder that existing detection methods can't catch.

Agentic RL Training Actively Degrades Tool Judgment: A Fix in 18% Fewer Calls

AKBE fixes a training-loop failure where agentic RL makes models worse at knowing when NOT to call tools, recovering 25% higher tool productivity.

AI Research Agents Fabricate Citations at 21%: A Verifiability Crisis

ScientistOne's Chain-of-Evidence framework exposes systematic fabrication in autonomous research agents, achieving zero hallucinated references where baselines fail at rates up to 21%.

Silencing Agents Beats Letting Them Talk: DarkForest Cuts Errors 30.7%

DarkForest keeps multi-agent LLMs from seeing each other's reasoning, then aggregates structured beliefs , cutting errors 30.7% and token use 6.5x.

Most Tokens in a Correct Response Are Getting the Wrong Credit Signal

DelTA shows RLVR's policy-gradient update acts as an implicit token-level discriminator, then fixes the distortion it creates , gaining 3.26 points on math benchmarks.

RLVR Fine-Tuning Is Geometrically Wasteful: Rank-1 Extrapolation Matches Full Training

RELEX shows RLVR weight trajectories are rank-1 and near-linear, letting teams extrapolate full-run checkpoints from just 15% of training steps.

Video MLLMs Fake Audio Understanding: Visual Hallucination at Scale

Every major video MLLM, including models from OpenAI and Google, substitutes visual inference for actual audio processing, a flaw now measurable and partially fixable.

Post-Trained MoE Models Can Skip Half Their Experts Without Retraining

ZEDA converts static MoE models into dynamic ones via self-distillation, cutting over 50% of expert FLOPs with ~1.20× speedup and minimal accuracy loss.

Post-Trained MoE Can Skip Half Its Experts Without Retraining

ZEDA converts static MoE models into dynamic ones via self-distillation, cutting over 50% of expert FLOPs with minimal accuracy loss and no pretraining.

Frontier Research Agents Pass at Under 22% on Consulting-Grade Work

A new benchmark with verifiable rubrics and cognitive traps reveals frontier deep research agents fail decision-grade consulting tasks at alarming rates.

Dense Teacher Supervision Breaks Multi-Turn Agents. SDAR Fixes It.

SDAR adds a sigmoid-gated distillation layer on top of RL, lifting agent performance by up to 10.2% over GRPO across ALFWorld, WebShop, and Search-QA.

Agents Score 55% on Belief Invalidation: The Silent Memory-Rot Problem

STALE benchmark reveals frontier LLMs fail to detect implicit memory conflicts, scoring only 55.2% on belief invalidation across 1,200 queries.

One Base Model, One Million Policies: MinT's LoRA Adapter Architecture

MinT keeps a single resident base model and hot-swaps LoRA adapters at request time, cutting per-policy GPU cost to near-zero at million-adapter scale.

On-Policy Distillation Hurts When the Teacher's Context Is Wrong

A training-free diagnostic shows distillation guidance aligns with ideal gradients on incorrect rollouts but degrades on correct ones, breaking the 'distill from best model' default.

MatryoshkaLoRA: One Training Run, Every Rank You Need

A nested diagonal matrix inside LoRA adapters eliminates rank grid search, yielding multiple efficiency-accuracy operating points from a single fine-tuning run.

LEAD Cuts Chain-of-Thought Length Without Accuracy Loss

LEAD uses adaptive RL reward shaping to eliminate CoT padding, achieving top accuracy and efficiency scores across five math benchmarks.

SkillOS: The Curation Bottleneck That Keeps LLM Agents Stuck at Zero

SkillOS uses RL to train a dedicated skill curator that filters and evolves reusable agent experience, beating memory-based baselines on multi-turn tasks.

Every LLM Throws Away Token Identity After Layer One. TIDE Doesn't.

TIDE re-injects token identity at every transformer layer, directly fixing rare-token undertraining and contextual collapse in small models.

MoE Experts Are Entangled by Default. EMO Fixes That at 1B Scale.

EMO pretrains MoE models so expert subsets specialize by domain, cutting 75% of experts at inference while losing only 1% accuracy.

SFT Before RL Is Actively Hurting Your Multimodal Model

PRISM inserts a black-box on-policy distillation stage between SFT and RLVR, closing distributional drift without white-box model access and lifting accuracy by up to +6 points.

GUI Agents Top Out at 21% on Multi-App Tasks That Mirror Real Work

WindowsWorld exposes a hard ceiling in current GUI agent evals: agents that look capable on single-app benchmarks collapse on professional cross-application workflows.

The Most Engineered Agentic Gateway Scores 0.000 on Every Safety Check

A new audit framework exposes four structural failure modes in agentic-AI runtimes, with the leading open-source gateway scoring zero recall on all four.

A Single Tool Call Can Poison an Agent's Memory for 100+ Sessions

Trojan Hippo achieves 85-100% attack success against frontier models by planting dormant payloads in agent memory via one untrusted tool call.

Cross-Architecture dLLM Distillation: 0.6B Student, 48.78 HumanEval

TIDE is the first framework to distill diffusion LLMs across incompatible architectures, lifting a 0.6B student to 48.78 HumanEval against a 32.3 AR baseline.

Your LangGraph Orchestrator Is Failing 24% of Travel Conversations

A controlled comparison shows in-context self-orchestration beats LangGraph on procedural tasks, cutting failure rates by half across three domains.

Safety Signal Lives Inside the Model, Not Just at the End

SIREN probes internal LLM layers to detect harmful content, beating current guard models with 250x fewer trainable parameters.

On-Policy Distillation Makes Models More Accurate and More Overconfident — Simultaneously

Standard model training methods boost accuracy but accidentally make AI overconfident—the model learns from information unavailable when actually deployed. A new approach separates accuracy training from confidence calibration, keeping accuracy gains while fixing the broken confidence estimates that break downstream systems like AI agents and retrieval pipelines.

Learning Adaptive Reasoning Paths for Efficient Visual Reasoning

Visual reasoning models now route simple questions directly to answers instead of forcing every query through lengthy multi-step reasoning chains. This adaptive approach matches accuracy while slashing compute costs on the majority of real-world questions—which turn out to be straightforward factual or perceptual tasks, not complex reasoning problems.

Agents Can Now Learn From Their Own Past Reasoning, Without Retraining

AI agents can now learn from their own past reasoning without retraining by retrieving similar thinking patterns from a stored bank of completed tasks. This lets agents apply proven problem-solving strategies to new work instantly, improving success rates especially when tasks share logical structure but different wording—where traditional memory systems fail. For production teams, the payoff is clear: building a reasoning trace archive from day one becomes more valuable than the model itself.

Hyatt Deployed ChatGPT Enterprise Globally: Rollout Details

Hyatt became the first major hospitality chain to deploy AI across its entire global workforce, using specialized tools for different jobs—general AI for office work and code-generation AI for technical tasks. This move signals that enterprise AI adoption is maturing beyond experiments, and shows other large companies that matching the right AI tool to specific work categories, rather than forcing one model everywhere, delivers better results.

Deep Research Agents Fail on the Basics — and Current Benchmarks Can't See It

Research agents that write full reports are being tested on the live web—where results change daily and can't be repeated. A new evaluation framework replaces this chaos with frozen, realistic document collections for each task, finally making performance scores trustworthy and exposing hidden failure modes like poor citations or missing facts that single scores hide.

Reward models that explain themselves outperform those that just score

Reward models for image generation now produce detailed written critiques instead of just numerical scores, enabling them to guide image refinement rather than merely rank outputs. This makes AI image generators improvable without retraining—a critique-based feedback loop instantly produces better images by revising prompts based on the model's own reasoning about what went wrong.

Computer-Use Agents Fail Safety Tests Even When Users Do Everything Right

AI agents that control computers now face a hidden danger: they fail safety tests even when users give completely harmless instructions. The problem emerges from what happens during task execution—malicious files the agent encounters or unintended side effects it causes—not from the original request. Over 90% of leading systems fail these tests, revealing that checking user inputs alone cannot catch these downstream harms.

Uni-ViGU: Towards Unified Video Generation and Understanding via A Diffusion-Based Video Generator

Video generation typically costs vastly more compute than understanding, making language-model-first architectures inefficient. Uni-ViGU flips this: starting with a video diffusion model as the foundation, it adds understanding as a lightweight add-on, letting both tasks share the generator's rich visual knowledge without architectural strain. This changes how teams can build unified systems for video captioning, QA, and generation.

The 3D point cloud field has a reproducibility problem, and it's structural

LIDARLearn unifies 55+ competing point cloud models—used in autonomous vehicles, drones, and robots—into a single standardized testing framework, finally making fair performance comparisons possible. Until now, incompatible codebases and preprocessing pipelines masked whether one method truly outperformed another, forcing teams to re-test every algorithm on their own data before deployment.

The Cloud Infrastructure Stack for AI Agents Is Consolidating Fast

Cloudflare now runs advanced AI models directly on its global network, letting enterprises build and deploy AI agents without juggling multiple vendors for security, routing, and secrets management. This matters for regulated industries where data must stay within strict boundaries—the real win is infrastructure consolidation, not new AI capabilities.

The 3D registration benchmark problem nobody fixed: models trained on perfect data, tested on perfect data

Factory robots and inspection systems fail with standard 3D registration models because they're trained on perfect synthetic data—clean scans with no noise or occlusion. R3PM-Net introduces the first real industrial datasets (Sioux-Cranfield and Sioux-Scans) to measure what actually works in production, finally closing the gap between lab benchmarks and grimy factory floors.

Training 100B+ Models Without a Cluster: Memory Architecture Beats Hardware Scale

MegaTrain trains 100-billion-parameter models on a single GPU by storing weights in CPU memory and streaming them to the GPU layer-by-layer, eliminating the need for expensive multi-GPU clusters. Smaller research teams and organizations can now experiment with massive models on standard workstations instead of renting cloud computing time.

Agents Keep Relearning the Same Lessons: SkillX Builds a Shared Curriculum Instead

SkillX lets AI agents share what they learn across teams instead of each solving problems from scratch. By organizing experience into three levels—strategic plans, functional skills, and atomic moves—agents can instantly access and reuse the right knowledge for any task, eliminating wasteful redundant learning.

When the teacher cheats, the student memorizes instead of learns

When AI models learn from a "teacher" that sees the right answer, they memorize shortcuts instead of learning generalizable skills—a hidden failure of dense supervision. This work shows that mixing in sparse feedback from verifiable outcomes prevents this collapse, enabling stable long-term training where pure dense signals fail.

AI-generated videos are too consistent — and that's exactly how to catch them

AI-generated videos betray themselves through eerie consistency—their frames correlate with each other far too predictably because they're anchored to a fixed prompt, while real video naturally accumulates random camera shake and lighting flicker. A new detection method exploits this temporal fingerprint across entire videos rather than hunting for glitches in individual frames, making it resilient to improvements in generation quality.

How Meta Used AI to Map Tribal Knowledge in Large-Scale Data Pipelines

AI coding assistants fail on large real-world codebases not because they're weak reasoners, but because they lack the organizational knowledge experienced engineers carry—which modules own what logic, which dependencies matter, which files are safe to touch. Meta fixed this by explicitly mapping their 4,100-file codebase's ownership structure and cross-repo dependencies, dramatically improving how often agents made useful edits. For any team seeing plausible-but-wrong code suggestions, the fix isn't a better model—it's encoding your codebase's actual structure.

Open-ended discovery systems are not truly open-ended; CORAL is the first framework to make them autonomous

Most AI discovery systems claim to explore freely, but hidden rules actually pre-decide their every move. CORAL removes these constraints, letting multiple AI agents work together through shared memory and recover from dead ends on their own—enabling genuine open-ended exploration for math, algorithms, and complex problems that require sustained multi-step searching.

LoRA Isn't the Default for Hybrid Models Anymore

For hybrid models combining recurrence and attention, tuning the recurrent layer's initial hidden state outperforms the standard LoRA approach by 10–24 percentage points on code tasks, using zero extra parameters and requiring no weight merging at deployment. This method works for narrow, data-scarce problems on models like Qwen and Falcon but doesn't apply to standard transformers or transfer to text-to-SQL tasks.

Treating vision and audio as second-class citizens has a cost

A new unified model treats vision, audio, and text as equal citizens by converting them all into discrete tokens, eliminating the separate encoders and translation layers that plague current multimodal systems. This architectural shift reduces error-compounding integration seams, making it dramatically simpler to build AI systems that truly integrate speech and images rather than bolting them onto language models as afterthoughts.

AI agents read physics papers but do not reproduce them.

AI agents claiming strong coding skills fail to reproduce physics papers end-to-end, exposing a critical gap between understanding research and executing it. A new benchmark tested 30 physics tasks requiring agents to read papers and match published results—revealing that standard coding benchmarks mask blind spots crucial for automating real scientific work.

Training in the Deployment Harness Closes the Benchmark-Production Gap

Cursor's Composer 2 trains coding models inside the actual deployment environment rather than on isolated benchmarks, eliminating the usual gap between test performance and real-world results. By running reinforcement learning on the same tools and structure deployed users see, the model learns to solve problems that actually matter instead of optimizing for curated datasets—a fundamental shift in how coding AI gets trained.

Diffusion policy RL has a hidden unification problem — and it's slowing everyone down

Robot learning teams have been reinventing the same solutions repeatedly because no one agreed on how diffusion-based robot policies actually work. FlowRL maps all existing approaches onto a unified framework, revealing which innovations are genuinely new versus cosmetic variations—letting researchers skip redundant work and compare fairly for the first time.

Bayesian Optimization Addresses Concrete Mix Design's Data Problem

For decades, concrete makers relied on expensive trial-and-error lab testing to find the right ingredient mix. Meta's new AI model cuts this dramatically by learning from each test to predict which next experiment reveals the most valuable information—reducing both the number of physical tests needed and carbon emissions from cement-heavy formulas.

Cost volumes are stereo matching's sacred cow — warping alone just dethroned them

A new stereo vision method ditches the industry standard "cost volumes"—3D grids that compare pixels across image pairs—and instead uses iterative image warping to measure and fix misalignment directly. It's now the fastest and most accurate method on all three major benchmarks simultaneously, running 1.8–6.7x faster while cutting cross-domain error by 81%, making it immediately valuable for depth-sensing applications from robotics to autonomous vehicles.

Video Agents That Decide What to Watch Before Watching It

EVA lets video AI systems decide which frames matter before processing them, using reinforcement learning to develop adaptive viewing strategies instead of watching everything uniformly. This cuts wasted computation on long videos—a critical bottleneck for any team building video understanding systems at scale.

Long video QA breaks when models ignore what the video is already telling them

Most video QA systems fail on long videos because they match query words to segments in isolation, ignoring how scenes connect visually and temporally. VideoDetective treats the video as a graph where segments influence each other's relevance scores, letting it find clues that only make sense in context—fixing a fundamental flaw in how we retrieve answers from hours of footage.

Deep research agents do not need the internet; they need the right offline corpus

DoRA's memory wall breaks at high rank: a systems fix, not a math fix

OpenAI's Safety Stack for Sora 2 Reveals How Hard Real-Time Video Moderation Actually Is

Real-time video generation breaks old safety tools designed for images—watermarks degrade under compression, and new user behaviors outpace single-layer defenses. OpenAI's Sora now combines prompt filtering, output classification, and platform enforcement across multiple layers to catch harmful content at scale, but developers building on video APIs can't rely on upstream safety alone.

3D reasoning in VLMs stems from perception issues, not language processing.

Vision-language models struggle with 3D spatial reasoning because they lack training signal, not because they need richer input data. This work trains models to reconstruct scenes and understand their own position within them, enabling video-based AI systems and AR applications to reason about space without preprocessing geometric data at inference time.

Real websites will get your agent banned — synthetic clones will get it trained

VeriEnv lets AI agents train on synthetic website clones instead of real sites, eliminating bot detection blocks and unreliable LLM judges. Agents now get deterministic feedback by reading internal site state, making web automation training 10x safer and faster—perfect for companies building search tools and automation pipelines before deploying to production.

The Search Agent Data Gap Has a Structural Fix — and the Numbers Behind It Are Now Public

Residual connections assume every layer matters equally — these results say they're wrong by design

Most researchers are using AI wrong — here's the five-level map that shows why

For the first time, we have a clear map for where AI-assisted research actually sits—from asking ChatGPT questions to running fully autonomous agents overnight. The key insight: most teams lack guardrails to stop agents from reporting plausible-looking false results, turning verification itself into the critical failure point that needs explicit rules built into the agent's instructions.

Coding Agents Fail at Real-World Optimization—and Current Benchmarks Can't Even See It

Ensemble weighting that punishes disagreement outperforms static mixing in non-stationary sequential tasks

For ensemble models in shifting environments, a new weighting system tracks both individual performance and how much each model agrees with the others—penalizing those that drift from consensus. This catches failing specialists before their raw accuracy numbers do, and comes with formal guarantees that the approach won't fall too far behind an ideal fixed strategy, even as the optimal expert changes over time.

Static ensemble weights fail in non-stationary environments, and coherence between models carries the signal you're missing

When LLMs retrieve documents to answer questions, they excel at math puzzles but fail catastrophically on cryptographic proofs—even when the correct answer sits in their retrieved context. The problem: models trained on clean benchmarks don't learn to verify retrieved information against subtle real-world constraints, leaving production systems vulnerable to confident hallucinations on security-critical tasks.

LLMs That Ace Math Olympiads Collapse on Real Cryptographic Code Proofs

LLMs That Ace Python Collapse on a General-Purpose Language With Thin Training Data

Text-to-image models fail at complex text because glyph templates were never in the loop

GlyphBanana lets AI image generators finally render complex text—formulas, CJK characters, mathematical symbols—by anchoring them with pre-made character templates instead of relying on training data that never existed. It works instantly on existing models without retraining, making it a direct solution for design tools and document generation systems that need reliable text in images.

DeepSport: A Multimodal Large Language Model for Comprehensive Sports Video Reasoning via Agentic Reinforcement Learning

For the first time, a single AI system can understand complex sports videos across multiple sports and tasks simultaneously—recognizing plays, interpreting rules, and analyzing tactics all at once. This works because the system learns through trial-and-error reasoning rather than memorization, enabling it to handle the fast motion and rule complexity that stump previous narrow models. Sports analytics teams and video AI researchers now have a unified blueprint replacing fragmented tool chains.

Governing Evolving Memory in LLM Agents: Risks, Mechanisms, and the Stability and Safety Governed Memory (SSGM) Framework

AI agents that remember conversations over time are becoming common, but no one has yet figured out how to stop those memories from getting corrupted, manipulated, or drifting into false beliefs. This paper introduces the first framework to actively protect evolving agent memory—catching contradictions before they're stored and flagging memories that slowly change meaning—making long-term AI agents actually trustworthy.

Knowledge Graph RAG Breaks on Multi-Hop Questions — Entity Summaries Fix the Retrieval Phase

Knowledge graphs struggle to answer complex questions because indexing strips away context needed to trace connections across multiple steps. Entity-level summaries that preserve this context—built during indexing rather than at query time—restore the ability to answer "who founded the company that acquired X?" without graph traversal. This breaks the indexing bottleneck that's been silently capping multi-hop reasoning in knowledge graph systems.

Using Code as Intermediate Representation Improves VLM Spatial Reasoning by 68.8%

AI image-understanding systems now accurately answer spatial questions like "where is the glass?" by first writing code to map object locations, boosting accuracy by 69%. This breakthrough helps developers build more reliable robots and automation tools that need to understand physical layouts.

Imitation Learning Can't Teach Judgment — Agents Trained on Perfect Demos Fail Out-of-Distribution

AI agents trained by copying human experts fail when conditions change slightly—they've never learned what *not* to do. New research shows agents need to experience and learn from failures in safe environments to develop real judgment, making them four times more resilient to unexpected situations.

Diffusion Models Don't Fail at Text Because They Can't Reason — They Fail Because They've Never Seen the Input

Text-to-image AI models fail at rendering complex text and formulas not because they can't reason, but because they've never encountered these inputs during training. GlyphBanana solves this by injecting character templates directly into the model's processing, bypassing the gap entirely—a practical tool for teams automating documents, scientific figures, and multilingual designs without retraining.

Unsupervised RLVR Hits a Ceiling Set by the Initial Distribution, Not Compute

A new study reveals that training AI systems through self-improvement has a hard limit set by the initial training data, not raw computing power. Once models exhaust the knowledge embedded in their starting point, they begin collapsing into repetitive, useless outputs—meaning better pre-training data is more critical than throwing more compute at the problem.

Sparse Attention Degrades Long-Form Quality in Ways Standard Perplexity Benchmarks Don't Catch

Sparse attention speeds up AI models for massive documents but secretly breaks their ability to connect ideas across long distances—while appearing perfect on standard tests. This discovery exposes a critical blind spot: efficiency tricks that look safe actually cripple reasoning on real long-document tasks, affecting anyone building document search or analysis systems.

CBCT Tells You Where the Tissue Was. Ultrasound Tells You Where It Is Now.

Surgeons navigate using CT scans that become outdated the moment a patient breathes or tissue shifts. This framework pairs CT with a robotic ultrasound probe that continuously tracks tissue movement in real time, automatically updating the surgical map without needing new scans. It transforms static imaging into live, deformable guidance for abdominal surgery.

High-Noise Diffusion Steps Contain Low-Res Information — Processing at Full Resolution Is Wasted Compute

High-noise diffusion models waste compute by processing images at full resolution when early denoising steps only need low-resolution information. This research cuts computational costs by 40% by dynamically lowering resolution in early stages and gradually increasing it as details emerge, enabling faster image generation on phones and cheaper server inference without sacrificing quality.

Factual Associations in LLMs Are Stored as Low-Rank Subspaces in Mid-Layer MLP Weights

Scientists pinpointed exactly where language models store facts—in tiny, compressed sections of mid-layer weights—enabling surgical corrections to individual false beliefs without damaging related knowledge. This breakthrough lets AI developers fix errors and update outdated information without expensive retraining, moving toward safer, more maintainable AI systems.