AI Coding Live News

g
guregodevo (Memdoor author)github.com·
👀13
🔥81

Memdoor reproduces GVS5H: a team of five Qwen3.8-27B agents averages 9.8/10 on the first 10 LiveCodeBench Hard problems, against 8.0 for a single Fable 5 call

On Oct 31 the open-source coding agent Memdoor (GitHub guregodevo/memdoor, Apache 2.0) published its team-solve workflow: using the GVS5H paper authors' exact prompts and loop, five Qwen3.8-27B instances act as planner, two ideators, solver and manager, talk only through files on disk, and a script that runs the tests decides success. Over five passes on the first 10 LiveCodeBench Hard problems from the GVS5H list it averaged 9.8/10, against 9.6 for the authors' own harness and 8.0 for a single Fable 5 call; 49 of 50 runs solved the problem for $35.79 in total, and every request and reply is public. The Hacker News post has about 200 points. This is a community reproduction on only 10 problems, and the author notes that training-data contamination cannot be ruled out.

Key Takeaways

  • Score: a mean of 9.8/10 over five passes (10, 10, 10, 10, 9), against 9.6 for the GVS5H authors' own harness and 8.0 for a single Fable 5 call (team-solve README, project-reported)
  • Cost: 49 of 50 runs solved, $35.79 and 15.3M output tokens in total; a median run took about 40 minutes of model time and $0.39, the longest 4 hours
  • Method: five roles (planner, two ideators, solver, manager) plus a repair worker each start from a fresh context, talk only through files on disk, and a shell script that runs the tests decides success instead of a model
  • Limits: only 10 problems rather than the paper's 100; the contests date from March and April 2025 and may be in training data; Fable 5's column comes from the GVS5H authors' result files and was not rerun in this harness
  • Reach: the HN post has about 200 points as of Nov 1, 16:10 SGT; the original GVS5H paper is arXiv 2608.26480, which reached #1 on HN on Oct 25
Read full story

BOSS Zhipin's Nanbeige lab open-sources Nanbeige4.3-33B, a 33B dense agent model with 512K context under Apache 2.0, reporting 80.9 on Terminal-Bench 2.1 vs 73.0 for Qwen3.8-27B

At 12:11 UTC on 2026-10-25, the Nanbeige LLM Lab of BOSS Zhipin (Kanzhun Limited) announced Nanbeige4.3-33B from its account @nanbeige (post), with the model and its Base version released as open weights on Hugging Face under Apache 2.0 (model card). It is a 33B dense model on a Llama-style architecture with a 512K context window, positioned as the teacher model of the Nanbeige4.3 series that will be distilled into smaller models such as Nanbeige4.3-3B. The official model card compares it with Qwen3.8-27B, Muse-Glimmer-30B and Gemma4-31B using the same harness at highest thinking effort: 80.9 on Terminal-Bench 2.1 (Qwen3.8-27B 73.0) and 65.5 on DeepSWE (42.5), but 60.3 on SWE-Bench Pro, slightly below Qwen's 61.7, and 84.8 on GDPval vs 86.4. All figures are self-reported and not yet independently reproduced.

Key Takeaways

  • Official sources: @nanbeige post on X and the Hugging Face model card; the post had about 616 likes, 79 reposts and 38K views when we pulled it
  • Specs: 33B dense, Llama-style architecture, 512K context, Apache 2.0, with a Base checkpoint released too
  • Self-reported coding scores: Terminal-Bench 2.1 80.9, Terminal-Bench 4.0 23.8, DeepSWE 65.5, SWE-Bench Pro 60.3 (Qwen3.8-27B: 73.0, 6.3, 42.5, 61.7)
  • Self-reported cowork scores: Automation Bench 54.2, JobBench 44.8, GDPval 84.8 (Qwen3.8-27B: 38.3, 34.5, 86.4)
  • Deployment: Transformers, SGLang and vLLM, with official examples using 4-way tensor parallelism; Nanbeige4.3-3B distillation is next
Read full story
Linked Models & Agents:
⚡ Nanbeige4.3-33B⚡ Qwen3.8-27B⚡ Gemma4-31B⚡ Muse-Glimmer-30B🌐 Nanbeige🌐 BOSS Zhipin🌐 Kanzhun

Eagle releases EAGLE-4, a speculative-decoding drafter that adapts to batch size and hardware; it reports 961.6 tok/s on Qwen3.8-27B for a single request

