Latest news, beside the leaderboard

Agentic post-training (scaling multi-turn RL and SFT) requires massive GPU investments, but AI labs lack reliable heuristics to predict which base model checkpoint possesses the highest potential before committing to multi-million-dollar post-training runs. Cold-start zero-shot evaluations on SWE-bench fail because unaligned base checkpoints cannot emit formatted tool invocations, while single-turn patch benchmarks ignore multi-step state management. Researchers from NVIDIA and UC Berkeley (including Bryan Catanzaro and Ashish Vaswani) present a lookahead evaluation framework (arXiv:2610.10478). By replaying successful post-trained trajectories and rerunning unit tests after every edit, they isolate the 'decisive step' that flips a repository from failing to passing. They introduce three lightweight evaluation screens at this decisive step that require zero cold-start tool calling: Decisive-Action Bits Per Byte (BPB), Patch MCQ, and prefix-conditioned pass@K. Across ten pairs of public base and post-trained models, these screens rank candidate checkpoints in tight agreement with final post-trained SWE-bench Verified pass@1 scores, establishing a low-cost lookahead methodology for model selection.

Mainstream coding agent benchmarks like SWE-bench frame evaluation around issue-derived tasks: feeding an agent a bug description and expecting an end-to-end patch. But does this reflect genuine developer practices? JetBrains Research analyzes 4,782 production sessions of professional software engineers inside JetBrains IDEs (arXiv:2610.09633). For long interactive sessions (>=3 turns, comprising 33% of production traffic), user requests span a diverse mix of intent types—project codebase Q&A, strategic planning, code review, refactoring, and test execution—with users frequently transitioning between types mid-session. To align benchmarks with real developer task flows, JetBrains introduces SWE-TaskFlow, an approach that transforms issue-based benchmarks via prompt-splitting and verifiable repository QA into calibrated multi-stage workflows guided by a TaskFlow Alignment Score (TFAS). A pilot study across 700 SWE-Bench Pro tasks demonstrates that sequential multi-step interaction protocols nearly double agent inference expenditure without stable improvements in resolve rates, proving that the interaction protocol itself is a critical, previously unmeasured dimension of agent evaluation.

In modern coding agent ecosystems (such as Claude Code, Cursor, Cline, and Antigravity), Agent Skills—specialized instruction files like `SKILL.md` and `CLAUDE.md` that dictate project architecture, commands, and rules—are continuously revised by developers alongside source code. Yet the concrete impact of these revisions on agent behavior and inference cost has remained largely unquantified. In a comprehensive empirical audit (arXiv:2610.04832), researchers analyze 2,608 first/last revision pairs across 3,159 Skills to measure the effects of revisions across 21 foundation models and four sandboxed coding agents. The study reveals that 55% of revisions alter specific rules or procedures. Adding a concrete rule raises compliance in single answers by +0.41 across open-weight models, increases required action adherence by +0.23 across sandboxed agents, and improves final task correctness by +0.10 in blind evaluations. Critically, these gains are overwhelmingly driven by rules that specify explicit CLI commands or exact file paths, whereas abstract stylistic guidance offers negligible lift. The paper also documents the performance and token trade-offs of dynamic on-demand skill loading.

When model capabilities exceed human expert evaluative bandwidth, achieving Recursive Self-Improvement (RSI) without external verifiers or compilers becomes the paramount frontier of AGI. While reinforcement learning with verifiable rewards (RLVR) thrives in formal code and math, open-ended research and complex reasoning tasks lack scalar ground truth, and solitary models evaluating their own outputs suffer from homogeneous confirmation bias. Sakana AI introduces MASS (arXiv:2610.12176, project: sakana.ai/mass), an RSI framework anchored in Multi-Agent Self-Supervision. Driven by a single base model (such as Qwen3.6-27B), MASS tasks the model with concurrently acting as task solver, workflow optimizer, and self-evaluator. The framework alternates between evolutionary multi-agent workflow discovery and supervised fine-tuning (SFT) over synthesized trajectories. Across two successive MASS self-evolution cycles, performance per output token increases by 1.2x to 1.6x across open-ended research suites (MLR-Bench, ScienceAgentBench, DSBench, AstaBench). Head-to-head win rates against the base model surge from 53.9% in round 1 to 69.9% in round 2, while a student model trained on multi-agent traces decisively beats a single-agent baseline trained on 1.4x more tokens.

