Cursor démontre la puissance des modèles économiques pour le codage

Cursor démontre la puissance des modèles économiques pour le codage

L'escouade d'agents de Cursor suggère que des modèles moins coûteux peuvent gérer la plupart des tâches de codage lorsque des modèles avancés planifient le travail.

Cursor a opposé une escouade d'agents améliorée à son prédécesseur en demandant aux deux de reconstruire SQLite en Rust en utilisant uniquement la documentation, sans accès au code source ni à Internet. Chaque configuration du nouveau système a atteint 100 % sur la suite de tests, tandis que l'ancienne escouade s'est enlisé dans ses propres conflits de fusion.

Chez Cursor, les flottes d'agents sont passées de projet de recherche à produit central. Avec Cursor 3, les développeurs peuvent faire fonctionner des flottes entières d'agents IA en parallèle. Anysphere, la société derrière Cursor, a récemment été acquise par SpaceX d'Elon Musk pour 60 milliards de dollars.

Le système divise les agents en deux rôles : les agents planificateurs, utilisant des modèles avancés puissants, décomposent un objectif en tâches plus petites. Les agents travailleurs, utilisant des modèles plus rapides et moins coûteux, exécutent ces tâches. Le résultat est un arbre de tâches qui s'adapte au fur et à mesure de l'avancement du travail.

Cursor affirme que cette séparation des rôles résout principalement un problème de contexte. Un agent isolé doit parcourir l'arbre entier tout en gardant à l'esprit à la fois l'objectif et la tâche actuelle. Cela aide à expliquer pourquoi les agents dérivent lors de travaux longs. Dans l'escouade de Cursor, les planificateurs ne codent pas, et les travailleurs ne planifient pas.

Git n'a pas pu gérer 1 000 commits par seconde

Une précédente escouade de navigateur Cursor a atteint environ 1 000 commits par heure sur Git. Elle utilisait des agents travailleurs, un agent juge et un intégrateur qui résolvait les conflits. L'intégrateur a finalement créé plus de goulets d'étranglement qu'il n'en a supprimés.

La nouvelle escouade a atteint 1 000 commits par seconde, ce qui a conduit Cursor à construire son propre système de contrôle de version, car les agents travaillant à ce rythme créaient des modes de défaillance que les équipes humaines ne rencontrent jamais.

Dans ce que Cursor a appelé le "design à cerveau divisé", deux planificateurs construisaient sans le savoir la même idée à des endroits différents et l'implémentaient de manières différentes. La contention était encore plus difficile à gérer lorsque les planificateurs étaient au courant les uns des autres et se bloquaient mutuellement avec des modifications concurrentes.

Cursor a fait enregistrer les décisions des agents dans des documents de conception partagés. Le code lié à une décision était référencé dans le document et vérifié au moment de la compilation.

Lorsque des conflits de fusion se produisaient, un agent neutre intervenait et les résolvait. Les travailleurs signalaient les fichiers encombrés pour qu'un agent extérieur les divise en modules plus petits. Étant donné que les agents avaient appris à ne pas toucher au code principal tout en travaillant dans des bases de code existantes avec des humains dans la boucle, Cursor leur a permis de casser des choses intentionnellement. Un agent pouvait corriger du code en dehors de sa zone assignée, et le compilateur transmettait le changement à travers le système.

Plusieurs angles de révision et un guide de terrain auto-maintenu

Cursor a testé plusieurs approches de révision. Un réviseur a reçu la transcription complète du travailleur, un autre n'a vu que la sortie, et un troisième n'a vu que la base de code. Aucune perspective unique n'a tout capté, mais des perspectives non corrélées combinées ont permis une fiabilité accrue.

Cursor a également testé un "guide de terrain", un dossier de connaissances maintenu par les agents eux-mêmes avec une limite de lignes fixe. Chaque agent recevait son contenu au démarrage. Étant donné que les poids des modèles sont figés, il est avantageux de capturer des découvertes surprenantes afin que les agents ultérieurs puissent prendre des raccourcis.

Cursor a donné à l'escouade le manuel SQLite de 835 pages et lui a demandé de construire une implémentation en Rust. Le code source, les suites de tests, le binaire SQLite et l'accès à Internet ont tous été retenus. Le benchmark était sqllogictest, une suite de tests avec des millions de requêtes SQL et des réponses connues. L'escouade ne savait pas qu'elle existait.

