IQuest-Coder-V1 Technical Report

The IQuest-Coder-V1 series introduces a new family of code large language models (7B to 40B) that employ a novel code-flow multi-stage training paradigm—spanning pre-training, reasoning-integrated mid-training, and dual-path post-training—to achieve state-of-the-art performance in agentic software engineering, competitive programming, and complex tool use.

The Gist

🚀 The Big Idea: Teaching a Robot to Be a Master Architect

Imagine you want to teach a robot how to build a skyscraper.

• Old Way: You give the robot a stack of blueprints (static code) and say, "Copy this." The robot learns to memorize the blueprints but gets confused if the building needs to change or if a pipe bursts in the middle of construction.
• IQuest-Coder's Way: You take the robot on a journey. You show it the entire history of how the skyscraper was built, how the architects argued over designs, how they fixed mistakes, and how the building evolved from a sketch to a finished tower.

The IQuest-Coder-V1 is a new family of AI models designed to do exactly this: understand code not just as static text, but as a living, breathing story of creation and evolution.

---

🏗️ The Training Pipeline: A Four-Stage School

The researchers didn't just dump data on the AI. They built a specific "school curriculum" with four distinct stages, like a master chef training an apprentice.

1. The Foundation: "The Library & The Kitchen" (Pre-Training & Annealing)

• The Analogy: First, the AI reads millions of books (general data) and then moves to a specialized library of cookbooks (code data).
• The Twist: Instead of just reading recipes, they show the AI the history of the kitchen. They show it a "triplet" of data: The old kitchen layout → The changes made (the patch) → The new kitchen layout.
• Why it matters: This teaches the AI that code isn't just words; it's a process of change. It learns to predict what happens next in a project, not just what a single file looks like.

2. The Internship: "The Long-Haul Project" (Mid-Training)

• The Analogy: Now the AI is an intern. They are given a massive, complex project that spans 32,000 to 128,000 pages (context).
• The Challenge: They have to solve logic puzzles, act as a "digital agent" (clicking buttons, running commands, seeing errors), and fix bugs in a huge codebase.
• The Result: The AI learns to think in "loops." If it makes a mistake, it doesn't give up; it looks at the error log, thinks, and tries again. This is the "Agentic" part—it learns to do things, not just talk about them.

3. The Specialization: "The Two Paths" (Post-Training)

Once the AI is smart, they split it into two different career paths:

• Path A: The "Thinker" (Thinking Model): This AI is trained to pause and "think" before answering. It's like a detective who writes down every clue and deduction before solving the case. It uses Reinforcement Learning (trial and error) to get better at solving hard, long-term problems.
• Path B: The "Assistant" (Instruct Model): This AI is trained to be a helpful, fast, and friendly coding buddy. It's great at following instructions like "Write a function to sort this list" and doing it immediately.

4. The Efficiency Hack: "The Loop" (Loop Architecture)

• The Problem: Usually, to make a smarter AI, you need a bigger brain (more parameters), which costs a fortune to run.
• The IQuest Solution: They introduced a "Loop" mechanism. Imagine a single person reading a difficult paragraph, then reading it again with a fresh perspective, using the same brain but processing the information twice.
• The Benefit: This allows the model to be incredibly smart without needing a massive amount of computer power. It's like getting a PhD-level brain in a compact, energy-efficient package.

---

🏆 The Results: How Did They Do?

The paper shows charts comparing IQuest-Coder to giants like GPT-5.1, Claude 4.5, and Kimi.

• The Scoreboard: In almost every category—fixing real-world software bugs, solving competitive programming puzzles, and using tools—the IQuest-Coder models are at the very top, often beating the expensive, closed-source giants.
• The "SWE-Bench" Test: This is the ultimate test. It asks the AI to fix real bugs in real software projects. IQuest-Coder scored 76.2, beating almost everyone else. It's like a robot that can actually fix your car engine, not just talk about how engines work.

---

💡 Key Takeaways for You

1. Code is a Story: The secret sauce was teaching the AI to understand the flow of code changes (commits), not just static files.
2. Thinking vs. Doing: They created two versions of the AI: one for deep, complex problem-solving (Thinking) and one for quick, helpful tasks (Instruct).
3. Efficiency Matters: The "Loop" design proves you don't need a super-computer to get super-smart results; you just need a smarter way to process information.
4. Open Source: Unlike many top AI models that are secret, the creators are releasing the "white-box" (the full recipe and the checkpoints) so anyone can study how they built this intelligence.

In a nutshell: IQuest-Coder-V1 is a new generation of AI that learned to code by watching the entire history of software development, practicing on massive projects, and learning to think through its own mistakes. It's a powerful, open-source tool that is ready to help build the software of the future.

Technical Summary

Technical Summary: IQuest-Coder-V1

1. Problem Statement

Despite significant advancements in Large Language Models (LLMs), a substantial performance gap remains between open-weights code models and proprietary leaders (e.g., Claude 4.5 Sonnet, GPT-5.1). This gap is most pronounced in long-horizon reasoning, multi-file codebase navigation, and agentic software engineering tasks. Existing open models often struggle with:

• Static vs. Dynamic Logic: Relying on static code snapshots rather than understanding the dynamic evolution of software (commits, patches, repository states).
• Context Limitations: Inability to effectively utilize long contexts (128k+) for repository-scale reasoning.
• Agentic Capabilities: Lack of robust error recovery and autonomous planning in complex, multi-step software engineering workflows.
• Deployment Constraints: The trade-off between model capacity (performance) and inference efficiency (deployment footprint).

