This is a decensored version of IQuestLab/IQuest-Coder-V1-40B-Thinking, made using Heretic v1.2.0+custom

Abliteration parameters

Performance

Transformers 5.x Compatibility

What the patch fixes: The custom IQuestCoderRotaryEmbedding references a "default" rope type that was removed from the transformers 5.x rope registry, and imports SlidingWindowCache which was renamed. The patch adds the missing rope initialization function and updates the cache import.

---

IQuest-Coder-V1 Model Family Update

7B Models

14B Models

40B Models

Sampling Parameters:

IQuest-Coder-V1 Highlights

• 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

• 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

Quickstart

Basic Usage with Transformers

Using Thinking Models

Deployment with vLLM

CLI-Like Agents and Tools Usage

Evaluation Results

Benchmark Parameters

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