On Oct 20, inference company Eagle released EAGLE-4, the fourth generation of the EAGLE speculative-decoding family. One drafter resizes its speculative tree for the batch size, hardware and workload while keeping the target model's output distribution. Eagle reports 961.6 tokens/s for one request on Qwen3.8-27B with 4x B300. The code ships as eagle-harness v0.1.0 with plugins for SGLang, vLLM and an experimental TokenSpeed backend. Many reposts call it open source, but the official license is source-available, not OSI open source.

Eagle releases EAGLE-4, a speculative-decoding drafter that adapts to batch size and hardware; it reports 961.6 tok/s on Qwen3.8-27B for a single request

Key Takeaways

  • Vendor figure: 961.6 tokens/s on Qwen3.8-27B with TokenSpeed, BF16, 4x B300, TP4, one request, T=0 (paper Figure 1(a))
  • Repo measurements: vLLM on 4x B300 goes from 241.6 to 722.8 tok/s at concurrency 1 (2.99x) and 1.70x at concurrency 8; SGLang gets 1.91x at concurrency 8 and 1.35x at 64
  • AMD numbers too: SGLang on one MI355X gets 2.07x at concurrency 8 and 1.56x at 32 (ROCm 7.2)
  • Design: sliding-window draft layer, low-rank candidate head and append-only draft cache; the harness calibrates verify latency offline and grows the tree while gain per cost stays high
  • License: Eagle 4 Source-Available; free for noncommercial use, commercial use only under $20M trailing 12-month revenue and outside competing offerings
Read full story

HKU Introduces ReaDy for Hybrid Linear Attention: Recurrent States as Dynamic Context Accelerates B200 Decoding to 302 TPS

Traditional speculative decoding relies on static target hidden features that fail to supply varying contextual needs across draft positions. HKU researchers introduced ReaDy (arXiv:2610.20503). Designed specifically for Hybrid Linear Attention (HLA) architectures combining Transformers with recurrent linear attention states, ReaDy leverages compact recurrent states as dynamic context for drafting. On a single NVIDIA B200 GPU serving Qwen3.8-27B, ReaDy achieves an acceptance length of 4.53 and 302.78 TPS, accelerating inference by 2.4x over standard autoregressive decoding.

HKU Introduces ReaDy for Hybrid Linear Attention: Recurrent States as Dynamic Context Accelerates B200 Decoding to 302 TPS

Key Takeaways

  • HKU introduced ReaDy (arXiv:2610.20503), the first speculative decoding framework customized for Hybrid Linear Attention (HLA) LLMs
  • Reuses compact recurrent states as dynamic context for drafting, overcoming the static context bottleneck of feature-based drafters
  • Achieves 302.78 TPS for Qwen3.8-27B on a single NVIDIA B200 GPU (2.40x over AR and +7.97% over SOTA DSpark)
  • Reaches an acceptance length of 4.53 tokens using an ultra-lightweight Rank-8 reader
Read full story
Linked Models & Agents:
ADSponsored

Terminal-RSI: Recursive Self-Improving Terminal Agents via Trajectory Self-Rewrite and Critic-Inheriting Policy Refinement Hit 86.52% on Terminal-Bench 2.1

Terminal agents frequently struggle to convert partial command-line progress into complete end-to-end task resolution. Researchers from Tencent AI Lab and NUS introduce Terminal-RSI, alternating Recursive Self-Rewrite (RSR) of verified trajectories with critic-inheriting Recursive Policy-Refine (RPR) alongside Turn-Boundary Skip-Observation GAE (TB-GAE). Evolving Qwen3.8-27B across five stages yields Terminal-RSI-27B, achieving 86.52% on Terminal-Bench 2.1 and 79.00% on Terminal-Bench Hard.

Terminal-RSI: Recursive Self-Improving Terminal Agents via Trajectory Self-Rewrite and Critic-Inheriting Policy Refinement Hit 86.52% on Terminal-Bench 2.1

Key Takeaways

  • Five-stage recursive self-improvement: alternates verified trajectory Recursive Self-Rewrite (RSR) with critic-inheriting Recursive Policy-Refine (RPR) on Qwen3.8-27B
  • Turn-Boundary Skip-Observation GAE (TB-GAE): retains token-specific baselines while decaying strictly across interaction turns rather than verbose shell output logs
  • State-of-the-art terminal performance: reaches 86.52% on Terminal-Bench 2.1, 79.00% on Terminal-Bench Hard, and lifts LHTB strict completion from 0/46 to 5/46
