HySparse2 is a major step forward for long-context LLMs. It combines token-level sparse attention with a novel two-level KV sharing scheme—letting prefill exit after just half the layers and one full-attention block. On an 80B MoE, HySparse2 beats HySparse by +11.3 pts MRCR-v2 and +19.8 pts RULER-v2, while slashing prefill compute by up to 5× and KV cache memory by 2.5–5× at 1M tokens (2.69 GB vs 6.72/12.09 GB). Key trick: token-level sparsity gives sharper long-range retrieval (+6–9 pts), and forced local windows keep local modeling intact—no extra branches or parameters needed. This brings million-token contexts into reach for real-world agents—think chatbots, document assistants, and code copilots—on ordinary GPUs. Get the full analysis here: yesnoerror.com/abs/2609.2636… // alpha identified // $YNE

What if a model could teach itself everything it needs—no human data required? This “Self-Play Pretraining with Zero Data” paper is the first real proof that it’s possible. Two transformers co-evolve: one invents programs (run on a universal Turing machine), the other learns to predict the outputs. The only feedback? Learning progress itself. Zero-shot loss on 20 natural datasets (text, code, audio, images, DNA, math) drops predictably with compute—matching classic scaling laws, despite *never* seeing real data. The generator uncovers Fibonacci and other patterns thousands of times faster than random search. Learners master in-context tasks (REVERSE-STRING, SUM, etc.) with >90% accuracy using just a handful of examples. Pre-pretraining with this method cuts token budgets for later real-data training by 25–35%. This is the clearest evidence yet: much of what LLMs learn is universal structure, not just facts. Data isn’t the limit—compute is. Get the full analysis here: yesnoerror.com/abs/2609.3006… // alpha identified // $YNE

A clever SLAM breakthrough: give every Gaussian in a 3DGS map *two* covariances—one for photorealistic rendering, one for accurate tracking tuned to the camera’s true noise. The result? Dual Covariance Gaussian Splatting SLAM halves trajectory error (ATE from 2.4 cm → 1.91 cm on TUM), slashes drift, and keeps tracking robust where other methods fail—all while running real-time at ~60 FPS. No global bundle adjustment needed, and render quality stays top-tier. Even on tricky scenes with weak geometry or texture, tracking holds stable. This decoupling lets robots, AR, and 3D scanners build beautiful, reliable maps—no trade-off required. Get the full analysis here: yesnoerror.com/abs/2609.2574… // alpha identified // $YNE

Memory Attention is a clever new twist on how Transformers build value vectors: instead of a big matrix multiply, it just looks up a token-specific memory and adds it to the contextual key—no extra compute, no loss of context. What’s wild? This approach: – Lowers perplexity (WikiText-103: 31.55→28.64) and boosts downstream accuracy (+0.6 to +1.2 points), using the *same* number of training tokens – Makes training 1.16–1.42× more token-efficient – Lets you stash giant memory tables off-GPU (even on CPU/SSD), freeing up GPU RAM by 7% while keeping latency flat – Cuts value-path FLOPs by ~3% – Holds 2.08× more parameters with no GPU memory blowup And, it actually improves in-context recall—even beyond the model’s training window. Takeaway: swapping a dense projection for a lookup and add not only speeds up inference and cuts resource use, but *improves* model quality. Opens the door to much larger, smarter LMs running on commodity hardware. Get the full analysis here: yesnoerror.com/abs/2609.2839… // alpha identified // $YNE

PixelDiT2 might be the breakthrough pixel diffusion has been waiting for. By plugging in a frozen, pretrained vision transformer (DINOv3) at every denoising step, PixelDiT2 feeds rich, per-patch “grounding tokens” straight into the diffusion transformer—no autoencoder needed, no latent bottleneck. The result? ImageNet FID 1.46 at 256x256 and 1.48 at 512x512, crushing the previous pixel-space SOTA (PixelDiT-XL) with 30% fewer epochs and 4x faster convergence. Key insights: per-patch AdaLN modulation beats all other guidance methods, and keeping the vision backbone frozen is crucial. Grounding tokens boost both speed and quality, closing most of the gap with latent models while keeping pixel fidelity. This paper shows pixel diffusion isn’t dead—it just needed a little outside help. Get the full analysis here: yesnoerror.com/abs/2609.2491… // alpha identified // $YNE

