Les meilleurs modèles pour Pi Coding Agent dépendent de la tâche : commencez avec Claude Sonnet 5.5 pour le code au quotidien ou GPT-6.1 Sol pour une option OpenAI. Essayez Claude Opus 5.5 sur le débogage difficile, comparez MiniMax M3 et DeepSeek V4.1 Flash pour les tâches routinières, et testez Qwen3.8 27B lorsque le code doit rester sur votre machine.

Pi est un harnais d’agent extensible qui s’exécute dans votre terminal. Le harnais gère la conversation et les outils ; le modèle décide quels fichiers lire, quelles commandes exécuter et quoi modifier. Pi vous permet de changer de modèle au sein de ce workflow, afin de les comparer sur le même dépôt plutôt que de vous fier à des classements sans rapport.

Les ID de modèles et la disponibilité ont été vérifiés par rapport au catalogue Haimaker le 14 octobre 2026. Les recommandations combinent les informations actuelles des fournisseurs avec une petite évaluation Pi indépendante. Nous n’avons pas lancé de nouveau benchmark Haimaker de ces modèles dans Pi.

Avec quel modèle commencer dans Pi ?

Commencez avec Sonnet 5.5 ou GPT-6.1 Sol sur une tâche que vous savez déjà vérifier. Conservez l’accès aux outils et l’état du dépôt inchangés, puis comparez un candidat économique sur la même tâche. Passez à Opus lorsque le modèle moins cher répète une approche qui a échoué ou nécessite trop de corrections humaines.

Charge de travail PiModèle à essayerID de modèle HaimakerCompromis
Modifications quotidiennes, tests et travail sur le dépôtClaude Sonnet 5.5anthropic/claude-sonnet-5-5Coûte plus cher par token que les choix économiques
Codage et planification avec un modèle OpenAIGPT-6.1 Solopenai/gpt-6.1-solComparez l’effort de raisonnement et le total de tokens
Débogage difficile ou exigences peu clairesClaude Opus 5.5anthropic/claude-opus-5-5Tarifs par token plus élevés ; peut nécessiter moins de tentatives
Codage routinier à petit budgetMiniMax M3minimax/minimax-m3Testez les arguments d’outils et la reprise après erreur
Tâches en arrière-plan à faible coûtDeepSeek V4.1 Flashdeepseek/deepseek-v4.1-flashLes tentatives et la latence peuvent annuler l’avantage des tarifs bas
Autre comparaison économiqueGLM-5.3 Flashz-ai/glm-5.3-flashVérifiez les sorties longues et le temps total de la tâche
Recherche et entrées de documents volumineuxGemini 3.8 Flashgoogle/gemini-3.8-flashLa grande capacité d’entrée nécessite toujours une vérification des réponses
Recherche et raisonnement difficilesGemini 4 Argongoogle/gemini-4-argonNouveau candidat payant, absent de l’évaluation Pi ci-dessous

La vue d’ensemble des modèles d’Anthropic décrit les niveaux Claude actuels. La documentation Sol d’OpenAI couvre son rôle en codage et en agent, et la liste des modèles de Google couvre les choix Gemini. Ces descriptions aident à constituer une présélection ; elles ne désignent pas un vainqueur pour votre base de code.

C’est la même approche par tâche que celle utilisée dans notre guide des modèles Hermes. La configuration de Pi, le cycle de modèles et les contrôles de réflexion sont différents, utilisez donc la configuration Pi ci-dessous plutôt que de copier une configuration Hermes.

Que montrent les comparaisons réelles de codage avec Pi ?

Une petite évaluation Pi soutient l’idée de tester Sonnet, Sol et Opus avant de supposer qu’un modèle économique terminera plus vite ou à moindre coût. Elle montre aussi qu’un raisonnement plus poussé peut ajouter des vérifications et des appels d’outils sans améliorer la réussite sur une tâche facile. La comparaison pertinente est le résultat final, en incluant les tentatives échouées et le temps de vérification.

L’évaluation personnelle de codage d’Ibragim Badertdinov a utilisé 10 tâches avec 3 exécutions par configuration. Les résultats du 30 septembre rapportent :

Modèle et effortRéussite de la tâche en une tentativeTemps rapporté par tâche
Sonnet 5.5, élevé100 %46 secondes
GPT-6.1 Sol, moyen100 %1 minute 7 secondes
Opus 5.5, faible100 %37 secondes
DeepSeek V4.1 Flash, max93,3 %4 minutes 30 secondes
GLM-5.3 Flash, max96,7 %7 minutes 1 seconde

Ce sont les résultats de l’auteur, pas les nôtres. La méthodologie décrit des tâches clairement définies issues du travail de l’auteur, des vérifications automatisées et un accès API. Les tâches restent privées, et les résultats ont utilisé Pi 0.85.1, et non la version actuelle Pi 1.x. Des taux de réussite égaux n’établissent pas non plus une qualité de code égale.

La comparaison donne une raison de tester l’effort de raisonnement en plus du modèle. Opus à effort faible a terminé cette petite suite plus rapidement que les autres configurations affichées. Cela ne signifie pas qu’un effort faible suffit pour une migration difficile. Exécutez la tâche avec ses contraintes réelles, puis vérifiez si un raisonnement supplémentaire modifie le patch ou ajoute seulement des vérifications répétées.