Read full story

ProgramGym Open-Sourced: Scaling 1,648 Verifiable Environments for Long-Horizon Program Reproduction Agents

Current software engineering benchmarks and training pipelines predominantly evaluate coding agents on localized bug fixing within existing repositories (such as SWE-bench) or isolated code snippet generation. They fail to teach agents how to explore unfamiliar reference systems, formulate architectural blueprints, and reproduce complete, multi-file software projects from scratch under long-horizon constraints. Researchers introduce ProgramGym (arXiv:2610.13395, repo: github.com/Acm1011/ProgramGym, dataset: ProgramGym/programgym-1648), an automated framework scaling verifiable training environments for program reproduction agents. ProgramGym consists of Program-Env, a feedback-driven engine that converts open-source repositories into verified runtime sandboxes paired with black-box test suites across C, C++, Go, and Rust (generating ProgramGym-1648), alongside Program-Agent, an iterative workflow enforcing role isolation across Analysis, Implementation, and Review stages with revision management. Fine-tuning Qwen3.8-27B on ProgramGym trajectories raises ProgramBench test pass rates from 34.87% to 42.84% (+7.97 points), outperforming GPT-5.4 under mini-SWE-agent (37.70%). Coupling SFT with the Program-Agent scaffold boosts performance to 56.25%, eclipsing Claude Opus 4.7 (50.90%) and Gemini 3.5 Flash (53.60%), with datasets and codebase open-sourced.

ProgramGym Open-Sourced: Scaling 1,648 Verifiable Environments for Long-Horizon Program Reproduction Agents

Key Takeaways

  • ProgramGym open-sources 1,648 verifiable multi-language environments for whole-program reproduction coding agents
  • Qwen3.8-27B-SFT achieves 42.84% on ProgramBench (+7.97 points), surpassing GPT-5.4 under mini-SWE-agent
  • Coupled with the Program-Agent scaffold, test pass rates reach 56.25%, outperforming Claude Opus 4.7 and Gemini 3.5 Flash
Read full story
P
Perplexityperplexity-ai·
👀124
🔥84

Perplexity open-sources pplx-decider-v1.1-27b: Decision Index rises from 56.4 to 61.56, beating Jev by 3.6 points

Perplexity released pplx-decider-v1.1-27b (Apache-2.0, fine-tuned from Qwen3.8-27B) on Hugging Face. It returns typed, probability-calibrated answers instead of text. Overall Decision Index is 61.56 vs 56.4 for v1 and 57.9 for Jev, and it is served via the Perplexity Decisions API.

Perplexity open-sources pplx-decider-v1.1-27b: Decision Index rises from 56.4 to 61.56, beating Jev by 3.6 points

