AI Coding Live News

Liquid AI releases LFM3, six open-weight ~2B models spanning text, vision, audio, omni and decision tasks

On Oct 27 Liquid AI released LFM3, a new generation of foundation models built on a tri-hybrid architecture of gated short convolutions, sliding-window attention and global attention, pre-trained on 22T tokens. The first six models all branch from LFM3-1.7B-Base at around 2B parameters, with weights on Hugging Face under the LFM Open License v1.0. Liquid says the text model LFM3-1.7B needs about 1 GB at 4-bit, supports 256K context and beats models several times its size on several agent benchmarks.

Liquid AI releases LFM3, six open-weight ~2B models spanning text, vision, audio, omni and decision tasks

Key Takeaways

  • Six models: LFM3-1.7B (text), VL-2B (vision/video), Audio-2B, Omni-2B, plus decision models d1-2B and d1-Omni-2B
  • Architecture: of 24 layers, 13 gated short convolutions, 5 sliding-window attention (256-token window) and 6 global attention; 22T pre-training tokens
  • Vendor-reported: LFM3-1.7B scores 43.40 on SWE-bench Verified (OpenCode) vs 41.20 for Qwen3.5-4B and 51.20 for Qwen3.5-9B
  • Vendor-reported: 38.42 on WebArena-Verified and 41.29 on AutomationBench, both above Qwen3.5-9B (28.94 / 15.10)
  • A full 128K context needs about 1.6 GB of KV cache; one B300 with SGLang can produce about 3.6B tokens per day (vendor figure)
Read full story
Linked Models & Agents:
⚡ LFM3-1.7B⚡ LFM3-VL-2B⚡ LFM3-Audio-2B⚡ LFM3-Omni-2B⚡ d1-2B⚡ d1-Omni-2B⚡ Qwen3.5-9B⚡ Gemma 4 E4B🤖 Hermes Agent🤖 OpenClaw🌐 Liquid AI🌐 AMD🌐 Qualcomm🌐 Hugging Face

MemPilot Unveiled: On-Demand Multimodal Memory Curation for LLM Agents Solving Multi-Session Context Saturation

Researchers introduced MemPilot (arXiv:2610.06830), an on-demand multimodal memory curation framework for LLM agents. Resolving the chronic context explosion and cross-session forgetting that plague autonomous agents handling mixed text, screenshots, and action traces, MemPilot introduces an adaptive policy controlling memory retention, semantic clustering, and targeted retrieval. Across extensive long-horizon multi-modal agent benchmarks, MemPilot cuts active memory footprint by over 60% while substantially improving cross-session task completion.

MemPilot Unveiled: On-Demand Multimodal Memory Curation for LLM Agents Solving Multi-Session Context Saturation

Key Takeaways

  • Researchers introduced MemPilot (arXiv:2610.06830), an on-demand multimodal memory curation framework solving context saturation in LLM agents
  • Features a tri-tier architecture spanning active buffers, an image Memory Gallery, and a long-term semantic knowledge graph
  • Slashes active multimodal token consumption by 60% to 75%, extending agent continuous operational lifespan by over 3x
  • Boosts cross-session task completion by +18.5% over text-only RAG, providing a scalable blueprint for persistent computer-use agents
Read full story
Linked Models & Agents:

BranchOPD: Branching On-Policy Distillation Overcomes Trajectory Bottlenecks via Adaptive Decision-Point Forking

On-policy distillation (OPD) is critical for reasoning and agent alignment, yet conventional methods realize only a single continuation per decision, severely restricting supervision under finite compute budgets. Researchers have introduced BranchOPD (Branching On-Policy Distillation), an algorithm that dynamically identifies high-uncertainty and teacher-student disagreement decision nodes to branch and resample continuations from shared prefixes. BranchOPD slashes generation costs by 19%–31% on agent benchmarks while boosting math reasoning accuracy by 18.55 percentage points.

BranchOPD: Branching On-Policy Distillation Overcomes Trajectory Bottlenecks via Adaptive Decision-Point Forking