Pour votre propre comparaison, enregistrez la réussite complète, les arguments d’outils incorrects, les nouvelles tentatives, le temps écoulé et la facture finale. Notre guide des coûts API pour agents de codage explique pourquoi les tarifs par token seuls peuvent donner la mauvaise réponse.

Comment connecter Pi à ces modèles ?

Utilisez Haimaker Connect pour connecter Pi sans écrire la configuration du fournisseur à la main. Installez Pi d’abord, puis exécutez Connect pour configurer ses fichiers natifs et vérifier la connexion.

Pour une nouvelle installation, le démarrage rapide de Pi utilise le package npm actuel ci-dessous et nécessite Node.js 22.19 ou plus récent :

npm install -g --ignore-scripts @earendil-works/pi-coding-agent
pi --version

Recommandé : Haimaker Connect

Exécutez l’assistant de configuration et choisissez Pi :

npx -y @haimaker/connect

Pour Pi avec la recommandation Sonnet ci-dessus, sélectionnez les deux explicitement :

npx -y @haimaker/connect --pi --model anthropic/claude-sonnet-5-5
pi --provider haimaker --model anthropic/claude-sonnet-5-5

Connect ouvre une connexion navigateur ou utilise un HAIMAKER_API_KEY existant. Il écrit le fournisseur Haimaker dans models.json, stocke la clé dans le auth.json de Pi, et vérifie une requête. Pi envoie ensuite les requêtes directement à Haimaker. Consultez la documentation du package Connect pour les options.

Sans --model, Connect configure haimaker/auto. Utilisez un modèle nommé pour les comparaisons afin que le routage ne change pas le modèle entre les requêtes. Connect écrit une seule entrée de modèle ; utilisez la configuration manuelle ci-dessous pour conserver plusieurs candidats dans le sélecteur de Pi. Il sauvegarde les fichiers existants, mais réécrit models.json en JSON sans commentaires.

Utilisez Haimaker Connect pour configurer Pi, puis comparez les modèles sur la même tâche de dépôt.

CONNECTER PI À HAIMAKER

Configuration manuelle : conserver plusieurs modèles dans le sélecteur

Définissez votre clé dans le shell qui lancera Pi :

export HAIMAKER_API_KEY=your-haimaker-key

Ajoutez ce fournisseur à ~/.pi/agent/models.json. Fusionnez-le dans un objet providers existant si vous en avez déjà un :

{
  "$schema": "https://pi.dev/schemas/models.schema.json",
  "providers": {
    "haimaker": {
      "baseUrl": "https://api.haimaker.ai/v1",
      "api": "openai-completions",
      "apiKey": "${HAIMAKER_API_KEY}",
      "models": [
        {
          "id": "anthropic/claude-sonnet-5-5",
          "name": "Claude Sonnet 5.5",
          "reasoning": true,
          "input": ["text", "image"],
          "contextWindow": 1000000,
          "maxTokens": 128000
        },
        {
          "id": "openai/gpt-6.1-sol",
          "name": "GPT-6.1 Sol",
          "reasoning": true,
          "input": ["text", "image"],
          "contextWindow": 922000,
          "maxTokens": 128000
        },
        {
          "id": "minimax/minimax-m3",
          "name": "MiniMax M3",
          "reasoning": true,
          "input": ["text", "image"],
          "contextWindow": 1000000,
          "maxTokens": 128000
        }
      ]
    }
  }
}

Les limites ci-dessus décrivent le catalogue Haimaker vérifié, qui peut différer de l’API directe d’un fournisseur. Pi accepte l’interpolation d’environnement dans les identifiants du fournisseur ; consultez son guide de configuration des modèles. Commencez avec une tâche circonscrite avant d’envoyer un contexte de dépôt volumineux.

Sélectionnez le modèle avec les deux identifiants :

pi --provider haimaker --model anthropic/claude-sonnet-5-5

Dans Pi, ouvrez /model pour sélectionner un autre modèle configuré. Le sélecteur recharge models.json. Les métadonnées de tarification personnalisées sont omises de cet exemple car les tarifs changent ; vérifiez la facture du fournisseur plutôt que de traiter un affichage de coût de session non configuré comme une exécution à coût nul mesuré.

Un compte fournisseur que vous possédez déjà

Pour un fournisseur intégré, exécutez /login et suivez le flux d’authentification de Pi, puis choisissez un modèle avec /model. La référence des fournisseurs de Pi liste les variables de clé API et les options spécifiques au fournisseur. Un abonnement et une clé API à consommation peuvent avoir des accès et une facturation différents, utilisez donc la méthode de connexion que votre compte prend réellement en charge.

Comment définir les niveaux de réflexion et changer de modèle ?

Gardez le choix du modèle et l’effort de réflexion comme variables séparées. Utilisez un effort modéré lorsque c’est pris en charge pour la première comparaison, puis augmentez-le sur une tâche qui nécessite plus de raisonnement. Pi restreint les niveaux aux capacités du modèle sélectionné. Comparez l’utilisation de tokens et l’achèvement lors du choix de l’effort ; les fournisseurs interprètent le même niveau différemment.

