IQuest-Coder-V1 Technical Report

Le rapport présente la série IQuest-Coder-V1, une nouvelle famille de modèles de langage pour le code qui, grâce à un paradigme d'entraînement multi-étapes basé sur le flux de code et des mécanismes d'inférence récurrents, atteint des performances de pointe en ingénierie logicielle autonome, en programmation compétitive et en utilisation d'outils complexes.

L'essentiel

🚀 IQuest-Coder-V1 : Le Nouvel Apprenti Génie du Code

Imaginez que vous voulez former un apprenti architecte pour qu'il construise des gratte-ciel entiers, pas juste des briques isolées. Jusqu'à présent, la plupart des "robots codeurs" (les modèles d'IA) apprenaient en lisant des livres de recettes de cuisine (du code statique) sans jamais vraiment cuisiner ensemble.

IQuest-Coder-V1, c'est comme une nouvelle école d'ingénierie qui a changé la méthode d'enseignement. Au lieu de simplement lire des recettes, ils ont appris à suivre l'histoire complète de la construction, depuis le premier croquis jusqu'au bâtiment final, en passant par les erreurs et les corrections.

Voici comment ils ont fait, étape par étape, avec des analogies simples :

1. La Méthode "Code-Flow" : Apprendre par l'histoire, pas par la photo

La plupart des IA apprennent avec des "photos" de code (des fichiers figés). IQuest-Coder, lui, apprend avec des films.

• L'analogie : Imaginez que vous apprenez à jouer du piano.
  • L'ancienne méthode : On vous donne une partition figée et on vous dit "joue ça".
  • La méthode IQuest : On vous montre un film d'un musicien qui joue, qui se trompe, qui corrige, qui change de tempo, et qui finit par jouer un concerto magnifique.
• Pourquoi c'est mieux ? Cela permet au modèle de comprendre comment un projet évolue, comment on répare un bug, et comment plusieurs fichiers travaillent ensemble, comme une équipe de musiciens.

2. Les Trois Étapes de la Formation (Le "Pipeline")

L'équipe a divisé l'apprentissage en trois phases distinctes, comme un parcours sportif :

• Phase 1 : L'Entraînement de Base (Le Marathon)
  Le modèle lit des milliards de lignes de code, de documentation et de livres techniques. C'est comme si l'apprenti lisait toute la bibliothèque du monde pour comprendre le vocabulaire et les règles de base.
• Phase 2 : Le "Mid-Training" (Le Camp d'Entraînement Spécialisé)
  C'est ici que la magie opère. Le modèle ne lit plus seulement, il réfléchit et agit.
  • On lui donne des problèmes complexes à résoudre (comme des énigmes mathématiques ou des défis de programmation).
  • On lui montre des "trajectoires d'agents" : des exemples où l'IA essaie, échoue, regarde l'erreur, et réessaie.
  • On lui apprend à gérer des contextes énormes (jusqu'à 128 000 mots), comme si un architecte pouvait voir tout le plan d'une ville entière d'un seul coup d'œil, pas juste un quartier.
• Phase 3 : La Spécialisation Finale (Le Choix de Carrière)
  À la fin, le modèle se divise en deux versions, selon ce dont on a besoin :
  • La version "Penseur" (Thinking) : C'est le détective. Il prend son temps, réfléchit longuement, vérifie ses hypothèses et résout des problèmes très difficiles (comme des compétitions de code ou de gros bugs). C'est comme un joueur d'échecs qui calcule 20 coups à l'avance.
  • La version "Assistant" (Instruct) : C'est le collaborateur rapide. Il répond directement aux demandes, écrit du code pour des tâches quotidiennes et aide à la création. C'est comme un assistant de bureau efficace qui fait ce qu'on lui demande tout de suite.

3. L'Innovation "Loop" : Le Miroir Infini

Le rapport mentionne une version spéciale appelée "Loop" (Boucle).

• L'analogie : Imaginez un miroir face à un autre miroir. Au lieu de lire un texte une seule fois, le modèle le relit plusieurs fois, en se regardant dans le miroir à chaque fois pour affiner sa compréhension.
• Le but : Cela permet à un modèle plus petit (moins cher et plus rapide) de faire le travail d'un modèle géant, en "réfléchissant" plusieurs fois sur le même problème avant de donner sa réponse. C'est un tour de magie pour économiser de l'énergie tout en restant très intelligent.

4. Les Résultats : Qui gagne ?

Le rapport compare IQuest-Coder aux géants actuels (comme GPT-5, Claude, ou Kimi).

• Le verdict : IQuest-Coder-V1 arrive en tête de peloton, souvent devant les modèles payants les plus chers.
• Ses super-pouvoirs :
  • Il est excellent pour réparer de vieux logiciels (SWE-Bench).
  • Il gagne des compétitions de code (LiveCodeBench).
  • Il sait utiliser des outils complexes (comme des terminaux d'ordinateur ou des bases de données) pour accomplir des missions complètes, pas juste écrire une phrase.

En Résumé

IQuest-Coder-V1 n'est pas juste un autre robot qui écrit du code. C'est un apprenti qui a vu le processus complet de la création logicielle.

Au lieu d'être un simple traducteur de mots en code, il est devenu un ingénieur autonome capable de :

1. Comprendre l'histoire d'un projet.
2. Réfléchir longuement avant d'agir (s'il est en mode "Penseur").
3. Se corriger lui-même quand il fait une erreur.
4. Travailler sur des projets gigantesques sans se perdre.

L'équipe a décidé de tout partager (les recettes, les entraînements, les modèles finaux) pour que tout le monde puisse construire l'avenir de l'intelligence artificielle, rendant la technologie plus accessible et plus puissante pour tout le monde.

Résumé technique

1. Problématique

Bien que les modèles de langage (LLM) aient fait des progrès significatifs, un fossé important persiste entre les modèles open-weights actuels et les leaders propriétaires (comme Claude 4.5 Sonnet ou GPT-5.1), en particulier dans le domaine de l'intelligence logicielle. Ce fossé se manifeste principalement par :

• Une incapacité à effectuer un raisonnement à long terme (long-horizon reasoning).
• Des difficultés à naviguer et à comprendre des bases de code complexes et multi-fichiers.
• Une limitation des représentations statiques du code, qui ne capturent pas l'évolution dynamique de la logique logicielle.

L'objectif est de combler cet écart en créant une famille de modèles capables de gérer des tâches d'ingénierie logicielle autonomes, de programmation compétitive et d'utilisation d'outils complexes.

2. Méthodologie : Le Paradigme "Code-Flow"

L'équipe IQuest propose une nouvelle approche d'entraînement en plusieurs phases, appelée Code-Flow, qui capture l'évolution dynamique de la logique logicielle plutôt que de se fier uniquement à des instantanés statiques. Le pipeline se divise en quatre piliers majeurs :

A. Pré-entraînement et Recuit (Annealing)

• Phase 1 : Pré-entraînement sur un mélange de données générales et de données de code.
• Phase 2 (Recuit) : Utilisation de données de code de haute qualité pour affiner les représentations de base.
• Innovation clé : Construction de triplets de données (R_old, P, R_new) basés sur le cycle de vie des dépôts (anciens commits, patchs, nouveaux commits). Cela permet au modèle d'apprendre les motifs d'évolution et de transformation du code, offrant un signal supérieur pour la planification de tâches par rapport aux fichiers statiques.

B. Entraînement Intermédiaire (Mid-Training)

Cette phase sert de pont entre la connaissance statique et l'action d'agent. Elle est divisée en deux étapes avec des contextes croissants :

• Phase 1 (32k tokens) : Intègre des données de raisonnement, des trajectoires d'agents et des tâches de code.
• Phase 2 (128k tokens) : Étend la capacité de contexte pour permettre un raisonnement à l'échelle d'un dépôt entier (repository-scale).
• Données : Inclut des QA de raisonnement (maths, logique), des trajectoires d'agents (boucles d'action-observation-révision) et des données de remplissage (Fill-In-the-Middle ou FIM) au niveau des fichiers et des dépôts.

C. Post-entraînement Bifurqué

Reconnaissant que différents cas d'usage nécessitent des optimisations différentes, le modèle est affiné via deux voies distinctes :

1. Voie "Instruct" (Instruction) : Optimisée pour l'assistance générale, le suivi d'instructions et la génération de code standard. Utilise le SFT (Supervised Fine-Tuning) suivi d'un RL (Reinforcement Learning) pour le suivi d'instructions.
2. Voie "Thinking" (Réflexion) : Optimisée pour le raisonnement autonome et la résolution de problèmes complexes. Utilise des données de traces de raisonnement explicites et un RL axé sur le raisonnement. Cette voie déclenche une capacité émergente de récupération autonome d'erreurs (self-debugging) dans les tâches à long terme.

D. Architecture Efficace : LoopCoder

Pour répondre aux contraintes de déploiement, une variante Loop est introduite.

• Architecture : Utilise un transformeur en boucle où les blocs partagent des paramètres et sont exécutés en deux itérations fixes.
• Mécanisme : La première itération traite les entrées avec des états cachés décalés. La seconde itération combine une attention globale (requêtes de l'itération 2 sur toutes les clés/valeurs de l'itération 1) et une attention locale (causalité au sein de l'itération 2).
• Avantage : Permet un calcul itératif sur des segments de code complexes, optimisant le compromis entre capacité du modèle et empreinte de déploiement.

3. Contributions Clés

1. Paradigme Code-Flow : Introduction d'un pipeline d'entraînement qui modélise l'évolution temporelle du code (commits, patches) plutôt que des snapshots statiques.
2. Découvertes Empiriques :
   • Les données de transition de dépôt sont supérieures aux fichiers statiques pour la planification de tâches.
   • L'injection de trajectoires de raisonnement et d'agents (32k) avant le post-entraînement stabilise les performances sous des décalages de distribution.
   • La voie "Thinking" via RL génère des capacités de récupération d'erreurs autonomes absentes dans les modèles standard.
3. Famille de Modèles Complets : Publication de la chaîne complète de checkpoints (de la base pré-entraînée aux modèles finaux Instruct et Thinking) pour les tailles 7B, 14B et 40B (avec variante Loop).
4. Infrastructure d'Entraînement : Mise en place d'un pipeline robuste incluant la détection d'erreurs silencieuses, la parallélisation de contexte et des mécanismes de vérification exécutable pour la génération de données.

4. Résultats et Évaluations

Les modèles IQuest-Coder-V1 atteignent des performances de pointe (State-of-the-Art) sur de nombreux benchmarks, surpassant souvent des modèles propriétaires massifs.

• Ingénierie Logicielle (SWE-Bench Verified) : Le modèle IQuest-Coder-V1-40B-Loop obtient 77,2 %, dépassant GPT-5.1 (76,3 %) et Claude Sonnet 4.5 (76,2 %).
• Programmation Compétitive (LiveCodeBench v6) : Le modèle Thinking atteint 87,0 %, se classant premier face à GPT-5.1 (81,1 %) et Kimi-K2 (73,0 %).
• Génération de Code (BigCodeBench / FullStackBench) : Le modèle 40B-Loop-Instruct obtient 91,5 % sur BigCodeBench et 92,9 % sur FullStackBench, surpassant la plupart des concurrents open-source et fermés.
• Tâches Agentic et Outils :
  • Terminal-Bench : 62,5 % (40B-Loop).
  • Mind2Web (Agents Web) : 62,5 %.
  • BFCL (Utilisation d'outils) : 73,9 %.
• Efficacité et Sécurité : Les modèles montrent une bonne efficacité de runtime (benchmark Mercury) et une gestion robuste des refus de sécurité (benchmarks XSTest, BeaverTails), avec des taux de refus appropriés sur les prompts nuisibles.

5. Signification et Impact

Le rapport IQuest-Coder-V1 marque une avancée significative dans le domaine de l'intelligence logicielle autonome :

• Démocratisation de l'IA de pointe : En offrant des modèles open-weights (jusqu'à 40B) qui rivalisent avec les modèles fermés les plus avancés, il rend accessible des capacités d'ingénierie logicielle de haut niveau.
• Nouvelle Approche d'Entraînement : La méthodologie "Code-Flow" et l'architecture "Loop" offrent de nouvelles perspectives sur la façon d'entraîner des modèles pour la complexité et la dynamique du développement logiciel réel.
• Transparence et Recherche : La publication de la chaîne complète de checkpoints (de la base au modèle final) permet à la communauté scientifique d'étudier l'émergence de l'intelligence d'agent et d'accélérer le développement de systèmes agentic prêts pour la production.

En résumé, IQuest-Coder-V1 démontre qu'une combinaison de données dynamiques (évolution de dépôts), d'entraînement intermédiaire spécialisé (raisonnement/agents) et d'architectures efficaces (Loop) permet de construire des assistants de codage autonomes capables de résoudre des problèmes d'ingénierie logicielle réels et complexes.