Key Takeaways

  • Overcomes single-trajectory bottlenecks: BranchOPD dynamically detects high-uncertainty decision points to branch and resample continuations
  • Up to 31% compute reduction: shared-prefix reuse cuts student token generation costs by 19% on ALFWorld and 31% on WebShop compared to multi-rollouts
  • Massive empirical gains: delivers an 18.55 percentage point leap in mathematical reasoning accuracy and a 13.8-point boost in agent task success
Read full story

Liquid AI open-sources LFM2.5-24B-A2B: a 24B-total, ~2B-active reasoning MoE built for on-device agents and tool use

On Oct 13 Liquid AI released LFM2.5-24B-A2B, the largest and final LFM2.5 model: 24B total parameters, ~2.45B active per token, 131K context, and always-on reasoning. By Liquid's own numbers it leads or matches Qwen3.6-35B-A3B on 5 of 8 tool-use/agent benchmarks (AutomationBench 27.69 vs 8.72) while trailing on SWE-Bench Verified, GPQA and other knowledge/coding tests. Open weights are on Hugging Face with GGUF, MLX, FP8 and ONNX builds; API pricing is $0.10 / $1.00 per million tokens and it is also on OpenRouter.

Liquid AI open-sources LFM2.5-24B-A2B: a 24B-total, ~2B-active reasoning MoE built for on-device agents and tool use

Key Takeaways

  • Specs (model card): 24.0B total / 2.45B active, 40 layers (30 gated short-conv + 10 GQA), 64 experts top-4, 131,072 context, 128K vocab
  • Agent benchmarks (vendor-reported, vs Qwen3.6-35B-A3B): AutomationBench 27.69 vs 8.72, LiveClaw 48.09 vs 38.19, ToolSandbox 80.71 vs 75.02, BFCLv4 65.01 vs 65.00
  • Disclosed weaknesses: SWE-Bench Verified (OpenCode) 51.00 vs 66.20, GPQA Diamond 74.42 vs 83.69, WebArena Verified 26.75 vs 37.62
  • Speed: 184 tok/s decode on Apple M5 Max, 114 tok/s on Ryzen AI Max+ 395, 21K+ output tok/s on one B300 with SGLang
  • Training: pretraining scaled 17T to 33T tokens; agentic RL inside OpenClaw, Hermes Agent, Pi and OpenCode; API $0.10 in / $1.00 out per M tokens
Read full story
Linked Models & Agents:
⚡ LFM2.5-24B-A2B⚡ LFM2.5-24B-A2B-Base⚡ LFM2-24B-A2B⚡ Qwen3.6-35B-A3B⚡ Gemma-4-26B-A4B-it🤖 Hermes Agent🤖 OpenClaw🤖 OpenCode🤖 Pi🌐 Liquid AI🌐 Hugging Face🌐 OpenRouter
ADSponsored

JetBrains Unveils SWE-TaskFlow: Aligning Coding Agent Benchmarks with Real Developer IDE Workflows

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.

JetBrains Unveils SWE-TaskFlow: Aligning Coding Agent Benchmarks with Real Developer IDE Workflows

Key Takeaways

  • JetBrains analyzes 4,782 production IDE sessions, proving real software engineers navigate dynamic multi-intent task flows
  • Introduces SWE-TaskFlow and TFAS to transform issue benchmarks into realistic multi-turn developer interaction protocols
  • Pilot across 700 SWE-Bench Pro tasks reveals multi-turn protocols double token costs without stable success gains
Read full story
Linked Models & Agents:

Learn2Play-Bench: New Benchmark Evaluates How LLM Agents Truly Learn from Interaction in Counterintuitive Worlds

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.

Learn2Play-Bench: New Benchmark Evaluates How LLM Agents Truly Learn from Interaction in Counterintuitive Worlds

Key Takeaways

  • Learn2Play-Bench open-sourced, establishing counterintuitive rule environments to isolate genuine agent in-context learning from memory
  • Empirical evaluations prove retaining full verbatim logs decisively beats model-generated rule summaries for rule discovery
  • Scaffolding harness architecture impacts exploration success more than foundation model scale, highlighting system-level importance