As autonomous coding agents achieve surging scores on benchmarks like SWE-bench, the prevailing assumption has been that coding proficiency primarily correlates with lines of code modified when aided by terminal search tools. However, agents routinely fail on subtle modifications in real repositories. Microsoft Research introduces CABRA (arXiv:2610.10610, code: github.com/microsoft/CABRA), a synthetic evaluation blueprint designed to isolate code comprehension from simple editing throughput. CABRA synthesizes programs as Directed Acyclic Graphs (DAGs) and scales task difficulty systematically along four orthogonal axes parameterized by n: Function Traversal, Function Search, Runtime Resolution, and Instruction Following. The findings establish that code comprehension—rather than tool invocation or editing volume—is the true bottleneck of autonomous coding agents. Crucially, the volume of tool calls allocated to code comprehension operations (such as READ and ANALYZE) serves as a substantially stronger predictor of an agent's success on SWE-bench Verified than the number of lines of code edited, with code and datasets fully open-sourced.

Endowing Multimodal Large Language Models (MLLMs) with robust 3D spatial intelligence and geometric reasoning is essential for embodied robotics. Existing systems rely on spatial coding agents—prompting MLLMs to generate and execute external Python geometry scripts (e.g., invoking OpenCV, point cloud packages, and coordinate projections) during inference. However, this tool-augmented architecture incurs massive latency overheads, execution dependencies, and frequent runtime runtime sandboxing failures. In newly released research (arXiv:2610.11366), researchers introduce SpatialOPSD (code: github.com/vermouth599/Spatial-OPSD), an on-policy self-distillation framework that internalizes agentic spatial capabilities directly into a standalone, tool-free MLLM. SpatialOPSD leverages summarized execution traces from spatial coding agents as privileged guidance during training. To prevent privileged information leakage from inducing repetitive generation and hallucinations, the framework introduces Repetition-Aware Distillation, pairing repetition masking with unlikelihood regularization. Empirical evaluations show that standalone SpatialOPSD outperforms tool-free baselines across diverse 3D spatial reasoning tasks while slashing latency and eliminating fragile external execution runtimes.