2. Methodology: The Code-Flow Paradigm

The IQuest-Coder-V1 series (7B, 14B, 40B, and 40B-Loop) introduces a Code-Flow Multi-Stage Training Paradigm. Unlike traditional training that treats code as static text, this approach models the dynamic evolution of software logic through four distinct pillars:

A. Pre-Training & High-Quality Annealing

• Stage 1 (General & Code): Initial pre-training on a massive mixture of general data and code data.
• Stage 2 (Annealing): A targeted phase using high-quality, curated code corpora.
• Key Innovation: Introduction of Repository Transition Data. Instead of static files, the model is trained on triplets $(R_{old}, P, R_{new})$ representing project states and patches. This captures the "flow" of commits, teaching the model to understand software evolution and planning rather than just syntax completion.
• Data Construction: Utilizes AST analysis for syntactic integrity and "Fill-In-the-Middle" (FIM) strategies at both file and repository levels to enhance cross-file context understanding.

B. Dual-Phase Mid-Training

This stage bridges the gap between static knowledge and agentic action, scaling context length progressively:

• Phase 1 (32k Context): Trains on reasoning QA, agentic trajectories, and code tasks to build a "reasoning runtime."
• Phase 2 (128k Context): Extends training to repository-scale contexts.
• Data Focus: Includes Agent Trajectories (action-observation-revision cycles with logs, errors, and test results) to teach "closed-loop intelligence" and error recovery.

C. Bifurcated Post-Training

The models diverge into two specialized paths to optimize for different use cases:

1. Thinking Path: Optimized for complex reasoning. Uses Supervised Fine-Tuning (SFT) on explicit reasoning traces followed by Reinforcement Learning (RL) using the GRPO algorithm (without KL penalties) to maximize test-case pass rates. This path triggers emergent autonomous error-recovery capabilities.
2. Instruct Path: Optimized for general assistance and instruction following. Uses SFT on general/code instructions followed by RL to enhance alignment and usability.

D. Efficient Architectures (LoopCoder)

To address deployment constraints, the IQuest-Coder-V1-Loop variant introduces a Loop Transformer architecture:

• Mechanism: Transformer blocks with shared parameters are executed in two fixed iterations.
• Attention: Combines Global Attention (Iteration 2 queries attend to all Iteration 1 keys/values) and Local Attention (causal within Iteration 2).
• Gating: A learned gating mechanism blends global context refinement with local causal dependencies.
• Benefit: Enables iterative computation over complex code segments without increasing parameter count, optimizing the capacity-efficiency trade-off.

3. Key Contributions

1. Code-Flow Training Paradigm: A novel pipeline that prioritizes dynamic repository transitions (commits/patches) over static snapshots, significantly improving task planning and logical reasoning.
2. Recurrent Loop Architecture: The "Loop" variant offers a scalable architectural solution for long-horizon tasks within standard deployment footprints, achieving high performance with shared parameters.
3. Emergent Agentic Capabilities: The "Thinking" path, driven by RL on verifiable feedback, demonstrates emergent self-debugging and error-recovery abilities in long-horizon tasks (e.g., SWE-bench) that are absent in standard SFT models.
4. Comprehensive Open-Source Release: The authors release the complete white-box chain of checkpoints, from Stage 1 pre-training bases to the final Thinking and Instruct models, facilitating research into the "forging" of agentic code intelligence.

4. Results

IQuest-Coder-V1 achieves State-of-the-Art (SOTA) performance across critical dimensions, often surpassing proprietary models like GPT-5.1 and Claude Sonnet 4.5.

• Agentic Software Engineering:
  • SWE-Bench Verified: Achieved 76.2% (40B-Loop-Instruct), outperforming GPT-5.1 (76.3% is close, but IQuest is competitive with top proprietary models) and significantly beating other open models.
  • Terminal-Bench: Scored 62.5% (40B-Loop-Instruct), leading open models and competing with top closed APIs.
• Competitive Programming & Code Generation:
  • LiveCodeBench v6: The 40B-Loop-Thinking model achieved 87.0%, setting a new benchmark.
  • BigCodeBench: Achieved 49.9% (40B-Loop-Instruct), outperforming Qwen3-Coder and Kimi-K2.
• Tool Use & Reasoning:
  • BFCL (Function Calling): 73.9% (40B-Loop-Instruct).
  • Mind2Web: 62.5%, demonstrating strong web-agent capabilities.
  • Text-to-SQL: Competitive results on BIRD and Spider, showing robust semantic parsing.
• Efficiency: The Loop architecture maintains high performance while offering a more efficient inference path compared to simply scaling up model size.

5. Significance

The IQuest-Coder-V1 series represents a paradigm shift in open-source code intelligence:

• Bridging the Gap: It effectively closes the performance gap between open-weight models and proprietary leaders in complex, multi-step software engineering tasks.
• Methodological Insight: The findings challenge conventional assumptions, proving that repository transition data and mid-training with agentic trajectories are critical for developing logical intelligence and error recovery.
• Research Catalyst: By releasing the full training pipeline and intermediate checkpoints, the authors provide a unique resource for the community to study how agentic capabilities emerge, potentially accelerating the development of production-ready autonomous coding agents.
• Practical Deployment: The introduction of the Loop architecture provides a viable path for deploying high-capacity reasoning models in resource-constrained environments.