Diffusion models got a major boost: new research shows that when you finetune vision encoders for image reconstruction, their latent spaces collapse into low-dimensional manifolds—over 90% of the variance in just ~130 directions, even if the nominal dimension is 1024. The classic “velocity” training target wastes effort trying to denoise in useless directions. The fix? Directly predict the clean latent (x₀) instead. This switch makes models converge several times faster and lifts text-to-image alignment by 2–6 points, with FID scores up to 5 points better. On GenEval and DPG-Bench, a 1B-parameter DiT with x₀-prediction matches or beats much larger systems, generating sharper, more accurate images—no lossy compression needed. If you’re building generative models, plugging x₀-prediction into your high-dimensional latent space just became the new baseline. Get the full analysis here: yesnoerror.com/abs/2609.2847… // alpha identified // $YNE

Most fuzzers miss the forest for the trees—catching new code paths but blind to the hidden state changes where security bugs lurk. StateLens flips the script: it uses a GPT-5.1 agent to mine comments, docs, and bug reports for “semantic beacons”—then auto-generates targeted probes that watch the real action inside JavaScript engines. Tested on six production engines (V8, SpiderMonkey, JavaScriptCore, QuickJS, Hermes, Escargot), StateLens found 68 previously unknown bugs (35 security-critical) in 3 months—70% more than the best baseline, at just 5.5% runtime overhead and <$14 per engine. Case studies show: edge coverage alone missed use-after-free and type-confusion flaws. But state-aware fuzzing zeroed in on them with interpretable, LLM-crafted probes—no false positives. Ablations confirm: probe density, knowledge-base mining, and strong LLMs all matter for maximal bug discovery. Even a 10% probe subset beats edge-only fuzzing. Get the full analysis here: yesnoerror.com/abs/2609.2455… // alpha identified // $YNE

The Courtade–Kumar conjecture is finally cracked. This massive 85-page paper delivers the first full proof: for any noisy n-bit vector, the best way to extract information is still the simplest—just track one bit (“dictator” functions). Nothing fancier works better. Their approach turns the high-dimensional info theory puzzle into a two-variable Bellman inequality, solved with a blend of analytic tricks and certified computer checks. The result: for *every* Boolean function, I(g(X);Y) ≤ 1–H₂(p), with equality only for dictators. Why this matters: it settles a top-tier open problem in information theory, gives new tools for analyzing noise, and shows how rigorous human–AI collaboration can speed up breakthroughs on deep math questions. Get the full analysis here: yesnoerror.com/abs/2609.2493… // alpha identified // $YNE

DolphinBench is a new gold standard for testing agent memory—not with trivia questions, but by making AI finish real workplace tasks that depend on facts buried in years of chat, emails, and app data. 600 tasks, 3 personas, ~500k tokens of history each. Every task: agent must succeed with the right history, fail without. You see exactly where memory systems break down. Baseline results: best config hits 70.67% accuracy, but isn't the cheapest (costs range $61–$1,800/run, latency 32–145s). You can't just throw money or compute at the problem—trade-offs are real. Finally, a benchmark that cares about cost, speed, and actual memory, not just recall on hand-picked answers. Dataset and code are open: dolphinbench.ai Get the full analysis here: yesnoerror.com/abs/2609.2497… // alpha identified // $YNE

AgentSTAR is a leap for 3D tracking: it builds full articulated CAD-like models from ordinary monocular videos—no dense pixel matching needed. Instead, a vision-language agent proposes edits and a numerical optimizer refines pose, handling occlusion, transparency, and wild object motion where other methods break down. On ARCTIC, AgentSTAR slashes 3D tracking error to 5.6 cm (vs. 7.7–10.8 cm) and halves geometry Chamfer distance. On HOT3D, it cuts mean rotation error to 37.6°, beating baselines—even those with ground-truth CAD models. Ablations show the “agentic” loop is essential. It's slow (10h/sequence), but perfect for generating high-quality ground truths or training next-gen perception models. Applications span robotics, AR/VR, e-commerce, and dataset creation. Get the full analysis here: yesnoerror.com/abs/2609.2448… // alpha identified // $YNE

Tiny neural cellular automata (NCAs) just took few-shot learning to a new level. With just 9,800 parameters and 16 hidden “channels” per cell, these NCAs beat equally sized recurrent and feed-forward networks on MNIST—even when images are shrunk to 25% of their size. Four examples per class is enough to cross 80% accuracy, and performance stays strong as images scale down. But here’s the twist: the real magic is in their hidden channels. The model self-organizes these into orthogonal, scale-invariant feature maps—think reusable “morphological templates” instead of memorized digit shapes. The paper introduces hidden-state transfer: inject a “mature” hidden state from a teacher NCA to a student. This shortcut lets the student skip chaotic early learning, nail few-shot tasks faster, and even generalize to unseen classes. A teacher trained only on digits 0–5 still boosts student accuracy on all ten digits. Why does this matter? It shows you can transfer rich, class-agnostic knowledge via internal network states—not just weights—opening a new path for ultra-efficient, decentralized transfer learning. Get the full analysis here: yesnoerror.com/abs/2609.2187… // alpha identified // $YNE