Quatre configurations ont été testées : GPT-5.5 seul, Grok 4.5 seul, Opus 4.8 comme planificateur avec Composer 2.5 comme travailleur, et Fable 5 comme planificateur avec Composer 2.5 comme travailleur. Le nouveau système a surpassé l'ancien dans chaque configuration. Après quatre heures, les nouvelles exécutions ont obtenu des scores entre 73 et 85 %, tandis que les anciennes exécutions ont obtenu des scores entre 11 et 77 %. Chaque configuration du nouveau système a ensuite atteint 100 %.

L'ancienne escouade a créé plus de travail qu'elle n'en a complété

Les exécutions de Grok 4.5 ont montré pourquoi l'ancien système a pris du retard. L'ancienne escouade a produit 68 000 commits en deux heures, soit environ 70 fois plus que la nouvelle. La plupart de cette activité était du travail perdu. L'ancienne exécution a accumulé plus de 70 000 conflits de fusion, tandis que la nouvelle est restée en dessous de 1 000 tout au long du test.

Le taux de conflit de l'ancienne version a continué d'accélérer au lieu de se stabiliser. Le fichier le plus contesté dans l'ancienne exécution a enregistré 7 771 conflits provenant de 1 173 agents, contre 47 dans la nouvelle exécution. Le même problème de cerveau divisé est apparu dans la structure du paquet. L'ancienne exécution a divisé le projet en 54 crates Rust avec trois paquets SQL distincts. La nouvelle exécution s'est rapidement arrêtée sur neuf crates.

Dans la configuration Fable 5, l'ancienne escouade avait besoin de 64 305 lignes de code moteur, tandis que la nouvelle n'en avait besoin que de 9 908. Dans la configuration Opus, l'ancien système a produit 19 013 lignes et a obtenu 97 %. Le nouveau système a atteint 100 % avec 4 645 lignes.

Avec des scores de test similaires ou meilleurs, la nouvelle architecture a réduit la taille de la base de code jusqu'à 85 %.

Des modèles de travailleurs moins chers ont créé les plus grandes économies

Les coûts totaux variaient de 1 339 $ pour l'hybride Opus à 10 565 $ pour GPT-5.5 fonctionnant seul. Les travailleurs représentaient au moins 69 % des jetons dans chaque exécution et généralement plus de 90 %. Les jetons des planificateurs coûtent plus cher, donc la répartition des coûts était différente. Dans l'hybride Opus, le planificateur produisait seulement une petite part des jetons mais représentait les deux tiers de la facture totale.

Les configurations les moins chères et les plus coûteuses différaient de coût par un facteur de 15 malgré des résultats comparables.

Le modèle de travailleur a créé le plus grand écart de coût. Dans l'exécution GPT-5.5, les travailleurs seuls ont coûté 9 373 $. Dans l'exécution utilisant Opus et Composer, l'ensemble de la flotte de travailleurs a coûté 411 $ à qualité comparable. La différence est presque entièrement due aux prix. Composer 2.5 est au niveau d'Opus 4.7 et GPT-5.5 mais coûte seulement 0,50 $ par million de jetons d'entrée et 2,50 $ par million de jetons de sortie. Le modèle est basé sur Kimi K2.5, selon Michael Truell, fondateur de Cursor.

Cursor soutient que seules quelques parties d'une grande tâche nécessitent l'intelligence d'un modèle avancé, y compris la décomposition des tâches et les décisions de conception clés. Une fois qu'un planificateur avancé résout l'ambiguïté, des modèles moins coûteux peuvent suivre son plan, bien que les exécutions hybrides aient montré que la qualité du planificateur comptait toujours. Le planificateur Fable 5 a utilisé moins de jetons de planification qu'Opus, mais ses travailleurs avaient besoin de beaucoup plus de jetons pour terminer le travail. L'exécution Fable a coûté plus cher au total.

Les travailleurs ont utilisé au moins 69 % des jetons dans chaque exécution mais n'ont représenté qu'une partie du coût.

Cursor décrit les escouades comme une sorte de compilateur probabiliste qui traduit l'intention en travail exécutable étape par étape. La société affirme que décrire cette intention avec précision était la principale contrainte de l'expérience. Cursor a publié la base de code de l'exécution solo Opus sous le nom de minisqlite sur GitHub.

Des exécutions comme celles-ci ne sont plus limitées aux expériences en laboratoire. Une version préliminaire de Fable 5 a géré la plupart de la réécriture de Bun de Zig à Rust. Soixante-quatre instances ont écrit plus d'un million de lignes de code en 11 jours pour environ 165 000 $. L'utilisation en production semble encore différente. Une étude publiée fin 2025 a révélé que 68 % des agents utilisés en production n'ont complété pas plus de dix étapes avant qu'un humain n'intervienne. Pour 47 %, la limite était de moins de cinq.