IQuest-Coder-V1 Model Family

TL;DR

IQuest-Coder-V1 is an open-source family of code LLMs (7B, 14B, 40B, plus 40B Loop variants) trained with a “code-flow” multi-stage paradigm that learns from repository evolution and commit transitions rather than static code snapshots. Each size ships in Instruct and Thinking variants, with native 128K context and integration with CLI agents like Claude Code and OpenCode. The 40B-Loop-Thinking variant is a research prototype combining looped transformer computation (a structural chain-of-thought via recurrent depth) with reasoning-RL (procedural chain-of-thought). Headline numbers: 76.2% on SWE-Bench Verified, 81.1% on LiveCodeBench v6, 49.9% on BigCodeBench.

Key claims

The 40B-Instruct model reaches 76.2% on SWE-Bench Verified, 49.9% on BigCodeBench, and 81.1% on LiveCodeBench v6 [Highlights].
A “code-flow” training paradigm uses repository evolution patterns and commit transitions as supervision rather than only static code [Highlights].
Post-training bifurcates into Thinking models (reasoning-driven RL) and Instruct models (instruction-following) [Highlights].
The 40B-Loop variant uses a recurrent transformer with 80 shared-parameter layers run for 2 iterations, refining hidden states across iterations via a global–local attention gating mechanism [Model Overview, Highlights].
40B-Loop-Thinking is positioned as a research prototype validating that loop-based computation (structural CoT) and reasoning-RL (procedural CoT) play complementary roles, not as a benchmark-chasing model [Highlights].
All models use Grouped Query Attention (40 Q heads / 8 KV heads) and natively support 128K context without rope-scaling tricks [Model Overview].
7B and 14B variants use shallow architectures (14 and 28 layers respectively at hidden size 5120) to trade depth for inference speed [Model Overview].

Method

The release covers a model family at three scales (7B, 14B, 40B) and two post-training tracks (Instruct, Thinking). All models share hidden size 5120, vocabulary 76,800, GQA with 40 Q heads and 8 KV heads, and 128K native context. The 7B is unusually shallow (14 layers); the 14B doubles that to 28; the 40B has 80 layers. The two Loop variants reuse the 40B’s 80-layer stack but execute it twice with shared parameters, with the second pass refining the first pass’s hidden states through a global–local attention gating mechanism. The cited “code-flow” training paradigm conditions on commit-level repository evolution rather than static file snapshots; details are in the technical report. Deployment uses vLLM with --tool-parser qwen3_coder and, for Thinking variants, --reasoning-parser qwen3 — reusing the Qwen3 parser infrastructure.

Results

On agentic / software-engineering benchmarks the 40B-Instruct reports 76.2% on SWE-Bench Verified (the headline number for the release). On competitive-programming and general coding: 81.1% on LiveCodeBench v6 and 49.9% on BigCodeBench. The repo ships full evaluation harness and trajectory zips under IQuest-Coder-Eval/SWE-Verified/ built on R2E-Gym, so the SWE-Verified numbers are reproducible. Benchmark sampling parameters are listed per-benchmark (e.g. greedy / T=0 for SWE-Verified and BigCodeBench; T=0.6 top_p=0.95 for LiveCodeBench). The release explicitly flags that long-horizon multi-turn tool use is a weak spot and that the Loop-Thinking 40B is a research prototype not optimized for headline benchmark scores.

Why it’s interesting

Two things stand out from a Luma perspective: (1) the Loop architecture is a concrete instance of recurrent-depth / looped-transformer compute scaling at 40B with a published checkpoint and eval harness, which is rare — most work on looped/universal transformers stops at small scale. (2) The “structural CoT (loop) + procedural CoT (reasoning RL)” framing is a clean experimental setup for asking whether implicit architectural reasoning and explicit token-level reasoning are additive or redundant. The cited companion papers (LoopCoder, “Scaling Laws for Code”, Close-the-Loop tool-use data synthesis, SWE context-management) sketch the full research program behind the release.