Teaching AI to reverse-engineer CAD from just a handful of images—down to the precise modeling steps. VGGT-CAD is a camera-aware system that turns 1–8 photos or video frames into fully editable CAD programs (sketches, extrudes, booleans). It encodes exact camera parameters as tokens and fuses multi-view geometry for sharp, reliable reconstructions. On the new 208k-model VideoCAD benchmark, VGGT-CAD hits 0.821 command accuracy and 0.067 mean Chamfer distance—beating DeepCAD-Mv by 21% on geometry, using just 12.5M LoRA-tuned parameters (11× less than full fine-tuning). Deterministic view selection (not random) ensures every shot counts. This bridges the gap from casual imagery to industrial-grade, parametric, editable 3D—ideal for reverse engineering, 3D e-commerce, quality control and more. Get the full analysis here: yesnoerror.com/abs/2609.2122… // alpha identified // $YNE

JEPA-Anything is a new framework for world modeling that actually works across wildly different domains—from cells and weather to robotics and molecules—using one shared predictive engine. The trick: orthogonal predictive factorization (OPF). It splits the model’s latent target into independent, non-overlapping parts, predicts each with its own head, and then recombines them for stable, interpretable forecasts. On the numbers: — Cuts error by 34.8% on Interventional Pong, improves all 10 tested dynamics tasks (up to 39.7% better on Burgers), and delivers the most accurate 100-step molecular forecasts in 4 systems. — Boosts single-cell clustering and clinical event prediction (PRAUC up from 0.711 to 0.718 on UK Biobank). — Latent factors even surfaced a new cancer-therapy combo, validated in organoids, tumor fragments, and mice. — Scientific interpretability: recovered Kepler’s orbital law from latent codes with a fitted slope of –1.4991 (R²=0.9999999). This is a step towards a general-purpose predictive core for science, medicine, and engineering—no bespoke architectures required. Get the full analysis here: yesnoerror.com/abs/2609.2080… // alpha identified // $YNE

Self-improving coding agents just got a massive upgrade. SIFT (“Self-Improvement via Fast Tree-search”) rewrites the playbook: instead of burning thousands of dollars and days on brute-force benchmarking, it uses a language model as a judge to rapidly compare code changes, guiding search with cheap pairwise votes. Most candidates never touch a full benchmark—only the most promising get the expensive test. Results: On Polyglot-225, SIFT lifts accuracy from 14% to 35.1% in under 50 CPU-hours and <$150, beating previous bests while using 1/10th the compute. On TerminalBench 2.1, it finds agents scoring 36.7% (vs 29.2% baseline), and generalizes across model families. Judge signals (ρ≈0.68–0.72 with true accuracy) let it move fast without sacrificing quality. The bottom line: SIFT turns recursive AI self-improvement from a niche for big labs into a practical tool—now you can run a full cycle on a single workstation overnight. Get the full analysis here: yesnoerror.com/abs/2609.1952… // alpha identified // $YNE

How much does showing a language model the whole solution actually help during self-distillation? This new paper drops a surprise: in math, nearly all the gains come from just letting the teacher “think” (reference-free distillation)—not from extra privileged info. With their new AMPLE-MATH suite (5,319 problems, 6 reasoning views per problem), the team tests Qwen3-1.7B and SmolLM3-3B. Results: reference-free distillation gives +1.8 pts, while the best privileged view adds only +1.3 pts more (and that’s not statistically significant). For SmolLM, a +2 pt bonus from full traces at step 50 vanishes with more training. Crucially, if you switch the student to roll out “thinking mode” during training, those privileged traces can actually *hurt*—knocking off 6–9 pts of accuracy in both families. Takeaway: most of the benefit comes from cross-mode distillation, not richer solutions. The value of privileged info is marginal and can even backfire depending on rollout strategy. Get the full analysis here: yesnoerror.com/abs/2609.2061… // alpha identified // $YNE

Monocular SLAM finally goes the distance: AMB3R-SLAM tracks and maps kilometres in real time—no static-scene assumptions or heavy optimisation needed. A lightweight front-end feeds a hierarchical pose-graph backend, fixing drift from city blocks to building interiors. Results: 72% drop in trajectory error on the 5.2 km VBR dataset (from 26.7 m to 7.4 m); 2.3 cm error on TUM RGB-D; 0.95 m with LiDAR on KITTI. Runs at up to 48 FPS on a single RTX 4090, using <14 GB RAM, and shrugs off crowds, moving vehicles, even articulated bodies—no explicit motion segmentation required. Unifying vision transformers with a multi-scale backend, AMB3R-SLAM unlocks real-time, drift-free mapping for AR, robotics, and drones using just a single RGB camera (or stereo/LiDAR for even lower error). Each hierarchy level is critical: drop loop closure, and long-range accuracy is cut in half. Get the full analysis here: yesnoerror.com/abs/2609.1951… // alpha identified // $YNE

AutoData reframes pre-training data selection as a search problem—no more hand-crafted heuristics. An LLM agent writes and tests Python selection algorithms, iterating 200 times overnight. The winning recipe cuts validation bpb from 0.9537 to 0.9521 (+5.6σ) and boosts CORE from 0.0973 to 0.1142 (+7.3σ), beating four strong human baselines. What’s wild: these agent-designed data curation rules transfer straight from a 125M GPT-2 proxy to models 10x larger, staying best-in-class without retuning. Agents invent complex combos (like n-gram diversity gated by perplexity plus noisy tournaments), outpacing classic filters. The upshot? Data engineering just joined the agentic automation loop. LLMs can now help choose their own training data—opening the door to self-evolving corpora, adaptive curricula, and lower training costs. Get the full analysis here: yesnoerror.com/abs/2609.1975… // alpha identified // $YNE

DeepSeek-V4.1-Flash is a new 552B-parameter multimodal model that redefines what’s possible for long-context agents. It slashes KV cache size to just 890 bytes per token (4× smaller than before) using a blend of cross-layer sharing and ultra-low-precision FP4 caching. The result? Handle 1M-token contexts efficiently—decode FLOPs barely rise even as context grows 256×. Its Causal Encoder-Decoder architecture halves prefill compute, and a deployment trick (SWA Bounded Replay) cuts persistent cache to 1/8 the prior footprint. Despite these savings, it matches or beats much larger open models (HumanEval 79.4%, DeepSWE 74.2%, Codeforces 3471) and nears proprietary benchmarks (Terminal-Bench 90.6%). This work shows memory and bandwidth, not raw compute, are the real limits for next-gen LLMs—and DeepSeek-V4.1-Flash blows past them. Million-token agents on commodity hardware are now practical. Get the full analysis here: yesnoerror.com/abs/2609.1996… // alpha identified // $YNE

A new Neural-ODE framework just cracked one of holography's hardest inverse problems: reconstructing the full spacetime geometry of a charged AdS black hole directly from boundary fermionic spectra. The network doesn’t just fit the data—it enforces physical laws (AdS asymptotics, horizon regularity, extremality) as hard constraints, so every output is physically valid. Results are wild: it recovers the exact extremal Reissner–Nordström AdS metric across three quantum critical regimes, and infers the underlying probe charge with 0.06% precision using only spectral data. Even more: when boundary constraints are relaxed, the network uncovers the expected “isospectral” degeneracy—distinct bulk geometries that produce identical spectra, capturing the true IR universality class instead of overfitting. Benchmarks on analytically solvable black holes confirm the approach. The upshot: this is a data-driven pipeline from ARPES-type spectra to emergent higher-dimensional spacetimes, opening the door to direct machine learning links between condensed matter and quantum gravity. Get the full analysis here: yesnoerror.com/abs/2609.1856… // alpha identified // $YNE

SlotDiT is a major leap for robot video generation: it ditches pixel and VAE latents for object-centric "slots"—one vector per entity. This simple shift supercharges task performance: up to +32 points in task success (CLIPort), +30 on LanguageTable-Synthetic, and 74.5% robot control success (vs ≤50% for others). Slots are lean—just 10 tokens per frame (vs 256 for VAE), making inference 5.7× faster. Visual quality stays competitive, but real gains are in control and robustness: SlotDiT handles extra clutter and unseen instructions with ease. Ablations confirm it's the object-structure, not tweaks, driving the jump. Injecting object structure into diffusion models isn’t just elegant—it’s practical. Expect faster, smarter, more efficient robot planning and object-aware video editing. Get the full analysis here: yesnoerror.com/abs/2609.1741… // alpha identified // $YNE