IQuest-Coder-V1 Model Family Update

🚀🚀🚀 IQuest-Coder-V1 Model Family Update: Released 7B & 14B Family Models, 40B-Thinking and 40B-Loop-Thinking, specially optimized for tool use, CLI agents (Like Claude Code and OpenCode) & HTML/SVG generation, all with 128K context, now on Hugging Face!

7B Models

14B Models

40B Models

Sampling Parameters:

For the IQuest-Coder-V1-Instruct: We suggest using Temperature=0.6, TopP=0.85, TopK=20.

For the IQuest-Coder-V1-Thinking: We suggest using Temperature=1.0, TopP=0.95, TopK=20.

IQuest-Coder-V1 Highlights

IQuest-Coder-V1 is a new family of code large language models (LLMs) designed to advance autonomous software engineering and code intelligence. Built on the innovative code-flow multi-stage training paradigm, IQuest-Coder-V1 captures the dynamic evolution of software logic, delivering state-of-the-art performance across critical dimensions:

• Performance: Achieves leading results on SWE-Bench Verified (76.2%), BigCodeBench (49.9%), LiveCodeBench v6 (81.1%), and other major coding benchmarks, surpassing competitive models across agentic software engineering, competitive programming, and complex tool use.
• Code-Flow Training Paradigm: Moving beyond static code representations, our models learn from repository evolution patterns, commit transitions, and dynamic code transformations to understand real-world software development processes.
• Dual Specialization Paths: Bifurcated post-training delivers two specialized variants—Thinking models (utilizing reasoning-driven RL for complex problem-solving) and Instruct models (optimized for general coding assistance and instruction-following).
• Efficient Architecture: The IQuest-Coder-V1-Loop variant introduces a recurrent mechanism that optimizes the trade-off between model capacity and deployment footprint. The 7B and 14B models adopt shallow architectures for faster inference speed.
• Native Long Context: All models natively support up to 128K tokens without requiring additional scaling techniques.
• CLI Agent Integration: Demonstrates initial deployment capabilities on ClaudeCode and OpenCode platforms, with the ability to integrate into CLI-based agent workflows.
• HTML and SVG Generation: Features preliminary support for HTML and SVG code generation.
• Architectural Chain-of-Thought via Recurrent Depth: 40B-Loop-Thinking is a research-oriented, experimental model prototype designed to explore how structural chains of thought and procedural chains of thought can be combined within a single system. The model uniquely integrates structural chains of thought—realized through loop-based computation enabled by the dual-iteration LoopCoder architecture—with procedural chains of thought derived from explicit reasoning trajectories trained via reinforcement learning. Unlike standard reasoning models that rely solely on token-level chain-of-thought expansion, Loop-Thinking introduces implicit multi-step computation at the architectural level through a looped Transformer design. In this design, the second iteration refines the hidden states produced by the first iteration using a global–local attention gating mechanism. This results in a nested reasoning mechanism: the loop structure supports iterative representation refinement, while the reasoning-oriented training paradigm injects explicit problem decomposition behavior. It is important to note that this model is not intended to achieve state-of-the-art performance across benchmarks, but rather to validate the complementary roles of loop-based computation and reasoning-oriented training in shaping reasoning structures, and to provide experimental evidence for future model design.

Model Overview

The IQuest-Coder-V1 series includes models ranging from 7B to 40B parameters, with both standard and Loop variants:

Architecture Features:

• Grouped Query Attention (GQA) for efficient inference
• Native 128K context length support
• Vocabulary size: 76,800 tokens
• Loop variants use recurrent transformer design with shared parameters across two iterations

For more details, please refer to our Technical Report, GitHub.

Quickstart

IQuest-Coder-V1 uses custom modeling code via Hugging Face's auto_map feature. We recommend using transformers>=4.52.4.

Basic Usage with Transformers

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "IQuest/IQuest-Coder-V1-40B-Instruct"

# Load the tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto"
)

# Prepare the input
prompt = "Write a Python function to calculate the Fibonacci sequence using dynamic programming."
messages = [
    {"role": "user", "content": prompt}
]
text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

# Generate response
generated_ids = model.generate(
    **model_inputs,
    max_new_tokens=8192
)
generated_ids = generated_ids[0][len(model_inputs.input_ids[0]):]
response = tokenizer.decode(generated_ids, skip_special_tokens=True)

print(response)

Using Thinking Models

For complex reasoning tasks, use the Thinking variant:

model_name = "IQuestLab/IQuest-Coder-V1-40B-Thinking"

# The Thinking model includes explicit reasoning traces
# Use similar code as above, but expect longer, more detailed responses
# with step-by-step problem decomposition

Deployment with vLLM

For production deployment, you can use vLLM to create an OpenAI-compatible API endpoint. Please refer to the vLLM PR for implementation details.

vllm serve IQuestLab/IQuest-Coder-V1-40B-Instruct --tensor-parallel-size 8

For Thinking models with reasoning support:

vllm serve IQuestLab/IQuest-Coder-V1-40B-Thinking --reasoning-parser qwen3 --tensor-parallel-size 8