Key Takeaways

  • Overall Decision Index 61.56: +5.16 over v1 (56.4) and +3.66 over Jev (57.9) on the same Qwen3.8-27B backbone
  • Categories: Language 69.45, Retrieval 61.26, Tools 78.88, Knowledge 48.18 (still below Jev's 51.4)
  • Gains come mainly from lifting the causal mask on full-attention layers plus more training data incl. tasksource
  • Decision head is a BF16 [255, 5120] readout, not a full-vocab lm_head; ~49 GiB of weights on a CUDA GPU
  • Hosted via POST /v1/decisions with noul / choice / score questions, many per request (docs)
Read full story
Linked Models & Agents:
⚡ pplx-decider-v1.1-27b⚡ Pplx Decider V1 27b⚡ Qwen3.8-27B⚡ Jev🌐 Perplexity

SWR: Self-Supervised Scaling of Scientific Terminal Environments for Coding Agents Surges Terminal-Bench 2 to 53.56%

Terminal coding agents are expanding from standard software engineering into scientific domains like bioinformatics, materials science, and physics. However, building training sandboxes requires executable reference behavior and rigorous verifiers capable of distinguishing true semantic correctness from superficial syntactic mimicry—a process that currently requires tedious manual engineering per task. Researchers from Tsinghua University and Tencent introduce Software-in-the-Loop Reconstruction (SWR, arXiv:2610.02710), a self-supervised environment scaling framework. SWR extracts ground-truth outputs and verifiers from existing executable scientific software workflows by perturbing input configurations into public observations and hidden evaluations. Agents synthesize complete, editable programs from input-output schemas without viewing source code, evaluated by hierarchical verifiers testing semantic fidelity, structural integrity, and anti-shortcut compliance. Implemented across 500 workflows and 46 software suites spanning six scientific domains, SWR generates 1,422 verified trajectories. Supervised fine-tuning of Qwen3.8-27B elevates Terminal-Bench 2 average success from 47.94% to 53.56%, establishing a scalable paradigm for scientific terminal agent training.

SWR: Self-Supervised Scaling of Scientific Terminal Environments for Coding Agents Surges Terminal-Bench 2 to 53.56%

Key Takeaways

  • Introduces SWR to bootstrap self-supervised terminal agent training sandboxes from existing scientific software workflows
  • Decouples public observations from hidden evaluations, using hierarchical verifiers to block shortcuts during program reconstruction
  • Drives Qwen3.8-27B performance on Terminal-Bench 2 from 47.94% to 53.56%, eclipsing all token-matched baseline controls
Read full story

Disaggregated Quantization: Specializing LLM Prefill and Decode via DQ and Offloaded Prefill for 1.78x TTFT Acceleration

Large language model serving exhibits bifurcated hardware constraints: prefill is compute-bound, benefiting from high-throughput low-precision tensor operations (e.g., NVFP4), while decode is memory-bandwidth-bound, requiring ultra-compact weight storage (e.g., 2-3 bit weight-only) to minimize token-generation memory traffic. Uniform quantization forces suboptimal compromises across both phases. Researchers from IST Austria introduce Disaggregated Quantization (DQ, arXiv:2609.26333), decoupling computation formats, quantization precision, and physical memory placement across prefill and decode. Paired with Offloaded Disaggregated Prefill (ODP) to stream NVFP4 prefill weights asynchronously from NVMe SSDs, DQ delivers a 1.78x time-to-first-token (TTFT) speedup on Qwen3.8-27B at 8K prompt length within llama.cpp, while supporting disaggregated serving in vLLM on architectures up to 2.8T parameters.

Disaggregated Quantization: Specializing LLM Prefill and Decode via DQ and Offloaded Prefill for 1.78x TTFT Acceleration

Key Takeaways

  • Pioneers Disaggregated Quantization (DQ) to specialize precision formats independently for compute-bound prefill and bandwidth-bound decode
  • Introduces Offloaded Disaggregated Prefill (ODP), streaming NVFP4 weights from SSD to slash 8K prompt TTFT by 1.78x in llama.cpp
  • Boosts MMLU-Pro by 32.5 points and MMMU-Pro by 35.3 points on compact 2-3 bit decode checkpoints, scaling to 2.8T architectures
Read full story

AREX-2 Advances Self-Improving Agents via Long-Horizon Reflective Tasks: Scoring 81.8 on MLE-bench and 92.2 on GAIA

Test-time self-improvement—the ability of an agent to iteratively refine solutions during inference—relies on high-fidelity reflection to surpass current proposals and long-horizon execution to maintain coherent multi-round exploration. Researchers from Renmin University of China, Microsoft Research, and USTC introduce AREX-2, establishing that these capabilities are domain-agnostic and learnable from verifiable environments. Synthesizing long-horizon reflective trajectories across machine learning and algorithmic programming, an AREX-2 agent built on Qwen3.8-27B achieves 81.8 on MLE-bench Lite and 70.7 on Frontier-CS, transferring seamlessly to deep research with 84.0 on BrowseComp, 92.2 on GAIA, and 93.8 on DeepSearchQA while monotonically scaling with compute budget.

AREX-2 Advances Self-Improving Agents via Long-Horizon Reflective Tasks: Scoring 81.8 on MLE-bench and 92.2 on GAIA

Key Takeaways

  • Identifies reflection and long-horizon execution as domain-agnostic foundations for test-time self-improving agents
  • Achieves 81.8 on MLE-bench Lite and 70.7 on Frontier-CS using an AREX-2 Qwen3.8-27B model
  • Transfers zero-shot to deep research benchmarks, scoring 92.2 on GAIA, 93.8 on DeepSearchQA, and 84.0 on BrowseComp
Read full story
ADSponsored

AREX-2 Advances Test-Time Self-Improving Agents via Long-Horizon Reflective Programming: 81.8 on MLE-bench

Endowing LLM agents with test-time self-improvement—the ability to iteratively refine solutions—is a vital milestone for autonomous engineering. Researchers from Renmin University and collaborators present AREX-2, an open-source framework leveraging long-horizon reflective trajectories. Decoupling self-improvement into reflection (generating superior alternatives) and long-horizon execution (sustaining iteration over multiple turns), AREX-2 trains on verified machine learning and algorithmic programming trajectories. Built on Qwen3.8-27B, AREX-2 achieves 81.8 on MLE-bench Lite and 70.7 on Frontier-CS, transferring effectively to deep research with 92.2 on GAIA and 93.8 on DeepSearchQA.

AREX-2 Advances Test-Time Self-Improving Agents via Long-Horizon Reflective Programming: 81.8 on MLE-bench

Key Takeaways

  • Decouples test-time self-improvement into domain-agnostic reflection and long-horizon execution
  • Achieves 81.8 on MLE-bench Lite and 70.7 on Frontier-CS with Qwen3.8-27B, transferring to 92.2 on GAIA
  • Breaks multi-turn degradation bottlenecks, showing monotonic score improvements as iteration budgets increase
Read full story

RTX 3090 local coding-agent bake-off: Qwen3.8-27B Q4 + llama.cpp ~59 tok/s with reliable tools

@Brjen’s team spent a week comparing local coding-agent stacks on one RTX 3090 (24GB). Winner: Qwen3.8-27B Unsloth UD-Q4_K_XL with llama.cpp (65k context, q8 KV, native MTP depth 2, fully on GPU). Real multi-step coding runs hit ~59 tok/s (~46 tok/s at 45k context) and passed nested tool JSON, fixing a failing test, and a clean unified diff. They rejected Q3 for bad tools, heavier quants for context/MTP tradeoffs, and Flash-Next setups that needed CPU offload.

Key Takeaways

  • Winner: Qwen3.8-27B UD-Q4_K_XL + llama.cpp, 65k context and MTP, fully on a 3090.
  • ~59 tok/s on multi-step coding; passed tool JSON, test-fix, and correct diff gates.
  • Q3, heavier quants, and offloaded Flash-Next were less reliable on 24GB.
Read full story
Linked Models & Agents:

LM Studio ships Inco Splash day 0: ~144 tok/s Qwen3.8-27B on M5 Max

LM Studio announced a day-0 partnership with Inco to bring the Splash inference engine into LM Studio. They cite up to about 144 tok/s for Qwen3.8-27B on M5 Max, with setup docs at lmstudio.ai/blog/splash-engine. Splash was already open-sourced by Inco; this puts the Apple-silicon-optimized stack inside LM Studio so local desktop users do not have to assemble the engine separately.

Key Takeaways

  • LM Studio integrates Inco Splash on day 0 for one-click local desktop use.
  • Claims ~144 tok/s for Qwen3.8-27B on M5 Max, with an official setup post.
  • Moves Apple-silicon-optimized inference into a mainstream local client distribution path.
Read full story

Inco open-sources Splash: ~144 tok/s for Qwen3.8-27B on M5 Max

Inco AI open-sourced Splash, a local inference engine built for Apple silicon and models like Qwen3.8-27B. On an M5 Max MacBook Pro it reports about 144 tok/s—up to 3× Ollama, 2× oMLX, and nearly 4× when an agent fans out sub-agents. LM Studio shipped day-0 support under Settings > Runtime > Experimental backends.

Key Takeaways

  • Open-source Splash: local inference tuned for Apple silicon and Qwen3.8-27B.
  • Demo: ~144 tok/s on M5 Max; up to ~3× Ollama / 2× oMLX, nearly 4× with agent fan-out.
  • LM Studio day-0 support; repo github.com/incoai/splash; blog lmstudio.ai/blog/splash-engine.
Read full story

Cerebras launches Qwen3.8-27B: open dense model scores 34 on AA Index, near GPT-5.6 Luna / DeepSeek V4 Pro tier

Cerebras said Alibaba's open-weight dense Qwen3.8-27B is live at Cerebras speed. It scores 34 on the Artificial Analysis Intelligence Index—comparable to models such as GPT-5.6 Luna, DeepSeek V4 Pro, and Claude Sonnet 4.6. Qwen also confirmed rapid inference on Cerebras.

Key Takeaways

  • Qwen3.8-27B live with Cerebras-speed inference.
  • AA Intelligence Index 34—near Luna / DeepSeek V4 Pro / Sonnet 4.6 tier.
  • Open dense weights; Qwen confirms Cerebras availability.
Read full story
Linked Models & Agents: