Trending ML Papers

What it is. ABot-Earth 0.5 is a generative AI model that builds realistic, walkable 3D versions of real places on Earth from ordinary satellite photos. Instead of sending camera-equipped planes or LiDAR rigs to scan a city block by block, it learns from existing high-quality 3D reconstructions and then 'hallucinates' the missing detail — buildings, trees, roads, facades — for any new location, at roughly under 10 minutes per square kilometer. The team claims an initial release already covering 300+ cities across 190+ countries that can be streamed and explored inside a web map.

Where it fits. Photorealistic 3D maps (think Google Earth's 3D tiles) have historically been built by flying planes and stitching thousands of oblique photos together — slow, expensive, and limited to wealthy cities. The AI community has been trying to use generative models to shortcut this, first for individual objects (a chair, a car) and more recently for whole outdoor scenes. The under-the-hood representation here is 3D Gaussian Splatting, which has quickly become the default way to render real-world places in high fidelity because it handles tricky stuff like leaves, glass, and water better than older mesh-based methods.

Why it matters. If satellite-to-3D really works at this cost and quality, large-scale digital twins stop being a luxury for big tech and city governments. That opens up cheaper drone simulation and training (the paper highlights UAV navigation), more realistic geospatial planning tools, and better immersive maps for consumer apps. The caveats: this is a v0.5 release from a single lab's marketing-flavored report, and 'planet-scale' demos historically look better in cherry-picked tiles than in the average suburb, so the real test will be how it generalizes outside dense urban training data.

What it is. Kuaishou (the company behind the short-video app of the same name) released an open-source multimodal model — meaning it handles text, images, and video together — aimed squarely at understanding very long videos and acting as an agent (writing code, calling tools, searching the web). The model has 30B total parameters but only activates 3B per token thanks to a Mixture-of-Experts design, which keeps it cheap to run. Its headline trick: it can ingest up to 256,000 tokens of context — long enough to reason over hour-long videos frame by frame — without choking on memory.

Where it fits. Video understanding is the next frontier for multimodal models. Today's systems can describe a still image fluently but mostly skim videos by sampling a handful of frames, which makes them blind to anything that happens between the sampled moments. The two bottlenecks are (1) attention cost grows quadratically with sequence length, so long videos are expensive, and (2) bolting on video and agent skills usually causes 'catastrophic forgetting,' where the model gets worse at the math and reasoning it used to do well. Keye-VL-2.0 adapts a recent technique called DeepSeek Sparse Attention to the multimodal setting to address the first problem, and uses a multi-teacher distillation recipe (called MOPD) for the second.

Why it matters. Long-video understanding is the gating capability behind real products: automatic meeting recaps, surveillance triage, lecture summarization, in-app video search, and any agent that needs to watch a screen recording and act on it. Kuaishou's release puts a credible, open-weights competitor in the hands of developers who can't pay for Gemini-tier APIs, with comparable scores on long-video benchmarks. What's still unclear is whether the gains hold up in messy real-world video (poor lighting, accents, vertical-format social clips) and how compute-efficient inference truly is once you account for serving infrastructure.

What it is. EvoArena is a benchmark that tests whether AI agents can keep up when their environment keeps changing — software gets new versions, terminal commands change syntax, users update their preferences. Most agent benchmarks today take a snapshot in time and never move; this one builds 'chains' where the same task evolves through several releases, and the agent has to figure out what changed without throwing out what still works. The authors also propose EvoMem, a memory system that works like Git: every time the agent updates what it knows, it keeps a versioned patch (with the reason for the change), so it can later look back at why an old rule no longer applies.

Where it fits. AI agents — systems that use a language model to operate software, run code, or do research over multiple steps — have been racing forward on benchmarks like SWE-bench and WebArena. But those benchmarks are static: the bug is the bug, the website never updates. In production, APIs change, code is refactored, users change their minds. Existing 'memory' for agents typically just overwrites the latest state, so when behavior needs to differ between versions, the agent loses track. The work positions itself as the missing 'changes over time' axis for agent evaluation.

Why it matters. Anyone building a real agent product — coding copilots, customer-support bots, ops automation — has felt this pain: the agent works on day one and silently breaks on day fifty because the underlying tools moved. EvoArena gives the field a shared way to measure that, and the headline result is bracing — even strong agents score under 40% on chained, version-aware tasks. The memory technique offers a modest 1.5% lift on EvoArena and a more meaningful 4-6% on standard benchmarks, suggesting that 'remember what changed and why' is a legitimately underexplored design ingredient. Whether the patch-history approach scales to messy production deployments is the obvious next question.

What it is. MiniMax introduced a new way to make the 'attention' part of a transformer model — the bit that compares each word to every other word — far cheaper when the input is very long. Instead of every token looking at every other token, MSA splits the past into blocks and uses a tiny scoring network to pick only the most relevant blocks for each query. On a 109-billion-parameter model with both text and image training, MSA matched the quality of the standard approach while cutting per-token attention compute by roughly 28x at one-million-token context length, and produced 14x faster prompt processing and 7.6x faster generation on Nvidia H800 GPUs. The technique is shipping in MiniMax-M3, a model already public on Hugging Face.

Where it fits. Attention is the famous quadratic-cost component of transformers: doubling the input quadruples the work. As context windows have grown from a few thousand tokens to hundreds of thousands (and now millions), this cost has become the dominant bottleneck for any application that wants to feed in long documents, full code repos, or hour-long videos. There's an active arms race on 'sparse attention' methods that look at only a subset of the past — DeepSeek, Moonshot, and others have shipped variants in the last year. MSA's pitch is that it stays simple, plays well with the Grouped-Query Attention design most production models already use, and was carefully co-designed with the GPU kernels to translate theoretical savings into real wall-clock gains.

Why it matters. Long-context is the unlock behind a lot of the agent and copilot use cases people are excited about — feeding in a whole codebase, an entire patient record, a multi-hour transcript. If you can deliver the same quality at a fraction of the cost, the economics of those products change: prompt-heavy assistants become viable on commodity hardware, and serving margins improve. Two caveats: sparse attention historically leaves small quality gaps on tasks that need broad, fuzzy recall over the whole context, and the speedups quoted here are for the best-case 1M-token regime — most apps will see smaller (but still real) gains.

What it is. WeaveBench is a benchmark that tests whether AI agents can do realistic computer work that mixes clicking around a graphical desktop with running terminal commands or editing code — the way a human actually uses a laptop. It contains 114 tasks across eight job-shaped domains (data analyst on call, game dev debugging, web ops, finance, photo editing, and more) that run on a real Ubuntu desktop. It also ships a 'trajectory judge' that doesn't just check the final answer but watches the whole sequence — files, screenshots, logs — and can flag cheating shortcuts like an agent fabricating a screenshot or hard-coding a metric.

Where it fits. There are roughly two camps in agent evaluation today: GUI benchmarks (think OSWorld) measure clicking and visual tasks; coding benchmarks (think SWE-bench) measure terminal and code-editing tasks. Real jobs aren't either — a site reliability engineer reads a dashboard chart, then SSHs in to fix a config, then re-reads the chart. Letting an agent solve a 'GUI' task by just running a shell command (or vice versa) is a known shortcut that inflates scores. WeaveBench, from Microsoft Research and partners, is an attempt to force agents into the messy hybrid setting and to grade them on the journey, not just the destination.

Why it matters. Computer-use agents are one of the most-hyped near-term product categories — vendors are racing to ship 'assistants that use your apps for you.' WeaveBench gives buyers a sharper way to ask 'does this thing actually work on my workflow?' rather than relying on cherry-picked demos. The headline is sobering: the best frontier model in the test reaches only 41.2%, and the trajectory judge shows that simpler grading materially overstates performance. For PMs and founders, that's a useful reality check on how far the underlying agents are from being trustworthy on multi-step desktop work.