Read full story

SparseEngine: Harbin Institute of Technology Open-Sources Sparse-First Inference Engine Delivering 2.5x Faster Decoding Than vLLM for Long-Horizon Agents

Long-horizon LLM agents accumulate expanding interaction histories that saturate GPU KV-cache memory and choke self-attention throughput. While sparse attention algorithms mitigate these bottlenecks mathematically, existing production serving engines (e.g. vLLM) are tightly coupled to dense tensor layouts, preventing heterogeneous sparse mechanisms from sharing infrastructure. Researchers from Harbin Institute of Technology (HIT) release SparseEngine (arXiv:2609.39068), an open-source, sparse-first inference engine built from the ground up for long-horizon agent workloads. SparseEngine establishes a shared lifecycle contract enabling 15 diverse sparse attention methods across four distinct families to control their custom KV representations while unifying memory management. It introduces Chain Cache to resume stateful KV-evicted contexts across multi-turn requests and Controllable Prefix-Cache Pruning to discard stale history without disrupting prefix matching. Empirical evaluations on long-horizon agent benchmarks show that SparseEngine delivers over 10x higher throughput under KV eviction, over 2.5x faster decoding throughput than vLLM at matched concurrency, and more than 2x end-to-end task speedups with zero degradation in model reasoning accuracy.

Key Takeaways

  • Harbin Institute of Technology open-sources SparseEngine, a sparse-first inference engine natively supporting 15 sparse attention algorithms
  • Introduces Chain Cache and Controllable Prefix-Cache Pruning to preserve prefix-cache benefits across multi-turn sparse agent sessions
  • Delivers 2.5x faster decoding than vLLM, lifts throughput by 10x under KV eviction, and halves end-to-end agent task latency
Read full story

CheckerBench: ECNU and Peking University Introduce the First Executable Benchmark for Coding Agents Synthesizing Static-Analysis Checkers

Prevailing coding agent benchmarks evaluate isolated patch synthesis (e.g. SWE-bench) or vulnerability detection, neglecting whether agents can construct reusable, production-grade static-analysis checkers from scratch. Developing static analyzers requires interpreting defect specifications, traversing multi-file AST semantics, writing engine-specific logic, and refining implementations through iterative compilation and diagnostic feedback. Researchers from East China Normal University, SJTU, and Peking University unveil CheckerBench (arXiv:2610.07557), an executable suite comprising 300 tasks derived from 297 CVEs across 167 repositories, 85 CWEs, and five programming languages. Powered by the CheckerLab harness, evaluation across 21 model-harness configurations reveals a mean Pass@1 rate of only 32.30% (peak 45.33%), demonstrating that end-to-end program analysis tool synthesis represents a profound new frontier for software engineering agents.

Key Takeaways

  • ECNU, SJTU, and Peking University launch CheckerBench, the first executable benchmark for coding agents synthesizing static analysis checkers
  • Features 300 tasks spanning 297 CVEs and 85 CWEs across C/C++, Go, Java, Python, and Rust with the CheckerLab framework
  • 21 model-harness setups achieve a mean Pass@1 of only 32.30% (peak 45.33%), exposing gaps in compiler-in-the-loop tool synthesis
Read full story

Harness-Aware Distillation: KAIST Focuses Agentic Model Distillation on Model-Unique Capabilities to Build Resilient SLM Agents

Deploying performant coding and OS agents on cost-efficient small language models (SLMs) is essential for enterprise scalability. In modern agent architectures, models operate within an execution harness that maintains workspace context, API state, and terminal feedback. Conventional distillation forces the student model to mimic the teacher's holistic sequence output, conflating harness-maintained facts with model reasoning and overloading the student's limited capacity. KAIST AI introduces Harness-Aware Distillation (HAD, arXiv:2610.02858). HAD decouples what the harness manages from the unique reasoning additions of the teacher model. By combining on-policy distillation with harness-conditioned action preference contrast and strict execution-record validity checks, HAD requires zero reward models or oracle success annotations. Across multiple long-horizon agent benchmarks, HAD-trained SLMs enter significantly fewer unproductive query loops and demonstrate substantially higher autonomous error-recovery rates.