When using tool, IQuest-Coder-V1-40B-Instruct and IQuest-Coder-V1-40B-Loop-Instruct should use --tool-parser qwen3, while IQuest-Coder-V1-7B-Instruct, IQuest-Coder-V1-7B-Thinking, IQuest-Coder-V1-14B-Instruct, IQuest-Coder-V1-14B-Thinking, IQuest-Coder-V1-40B-Thinking and IQuest-Coder-V1-40B-Loop-Thinking should use --tool-parser qwen3_coder.

CLI-Like Agents and Tools Usage

CLI-like agent capabilities are available for the following models: IQuest-Coder-V1-7B-Instruct, IQuest-Coder-V1-7B-Thinking, IQuest-Coder-V1-14B-Instruct, IQuest-Coder-V1-14B-Thinking, IQuest-Coder-V1-40B-Thinking and IQuest-Coder-V1-40B-Loop-Thinking.

Step 1: Deploy the model with vLLM and set tool parser (Attention: Do not set reasoning parser for Instruct LLMs, otherwise it will cause unexpected errors):

vllm serve IQuestLab/IQuest-Coder-V1-7B-Instruct --tool-parser qwen3_coder

or

vllm serve IQuestLab/IQuest-Coder-V1-7B-Thinking --tool-parser qwen3_coder --reasoning-parser qwen3 

Step 2: Use Claude Code to enjoy it:

export ANTHROPIC_BASE_URL="http://iquestcoder.link"
export ANTHROPIC_AUTH_TOKEN="sk-iquestcoder"
claude --model IQuestCoder-V1-7B-Instruct

Evaluation Results

Benchmark Parameters

SWE-Bench Verified Evaluation

We provide the evaluation framework and trajectory data for reproducing our SWE-Bench Verified results in IQuest-Coder-Eval/SWE-Verified/.

The evaluation framework is based on R2E-Gym. To reproduce the evaluation:

cd IQuest-Coder-Eval/SWE-Verified/R2E-Gym

# Install dependencies
pip install -e .

# Run evaluation
bash benchmark/bench/loopcoder/loopcoder.sh

The trajectory file ./IQuest-Coder-Eval/SWE-Verified/traj.zip contains the complete agent trajectories for our SWE-Bench Verified evaluation.

Limitations

• Research Prototype: The current models are designed for research purposes. Real-world user experience may differ from state-of-the-art commercial models, with weaker instruction-following capabilities in certain scenarios.
• Long-Context Management: Due to parameter size constraints, performance on long-horizon tasks and multi-turn tool invocations is limited, particularly in scenarios requiring sustained context management and complex agentic workflows.
• Reasoning vs. Efficiency Trade-off: Thinking models provide superior reasoning but generate longer responses; Instruct models are more efficient for straightforward tasks.
• Code Execution: Models generate code but do not execute it; always validate outputs in sandboxed environments.
• Domain Specificity: While trained on diverse codebases, performance may vary on highly specialized or proprietary frameworks.
• Factuality: Models may generate plausible but incorrect code; verify critical implementations thoroughly.

Citation

If you find our work helpful, please cite:

@article{iquest-coder-v1-2025,
  title={IQuest-Coder-V1 Technical Report},
  author={IQuest Coder Team},
  url={https://github.com/IQuestLab/IQuest-Coder-V1/blob/main/papers/IQuest_Coder_Technical_Report.pdf}
  year={2025}
}
@article{codescaling,
  title={Scaling Laws for Code: Every Programming Language Matters},
  author={Yang, Jian and Guo, Shawn and Jing, Lin and Zhang, Wei and Liu, Aishan and Hao, Chuan and Li, Zhoujun and Zhao, Wayne Xin and Liu, Xianglong and Lv, Weifeng and others},
  journal={arXiv preprint arXiv:2512.13472},
  year={2025}
}
@article{close_the_loop,
  title={Close the Loop: Synthesizing Infinite Tool-Use Data via Multi-Agent Role-Playing},
  author={Yuwen Li, Wei Zhang, Zelong Huang, Mason Yang, Jiajun Wu, Shawn Guo, Huahao Hu, Lingyi Sun, Jian Yang, Mingjie Tang, Byran Dai},
  journal={arXiv preprint arXiv:2512.23611},
  year={2025}
}
@article{loopcoder,
  title={LoopCoder: Scaling Code Intelligence via Looped Language Models},
  author={Jian Yang, Wei Zhang, Shawn Guo, Yizhi Li, Lin Jing, Zhengmao Ye, Shark Liu, Yuyang Song, Jiajun Wu, Che Liu, T. Zheng, Siwei Wu, L. Liao, X. Ma, Chuan Hao, Ran Tao, Yan Xing, Jianzhou Wang, Mingjie Tang, Aishan Liu, Zhoujun Li, Xianglong Liu, Weifeng Lv1, Bryan Dai},
  year={2025}
}
@article{swe_compress,
  title={Context as a Tool: Context Management for Long-Horizon SWE-Agents},
  author={hukai Liu, Jian Yang, Bo Jiang, Yizhi Li, Jinyang Guo, Xianglong Liu, Bryan Dai},
  journal={arXiv preprint arXiv:2512.22087},
  year={2025}
}