Trending ML Papers

What it is. This paper shows how to keep improving a large language model on very long inputs — think a million-plus words of context, like a whole codebase or a full agent session — without needing a giant fleet of GPUs. The trick is to process the huge shared prompt just once, save only the small pieces that later parts of the model actually need, and then replay short chunks of the model's response one at a time so memory never explodes. The authors demonstrate this on eight GPUs, pushing training context up to 2.1 million tokens and stress-testing to 4.46 million.

Where it fits. AI agents that browse the web, use tools, or work through long documents accumulate huge histories, and there is a growing mismatch: models can read a million-token prompt at inference time, but the reinforcement learning (RL) step used to fine-tune them — where the model has to remember every intermediate calculation so it can adjust its own weights — usually caps out around a quarter-million tokens. Prior solutions (Ring Attention, DeepSpeed-Ulysses, ByteScale) all extended context length by throwing hundreds or thousands of GPUs at the problem. LongStraw takes the opposite tack, asking how far you can push on a fixed, modest hardware budget.

Why it matters. Long-context training is currently a rich-lab-only sport, which pushes agent research toward companies with massive infrastructure. If you can train million-token agents on a handful of GPUs instead of a datacenter, small teams and academic labs can plausibly compete on the same problems as frontier labs. The authors are transparent that this is an execution capacity demonstration — the distributed gradient pieces are not fully wired up yet — so treat this as a promising engineering blueprint rather than a shipped training recipe.

What it is. VideoChat3 is a 4-billion-parameter open-source model that watches video and answers questions about it — everything from 'when does the person start cooking?' to 'what is the cat's bowl color?' — including live, streaming video where it decides on its own when to speak up. Two ideas power it: a video encoder that compresses across time by treating groups of frames together instead of one-by-one, and an adaptive resolution scheme that only spends compute on visually interesting moments. The team is releasing weights, code, training strategy, and all three training datasets.

Where it fits. Video understanding sits at the intersection of vision and language models. Existing systems either specialize (great at short clips but poor at hour-long videos, or vice versa), stay closed like Gemini and Kimi's video features, or are only partially released — with the training data recipe kept private. That last piece has become a big deal because researchers can no longer tell why a model is good. VideoChat3 is aimed squarely at closing that reproducibility gap while also being cheaper to run.

Why it matters. For anyone building products around video — surveillance, sports analytics, accessibility tools, live moderation, customer-support video calls — the practical bottlenecks have been cost per hour of footage and vendor lock-in. A small, fully open, streaming-capable model that outperforms similarly-sized peers turns 'have to call an API' into 'can run in-house.' Whether it is competitive with the closed frontier models at the higher end is still an open question, but the efficiency gains for the 4B tier look real.

What it is. SEED is a training method for AI agents that solve long, multi-step tasks — things like navigating a website, searching through documents, or running a text-based game. Its core idea: after an agent finishes a task, have the same model look back at what it just did and write out plain-English 'lessons learned' (which workflows worked, which observations mattered, which mistakes to avoid). Those lessons are then baked into the model's weights, so the next time the agent tries a similar task it acts smarter without needing the lesson handed to it at inference time.

Where it fits. The standard way to train agents today, reinforcement learning with outcome rewards, tells the model 'you succeeded' or 'you failed' at the end of a whole session but not which specific decisions along the way were the good or bad ones. This 'credit assignment' problem has become one of the central challenges as agents take on longer tasks. Prior approaches used static skill libraries or retrieved past experiences at inference time, but those get stale as the agent improves. SEED's twist is that the reviewer and the agent are the same model, so the reviewer's judgment automatically keeps up as the agent evolves.

Why it matters. Agents are the current big product bet — coding copilots, web browsers, customer-service systems — and their weakest link is learning from long trajectories where feedback is sparse. If self-generated hindsight can be turned into permanent skill without needing a bigger teacher model or a memory database at runtime, it means agent quality can be improved cheaply and continuously in-house. Reported gains are substantial on standard agent benchmarks (from 21.9 to 91.8 on ALFWorld, for example), though generalization to messier real-world tasks like production coding agents remains to be seen.

What it is. This paper shows you can dramatically cheapen reasoning-model training by running the expensive part on a small model first, then transferring only the useful changes to a bigger model. The team compares a small model before and after reinforcement learning and treats the difference — 'what did RL make this model more or less likely to do?' — as a training signal for a stronger model. The stronger model never has to go through the slow RL loop itself. Concretely, they lifted Qwen3-1.7B from 48.3% to 58.3% on the AIME 2024 math competition benchmark in about 4 hours on 8 GPUs, matching what took another team a full week on 32 GPUs.

Where it fits. Reinforcement Learning with Verifiable Rewards (RLVR) — training a model against tasks with clear right/wrong answers like math problems — has become the dominant recipe for turning language models into reasoners (see DeepSeek-R1, o1-style systems). But every rollout during RL means the target model has to generate long responses, which gets crushingly expensive as models get bigger. Prior 'distill from a bigger teacher' approaches don't help here, because we want the small-model-trained-with-RL improvement, not the small model's raw abilities. Direct-OPD reframes the question as: what if you distill only the delta between a model before and after RL?

Why it matters. If this holds up, RL post-training economics change: labs can iterate the expensive RL loop on cheap 1B-2B models and then broadcast improvements to their expensive flagship models in a few GPU-hours. That accelerates the pace at which frontier models can absorb new reasoning capabilities and lowers the compute moat around post-training. The main caveat is that the technique has been validated on math reasoning with verifiable answers — it's not yet clear how far the 'RL delta as implicit reward' idea generalizes to messier domains like open-ended coding or dialog.

What it is. ABot-N1 is a single foundation model for robot navigation that handles five different task types — 'walk to this GPS coordinate,' 'find the coffee shop,' 'follow that person,' 'go to the red couch,' 'follow these directions' — instead of needing a separate specialist model for each. It works by splitting the brain in two: a slower reasoner (a 4B vision-language model) reads the scene, thinks out loud, and drops a literal pixel marker on the camera image saying 'go here next,' while a faster 2B model turns that marker into smooth motion commands in real time. That intermediate 'here is where I plan to walk, and here's why in words' step also makes the system inspectable when things go wrong.

Where it fits. Robot navigation research has long lived in silos: point-to-point navigation, following spoken instructions, chasing after a person, and searching for objects each had their own specialized model. Recent work has tried to unify these into one model, but doing so often produces black-box policies that trade accuracy for generality and cannot explain themselves — a serious problem when the robot is running around a real street or office. The 'slow reasoning + fast control' split is inspired by how humans (arguably) plan movement, and the specific 'pixel goal' interface is the new twist that ties both halves together transparently.

Why it matters. For anyone deploying mobile robots — delivery, warehouses, hospitality, home assistants — this points toward one model instead of five, which simplifies fielding, updates, and safety review. The interpretability angle is especially relevant for regulated deployments: when a robot fails, engineers can now inspect the chain of thought and the pixel target instead of guessing at a latent vector. Reported urban navigation numbers (77.3% success on point-of-interest tasks, up 35 points over prior work) are strong, though the real test will be how gracefully it handles the crowded, weird edge cases of real-world sidewalks and homes.