La référence CLI de Pi prend en charge un modèle et un effort explicites :

pi --provider haimaker --model openai/gpt-6.1-sol --thinking medium

Dans une session interactive, /thinking change l’effort et /scoped-models choisit les modèles parmi lesquels vous parcourez avec Ctrl+P. Commencez avec 2 modèles dans ce cycle : un candidat pour les tâches routinières et une alternative plus puissante. N’en ajoutez un autre que lorsqu’il résout un échec récurrent. Enregistrez une valeur par défaut au démarrage depuis le sélecteur de modèles avec Ctrl+S.

Changer de modèle manuellement garde le choix visible. Le haimaker/auto de Haimaker route côté API. Pour le routage au sein de Pi, utilisez le routage de modèles virtuels via les extensions. Configurez et testez cette extension séparément. Plusieurs entrées dans models.json vous donnent des modèles sélectionnables ; la liste ne choisit pas entre eux.

Pi sépare également les modèles de codage des modèles de classification et d’image. Sa documentation actuelle liste GPT-6 Luna via l’API Decisions comme classifieur utilisé par Codemode, plutôt que le sélecteur de conversation principal. Vérifiez l’API et le rôle du modèle lorsque vous suivez une recommandation communautaire, surtout si elle a été faite sur une ancienne version de Pi.

Quels modèles locaux valent la peine d’être essayés avec Pi ?

Comparez Qwen3.8 27B, Muse Glimmer 30B et Qwen3 Coder 30B lorsque vous disposez de mémoire de station de travail et souhaitez une inférence locale. Utilisez Gemma 4 E4B ou Qwen3 8B sur des machines plus petites. Vérifiez si le modèle local utilise correctement les outils de Pi et récupère après l’échec d’une commande.

Pi dispose d’une intégration routeur llama.cpp documentée pour les modèles GGUF. Si vous utilisez déjà Ollama, configurez son endpoint compatible OpenAI séparé. Téléchargez un modèle adapté à la machine, puis ajoutez son tag exact à models.json :

ollama pull qwen3.8:27b

{
  "providers": {
    "ollama": {
      "baseUrl": "http://localhost:11434/v1",
      "api": "openai-completions",
      "apiKey": "ollama",
      "models": [
        {
          "id": "qwen3.8:27b",
          "name": "Qwen3.8 27B local",
          "reasoning": true,
          "input": ["text", "image"],
          "contextWindow": 32768,
          "maxTokens": 8192
        }
      ]
    }
  }
}

La clé fictive permet à Pi de résoudre l’authentification pour le fournisseur local ; Ollama l’ignore. Fusionnez ce fournisseur à côté de toute configuration cloud, puis sélectionnez-le :

pi --provider ollama --model qwen3.8:27b

La fiche Ollama de Qwen3.8 indique un téléchargement d’environ 18 Go, avant l’état de contexte et les tampons d’exécution. Un GPU de 24 Go ou une machine avec 32 Go+ de mémoire unifiée est un point de départ pour une session circonscrite. Le contexte de 32K dans cet exemple est un réglage de départ conservateur, pas une garantie d’adéquation. Pour des machines plus petites et d’autres candidats, consultez notre guide des modèles de codage Ollama.

L’inférence locale garde les prompts du modèle sur votre machine. Les outils externes peuvent toujours envoyer des données ailleurs, et un modèle avec un tag cloud utilise une inférence hébergée. Vérifiez à la fois le point de terminaison et les outils activés lorsque vous gardez le code privé.

Questions fréquemment posées

Puis-je changer de modèle sans perdre ma session Pi ?

Oui. Utilisez /model pour changer de modèle dans une session Pi existante. Pi enregistre les changements de modèle et de niveau de réflexion, et la reprise les restaure. Utilisez /scoped-models pour choisir les modèles disponibles pour le cyclage avec Ctrl+P.

Pourquoi mon modèle personnalisé n’apparaît-il pas dans Pi ?

Vérifiez que Pi peut résoudre les identifiants du fournisseur et que l’ID du modèle figure dans models.json. Une variable d’environnement doit être présente dans le processus qui lance Pi. Les modèles de classification et d’image utilisent des outils séparés et n’apparaissent pas dans le sélecteur principal /model.

Pi prend-il en charge Haimaker et les modèles Ollama locaux ?

Oui. Utilisez npx -y @haimaker/connect —pi pour configurer Haimaker via les fichiers natifs de Pi, ou ajoutez le fournisseur manuellement dans ~/.pi/agent/models.json. Ollama utilise un fournisseur local séparé à http://localhost:11434/v1 avec le tag exact du modèle local.

Commencez avec une tâche vérifiée du dépôt, gardez les outils et le contexte de Pi inchangés, et comparez deux modèles. Gardez le modèle qui la termine correctement avec moins d’attente et de vérification. Répétez cette comparaison lorsqu’une nouvelle version corrige une défaillance que vous rencontrez réellement.