AMI Labs (Yann LeCun's Advanced Machine Intelligence) with NYU, INRIA Paris and Brown released H-JEPA (arXiv 2610.06805), an end-to-end recipe for a stack of action-conditioned JEPA world models, each predicting farther ahead in its own latent space and planning top-down via subgoals. Paper-reported: a three-level model reaches 73.3% success on Visual AntMaze vs 18.0% for flat LeWM, with less planner compute. MIT-licensed code plus 93 checkpoints are public on GitHub and Hugging Face.

Enabling LLM agents to distill and reuse modular skills from past task traces allows policies and skillbanks to co-evolve over time. However, conventional skill discovery systems face steep bottlenecks: evaluating newly proposed skills typically demands expensive and slow environment rollouts, while rewarding skills based purely on execution success conflates the intrinsic value of the skill with the general competence of the evolving actor. In newly published research (arXiv:2610.10164), researchers introduce UniSkill (repo: github.com/LimOkii/UniSKill). UniSkill leverages a unified shared policy to simultaneously execute environment tasks and generate structured edits (Add, Update, No Edit) to a persistent skillbank. Crucially, UniSkill evaluates proposed skills through Contrastive Action Feedback—measuring how substituting a retrieved skill with a proposed candidate widens the action log-likelihood margin between previously observed successful and failed trajectories—providing immediate actor-alignment feedback without requiring expensive new rollouts. Evaluated across diverse agentic benchmarks, UniSkill demonstrates superior sample efficiency and sustained policy refinement, with code fully open-sourced.

Generating cinematic video accompanied by synchronized, high-fidelity audio represents a premier frontier in multimodal AI. Traditional pipelines rely on disjointed workflows where silent video is generated first and audio is patched in post-hoc, leading to temporal misalignment, unnatural ambient acoustics, and broken lip-sync. The Kandinsky research team releases Kandinsky 6.0 Video (arXiv:2610.05608, code: github.com/kandinskylab/kandinsky-6, Hugging Face Diffusers integration). Powered by a dual-stream CrossDiT (Diffusion Transformer) architecture, Kandinsky 6.0 Video tightly couples a pretrained video generation stream with a newly trained audio stream via bidirectional cross-attention for joint temporal-semantic alignment. Available in two configurations—a 3B Lite variant and a 29B Pro flagship—the model generates 5-second video sequences accompanied by synchronized 44 kHz broadcast-grade audio, featuring native lip-sync and integrated Full-HD (1920x1080) super-resolution. The codebase, model weights, and Diffusers integration are fully released under the permissive MIT license.

Reinforcement Learning with Verifiable Rewards (RLVR) powers modern reasoning LLMs by translating post-interaction scalar outcomes into optimization signals. However, in group-relative objectives (e.g., GRPO), reward signals vanish completely when all rollouts within a group share the same score (such as widespread mutual failures), discarding rich diagnostic feedback regarding task requirements and failure modes. In smaller models (such as 2B parameters), up to 98% of rollout groups result in universal failure, leaving standard RLVR stranded at 0% task success. Salesforce AI Research introduces Self-Retrospection Distillation (SRD, arXiv:2610.08077, repo: github.com/SalesforceAIResearch/SRD). SRD instantiates prospective learning, using privileged post-hoc trajectories to supervise pre-interaction foresight representations within the same policy without adding inference latency. Across 10 tool-integrated reasoning and long-horizon agentic benchmarks, SRD delivers gains of up to 24.2 percentage points over baseline RLVR and self-distillation. Critically, in 2B model regimes where 98% of groups are all-failure and standard RLVR flatlines at 0.0%, adding SRD reaches a 60.6% success rate under identical rollout budgets.

OpenCode v1.19.0 (Oct 11) adds `opencode upgrade --major` and a TUI `/update` command to move 1.x installs to OpenCode 2 (tagged up to v2.0.26), stops auto-installing updates, and hardens PTY connection validation. The official V2 migration guide lists three intentional breaking changes: plugin API, server API/clients, and terminal client config.

In software engineering and knowledge-work tasks, autonomous coding agents operate via Direct Workspace Interaction (DWI)—issuing shell commands to navigate, inspect, and modify files within local repositories without external vector indexing. However, during extended interaction horizons, agents suffer severe context degradation: initial task requirements are purged from context windows by voluminous file dumps, read file provenances vanish, and listed but unopened candidate files are permanently forgotten, leading to premature task terminations and unfulfilled requirements. Researchers from KAIST introduce RunningTab (arXiv:2610.10444), an innovative agent interaction framework that replaces unreliable internal agent scratchpads with an environment-maintained 'running tab'. The tab persists three critical streams: dynamic requirement trackers, verified file excerpts with provenance links, and unopened candidate file stacks. When an agent attempts to finalize a deliverable, the environment triggers a mandatory 'Finish Check' barrier that blocks completion if unsatisfied criteria persist. Evaluated across Workspace-Bench, TheAgentCompany, and OfficeQA Pro benchmarks using frontier LLMs, RunningTab decisively outperforms vanilla DWI and self-refine baselines, establishing substantial gains in rubric satisfaction (TCR@70).

Whether LLM-based autonomous agents truly learn from interactive experience or merely regurgitate memorized knowledge remains a fundamental question in AI research. Most conventional agent benchmarks evaluate tasks (such as writing standard Python or navigating operating systems) heavily represented in pretraining corpora, creating severe data contamination that obscures whether agents are synthesizing new concepts or retrieving memorized patterns. Researchers introduce Learn2Play-Bench (arXiv:2610.08215, code: github.com/liushiliushi/Learn2Play-Bench, site: liushiliushi.github.io/learn2play-bench-website), a novel open-source benchmark constructed around text-based environments with entirely unfamiliar and counterintuitive mechanics. Agents must discover game physics and causal dependencies purely through trial-and-error interactions. The benchmark reveals two critical insights: retaining uncompressed, verbatim interaction logs decisively outperforms LLM-generated rule summaries, and the agent harness scaffolding (managing tool loops, memory, and reflection) exerts a larger impact on final performance than the choice of underlying foundation model.

Enabling service robots to execute open-ended human navigation requests across unfamiliar environments (such as locating reading glasses on a living room table and navigating to them) represents a critical challenge in embodied AI. Conventional navigation models rely heavily on domain-specific fine-tuning within specific simulated datasets, resulting in brittle real-world generalization when deployed in unseen layouts. Researchers from Zhejiang University's 3DV Lab introduce SuperNav (arXiv:2610.12126, code: github.com/zju3dv/SuperNav, project: zju3dv.github.io/SuperNav), an open-source agentic navigation framework that achieves universal scene navigation with zero navigation-specific fine-tuning. SuperNav decouples high-level cognitive reasoning—delegated to a frozen, off-the-shelf Multimodal Large Language Model (MLLM)—from low-level physical control executed by specialized robotic navigation tools. Utilizing a Unified Visual-Point Interface where the MLLM marks normalized coordinates directly on observation images, the agent revises decisions continuously based on visual feedback. Validated in the HM3D virtual benchmark and deployed on a real Unitree Go2 quadruped robot across multi-object and demand-driven navigation tasks, SuperNav decisively outperforms fine-tuned baselines.

OpenAI's Codex lead Tibo says GPT-6.1 Sol's default context in Codex and ChatGPT Work goes from 272K to 500K (~80% more) to cut compactions on long tasks, with no long-context fees when usage comes from a ChatGPT subscription. Separately, the official Codex changelog says GPT-5.5 retires from ChatGPT and Codex on all plans on October 14 (the API keeps it).

On Oct 11 the vLLM Semantic Router (vllm-sr) team released the Decision 3.0 family (d3, d3-flash, d3-mini, d3-nano, d3-lite, d3-edge) on Hugging Face under Apache-2.0. Built on Qwen3.5/3.8, the models take text, images and video and return probabilities for choice, yes/no and score questions in one call without generating text. Vendor-reported: the 27B d3 scores 64.7 on Jev Decision Index 0.3.1, ahead of Perplexity Decider v1.1 (62.8) and Decision 2.0 (55.9), with a 55 ms median text latency on one AMD MI325X.

Interactive virtual environments allow embodied AI agents to learn through exploration and practice, but creating worlds that are simultaneously faithful (rigid state dynamics and programmatic rules) and realistic (photorealistic visual distributions) has remained a critical bottleneck: physics engines lack visual fidelity, whereas generative video models suffer from compounding visual hallucinations during extended agent interactions. MirroS Lab and researchers introduce AgentGarten (arXiv:2610.12374, repo: github.com/MirroS-Lab/AgentGarten, site: mirros-lab.github.io/agent-garten), an open-source framework that decouples physics simulation backends from a shared neural renderer. Simulators maintain ground-truth state and execute code-defined rules without ingesting rendered frames, strictly preventing error accumulation. Visual observations are synthesized in real-time (>30 FPS) from exported geometric conditions via a neural renderer trained with Adversarial Forcing, making history prefilling differentiable through exact replay. Agents learn through visual perception, distilling execution trajectories into playbooks that succeeding generations inherit. In benchmarks such as hide-and-seek, agents autonomously discover obstacle-moving and ramp-climbing tactics in just 4 to 10 rounds (compared to tens of millions of rounds in classic RL), with code and environments fully open-sourced.

Token-level LLM routing—routing easy tokens to small models and switching to frontier models for critical reasoning tokens—presents an optimal trade-off between output quality and inference cost. However, current LLM serving engines (such as vLLM and TGI) are architected for single-model execution, suffering severe step desynchronization, batch admission latency, and extreme orchestration complexity when handling high-frequency token transfers across heterogeneous models. Researchers from Tsinghua University's NICS Lab present TokenRouter (arXiv:2610.12242, accepted at NeurIPS 2026, code: github.com/thu-nics/TokenRouter), an efficient and developer-friendly serving system engineered for token-level routed LLM inference. TokenRouter introduces a 'request-centric programming and model-centric execution' paradigm, enabling developers to write routing logic intuitively per request while the runtime handles asynchronous execution across subservers. Incorporating a Delayed-Batching Scheduler parameterized via discrete-time Markov chain modeling, a decoupled tri-loop architecture, and an instant handoff-resume mechanism, TokenRouter achieves 2.01x to 64.15x higher decoding throughput compared to existing serving platforms across diverse routing workloads, with complete code open-sourced.

Reinforcement learning (RL) post-training is foundational to scaling reasoning capabilities in large language models. However, its memory footprint remains a prohibitive bottleneck: storing full-sized gradient buffers alongside multi-state Adam optimizer moments frequently triggers out-of-memory (OOM) failures when attempting to train large models (such as 27B parameters) on standard compute hardware. In newly released research (arXiv:2610.06647), researchers introduce LoGRA, an efficient RL post-training framework available within the open-source Molt library (github.com/skzhang1/labs-molt). LoGRA compresses training representations by retaining useful learning signals inside compact low-rank gradient sketches accumulated directly during backpropagation, facilitating both memory-efficient parameter updates and streamlined policy synchronization. To counteract instability from gradient compression, LoGRA introduces a Predicted-KL step control mechanism that forecasts policy change magnitudes prior to parameter updates, dynamically attenuating disruptive updates. Evaluated across reasoning benchmarks, LoGRA reduces average training memory by up to 45.7% with zero degradation in task performance, successfully sustaining stable RL training of a 27B model for over 1,100 steps on a single eight-GPU node where standard dense Adam crashes with OOM.

GitHub Security Lab's MIT-licensed Fuzzing Taskflow, built on its Taskflow Agent framework, takes a GitHub owner/repo and lets an agent pick entrypoints, analyze the build, write harnesses, run AFL++, iterate on coverage, and write a per-crash vulnerability report with root cause and a suggested patch. Claude Sonnet 5 is the default model; GitHub warns to run it only in disposable environments.