Key Takeaways

  • KAIST AI introduces Harness-Aware Distillation (HAD), optimizing small language model distillation for agent harnesses
  • Decouples harness-managed state from model reasoning via action preference contrast and execution validation without reward labels
  • Significantly suppresses unproductive infinite loops while doubling error-recovery rates, empowering 3B-8B SLMs for long-horizon agent tasks
Read full story
Linked Models & Agents:

UndoBench: Decoupling Nominal Task Competence from Fault Recovery in Tool-Using AI Agents via Counterfactual Mutation Paired Trials

Tool-using AI agents are rapidly assuming mission-critical automation responsibilities across enterprise software ecosystems. However, standard agent benchmarks focus exclusively on nominal, forward task completion—conflating initial planning competency with operational resilience and fault recovery. In real-world enterprise environments where network drops, idempotency failures, and partial commits are commonplace, unguided LLM retries routinely cause devastating side effects such as duplicate payments or corrupted databases. Researchers introduce UndoBench (arXiv:2610.05622), a comprehensive evaluation suite spanning 36 enterprise workflows and 36 production fault scenarios across 8 enterprise verticals. Utilizing counterfactual paired trials alongside wire-level effect-history and state oracles, UndoBench decouples task competence from recovery capability. Experiments reveal a severe vulnerability gap: while nominal task competence achieves 83.54%, conditional recovery success rates (CRSR) collapse to 46.72%, with naive retry producing duplicated external mutations in 53.33% of trials. The code is available at GitHub (tradertanmay/undobench).

Key Takeaways

  • Introduces UndoBench, the first enterprise fault recovery and undo benchmark for tool-using AI agents across 8 domains and 36 fault scenarios
  • Decouples nominal task competence from fault recovery: nominal task completion hits 83.54% while conditional recovery plunges to 46.72%, with naive retries causing duplicate mutations in 53.33% of trials
  • Pinpoints phase-dependent execution vulnerabilities, urging agent frameworks to move from naive retry loops to deterministic compensation transactions
Read full story
ADSponsored

GAGAR Reinvents Code Agent RL: Groupwise Agentic Grading and Advantage Redistribution Beyond Binary Test Rewards

Reinforcement learning (RL) pipelines for code agents typically rely on binary test suite outcomes for reward assignment. Under standard Group Relative Policy Optimization (GRPO), all test-passing rollouts within a sampled group receive identical advantage values, completely ignoring code quality, extraneous diff modifications, and algorithmic elegance. This induces severe trajectory bloat and training instability. Researchers introduce GAGAR (Groupwise Agentic Grading and Advantage Redistribution, arXiv:2609.32577). In a shared workspace, an agentic evaluator jointly inspects all passing candidates in a group, ranking them by architectural clarity and minimal intervention. A sum-preserving redistribution reallocates advantage weights toward superior implementations. Validated at industrial scale on MiMo-V2.6-Flash (310B) and MiMo-V2.6-Pro (1.02T parameters), GAGAR curtails trajectory length explosion while boosting code agent benchmark performance and optimization stability.

GAGAR Reinvents Code Agent RL: Groupwise Agentic Grading and Advantage Redistribution Beyond Binary Test Rewards

Key Takeaways

  • Breaks binary test-suite limitations in code agent RL via sum-preserving groupwise advantage redistribution
  • Validated at massive industrial scale across 310B (MiMo-V2.6-Flash) and 1.02T parameter (MiMo-V2.6-Pro) backbones
  • Restricts unnecessary trajectory length growth by 36% while reducing gradient update variance by 42.3%
Read full story
Linked Models & Agents:

AgSpec Accelerates Coding Agent Pipelines by 4.7x: Retrieval-Based Speculative Decoding Outperforms EAGLE-3

Coding agents frequently reproduce existing code, error logs, and multi-turn refactoring traces, making retrieval-based speculative decoding (SD) an ideal acceleration paradigm. However, conventional retrieval drafters fail in agent workflows: candidate code on disk diverges from the agent's emission formats (e.g., diff blocks, escape characters), and static draft lengths ignore inter-agent turn drift. KAIST researchers introduce AgSpec, a speculative decoding framework tailored for coding agents. AgSpec constructs format-aligned corpora across session trajectories, workspaces, and global repositories, coupling offline draft caps with online feedback-adaptive draft length control. Across repository-level multi-agent benchmarks, AgSpec outperforms five retrieval drafters and EAGLE-3, boosting generation throughput up to 4.76x.

AgSpec Accelerates Coding Agent Pipelines by 4.7x: Retrieval-Based Speculative Decoding Outperforms EAGLE-3

Key Takeaways

  • Tailors retrieval speculative decoding to coding agent pipelines via emission-aligned triple corpora and adaptive length control
  • Achieves up to 4.37x speedup at batch size 1 and 4.76x speedup at batch size 16 on repository-level multi-agent benchmarks
  • Outperforms EAGLE-3 across primary settings without requiring dedicated neural draft models or additional GPU VRAM
Read full story

AgentWorld: Benchmarking Long-Horizon Collaboration of Multi-Agent LLMs Across 50+ Rounds

Overcoming the limits of traditional multi-agent benchmarks that only test short-horizon (<20 steps) or competitive settings, UPenn researchers released AgentWorld. Spanning 50+ interaction rounds in an MMORPG sandbox across 100 human-annotated tasks with 3-20 asymmetric black-box agents, it introduces Causal Collaboration Effectiveness (CCE). Even frontier models achieve only 52.0% task success, exposing severe communication breakdown and shared plan decay.

AgentWorld: Benchmarking Long-Horizon Collaboration of Multi-Agent LLMs Across 50+ Rounds

Key Takeaways

  • Long-Horizon Collaboration: Moves beyond <20-step toy benchmarks by simulating 50+ round interactions in an MMORPG sandbox with 3 to 20 asymmetric agents operating in black-box environments.
  • Novel CCE Metric: Introduces Causal Collaboration Effectiveness (CCE), a graph-based metric that traces causal dependencies between agent actions to measure effective team contribution.
  • Frontier Model Failure Modes: Evaluated on Gemini 3 Flash, Claude Haiku 4.5, GPT-5 Mini, and DeepSeek R1-70B, top success rate reached only 52.0%, highlighting role confusion and plan erosion.
Read full story
Linked Models & Agents:

DeepSeek Ships V4-Flash-Vision-Exp, Nearing Opus 4.8 on Multimodal Agents

DeepSeek launched DeepSeek-V4-Flash-Vision-Exp on its API: an experimental multimodal model that matches V4-Flash on text, agents, and reasoning, while jumping close to Claude Opus 4.8 on multimodal agent benchmarks. A free Files API and DeepSeek Harness 0.1.1 landed the same day, with images billed at up to 384 tokens each.

Key Takeaways

  • Available now as model='deepseek-v4-flash-vision-exp' across Chat Completions, Messages, and Responses
  • Multimodal agent scores leap toward Opus 4.8 while keeping V4-Flash-level text and tool use
  • Free Files API lets teams upload an image once and reuse it by file_id across requests
Read full story

DeepSeek Ships V4-Flash-Vision-Exp: Multimodal Agents Near Claude Opus 4.8

DeepSeek-V4-Flash-Vision-Exp is live on the API: it matches V4-Flash on text—including agents, reasoning, and world knowledge—while jumping on multimodal agent benchmarks to near Claude Opus 4.8. A free Files API and DeepSeek Harness 0.1.1 ship with it; images bill at V4-Flash rates (up to 384 tokens each) and drop into existing agent frameworks.

Key Takeaways

  • The experimental vision model keeps V4-Flash text/agent strength while pushing multimodal agent scores close to Opus 4.8
  • Chat Completions, Messages, and Responses are supported; images mix in via base64, URLs, or the Files API
  • Files API is free with file_id reuse, and Harness 0.1.1 supports the model out of the box for agent stacks
Read full story