Pivert's Blog

Reading Time: 14 minutes

---

Mise à jour 09/2026

Les choses évoluent très vite avec l’IA, et cet article a déjà pris quelque rides. Les principes restent, mais j’ai du revoir complètement mon setup :

• OMO n’étant compatible ni avec GPT-6-Luna, ni avec Opencode v2 car ils favorisent maintenant leur propre harnais. Harnais qui ne prenait même pas ollama-cloud en charge, et redirigeant vers des fournisseurs bien plus coûteux… J’ai bien du me rendre à l’évidence : OMO nous a quitté.
• Heureusement, il existe un autre projet qui a pris le trou laissé par OMO : OMO-slim

Résumé

La facture mensuelle se situe entre 15–35 € pour environ 15–20 heures de codage soutenu par semaine. Voici la composition réelle :

• Ollama Cloud Pro (annuel) : 15 €/mois en forfait plat (15 €/mois à partir de 200 $/an, soit ~2 mois offerts par rapport au tarif mensuel).
• Extra usage Ollama Cloud : 0–10 €/mois pour débloquer du quota supplémentaire quand on atteint les limites de session, ou pour utiliser Kimi K3 ponctuellement.
• OpenCode Zen (pay-per-use) : 0–10 €/mois, presque entièrement pour la catégorie writing et les rares fallbacks.

Sur les mois faibles ou les vacances, la facture tombe à la moitié, car l’extra usage et Zen sont consommés proportionnellement.

Trois décisions gardent le stack compétitif sans le rendre stupide :

• Routage par catégories. Les modèles sont assignés à des types de travail, pas à des agents individuels.
• Spécialisation GLM. glm-5.2 pour la planification et l’infrastructure, glm-5.3 pour le raisonnement profond, glm-5.3-flash pour les tâches visuelles.
• Fallback automatique sur quota Ollama. Oh My OpenAgent est configuré pour basculer sur les modèles de fallback en cas d’erreur 402 ou 429 d’Ollama Cloud.

Qu’est-ce qu’Oh My OpenAgent ?

OpenCode est un framework de codage assisté par IA. Par défaut il fonctionne comme une conversation mono-modèle.

Oh My OpenAgent transforme OpenCode en un système multi-agents. Chaque agent est rattaché à une catégorie, et chaque catégorie a son propre modèle principal et sa chaîne de fallback. On ne choisit pas un seul modèle pour tout : le plugin route le travail vers le modèle le plus adapté.

Routage par catégories : le cœur du design

Les modèles sont configurés par catégorie. Les agents héritent du modèle, de la variante, du flag de réflexion (thinking), de la température et des fallbacks de leur catégorie. L’agent décide quel type de travail c’est ; la catégorie décide quel modèle l’exécute.

Cela change la gestion des coûts : on ne raisonne plus agent par agent, mais par type de tâche.

Les catégories

Catégorie	Modèle principal	Variante / notes	Fallbacks	Usage
quick	ollama-cloud/deepseek-v4-flash	default	opencode/deepseek-v4-flash	Tâches triviales
unspecified-low	ollama-cloud/deepseek-v4-flash	balanced	opencode/deepseek-v4-flash	Tâches modérées
unspecified-high	ollama-cloud/kimi-k2.7-code	high	opencode/kimi-k2.6 moonshot.ai/kimi-k2.7-code	Tâches multi-fichiers complexes
deep	ollama-cloud/glm-5.3	max, thinking activé	ollama-cloud/deepseek-v4-pro ollama-cloud/kimi-k2.7-code opencode/gemini-3.1-pro (high)	Raisonnement technique premium
visual-engineering	ollama-cloud/glm-5.3-flash	flash multimodal	ollama-cloud/minimax-m3 opencode/gemini-3.5-flash-lite ollama-cloud/deepseek-v4-pro opencode/gemini-3.1-pro	UI/UX, captures, diagrammes
ultrabrain	ollama-cloud/kimi-k2.7-code	max, thinking activé	opencode/kimi-k2.6 moonshot.ai/kimi-k2.7-code	Raisonnement maximal
writing	ollama-cloud/deepseek-v4-flash	—	opencode/deepseek-v4-flash ollama-cloud/glm-5.2	Documentation
infrastructure	ollama-cloud/glm-5.2	température 0.15	ollama-cloud/kimi-k2.7-code	Terraform, K8s, Ansible
planning	ollama-cloud/glm-5.2	max, thinking activé	ollama-cloud/kimi-k2.7-code	Plans de travail
orchestrator	ollama-cloud/kimi-k2.7-code	high	opencode/deepseek-v4-flash ollama-cloud/deepseek-v4-flash	Sisyphus, tous les messages

Neuf catégories sur dix partent sur Ollama Cloud. Seule la catégorie writing part sur OpenCode Zen, car le modèle gratuit est suffisant pour la documentation et cela préserve le quota Ollama pour le code.

Pourquoi garder GLM-5.2 quand GLM-5.3 existe ?

GLM-5.2 n’est pas “meilleur” que GLM-5.3, mais il est moins cher en quota pour des tâches qui n’ont pas besoin du raisonnement maximal :

• glm-5.2 est un modèle à grand contexte peu gourmand. Il gère planning et infrastructure parce que ces deux tâches demandent du contexte long, une sortie structurée, mais pas le meilleur raisonnement du marché.
• glm-5.3 est le modèle de codage open-weights le plus fort. Il tient la catégorie deep : revue d’architecture, debugging difficile, recherche sécurité.
• glm-5.3-flash est multimodal natif et tarifé comme un flash. Il tient visual-engineering : captures d’écran, diff UI, diagrammes.

C’est le contraire du “un seul modèle fort partout”. Chaque variante GLM est choisie pour un compromis coût/raisonnement précis.

Les agents se mappent sur les catégories

Agent	Rôle	Catégorie	Pourquoi cette catégorie
Sisyphus	Orchestrateur, reçoit tous les messages	orchestrator	Doit déléguer, pas forcément raisonner au niveau 4
Oracle	Consultant architecture en lecture seule	deep	Besoin du raisonnement le plus fort
Prometheus	Planificateur stratégique	planning	La planification aime le grand contexte à coût modéré
Plan	Planificateur structuré	planning	Même logique que Prometheus
Metis	Analyste pré-planification	ultrabrain	Attrape les contraintes avant la planification
Momus	Critique impitoyable	unspecified-high	Critic de qualité, gardé hors GPT autant que possible
Librarian	Recherche documentation et OSS	quick	Recherche en masse, flash suffit
Explore	Grep rapide du codebase	quick	Recherche de motifs, flash suffit
Atlas	Orchestrateur de tâches	unspecified-low	Exécution de plan, flash suffit
Sisyphus-Junior	Worker d’implémentation ciblé	unspecified-high	L’implémentation complexe reste sur Kimi
Multimodal-Looker	Analyste visuel	visual-engineering	Focus multimodal + UI
Hephaestus	Worker profond	deep	Même catégorie deep, GPT n’est qu’un fallback d’urgence

Les agents en lecture seule (Oracle, Librarian, Explore, Multimodal-Looker) ne peuvent pas écrire. Momus ne peut pas écrire. Sisyphus-Junior ne peut pas redéléguer. Ces restrictions maintiennent chacun dans son rôle.

Le choix de l’orchestrateur : Sisyphus et le quota Ollama

Sisyphus est la décision de routage la plus coûteuse, car il voit tous les messages. Le choix actuel est ollama-cloud/kimi-k2.7-code (niveau 3 / usage élevé). Le candidat moins cher évident est ollama-cloud/deepseek-v4-flash (niveau 2 / usage moyen, contexte 1 M, outils, thinking, vision).

Le compromis est réel mais étroit :

• Kimi K2.7-code délègue peut-être un peu mieux sur des requêtes ambiguës, et il est parfois utilisé par Sisyphus pour exécuter directement au lieu de déléguer.
• DeepSeek V4 Flash est moins cher, a une fenêtre de contexte de 1 M tokens, et supporte la même surface d’outils et de réflexion.

C’est l’expérience en cours : l’orchestrateur de porte d’entrée peut-il descendre d’un niveau d’usage sans dégrader la qualité de délégation ? Si oui, le quota Ollama s’étire sans changement de comportement pour l’utilisateur. Si non, Kimi reste. La structure par catégories rend ce test trivial : changer le modèle principal de la catégorie orchestrator, redémarrer OpenCode, observer une semaine.

Compactage (/compact)

Le compactage de contexte — la summarisation automatique qui empêche les longues sessions de déborder — utilise ollama-cloud/deepseek-v4-flash. Il est configuré directement dans opencode.jsonc via l’override natif agent.compaction.model, pas via un plugin.

C’est le bon modèle pour cette tâche : grand contexte (1 M), bon marché, et suffisant pour produire des résumés de continuation. Cela évite aussi au modèle de session de gaspiller sa propre fenêtre de contexte en summarisation.

Basculement automatique en cas de quota Ollama épuisé

Avec Ollama Cloud Pro, on atteint parfois le message :

extra usage auto reload monthly max reached, increase your monthly max or add extra usage at https://ollama.com/settings …

Par défaut, Oh My OpenAgent ne bascule pas sur les fallback_models configurés dans ce cas. Pourquoi ? Le mécanisme de fallback (runtime_fallback) est désactivé par défaut, et sa liste retry_on_errors ne contient que [429, 500, 502, 503, 504]. L’erreur Ollama Cloud arrive souvent avec un code 402, absent de cette liste, et le message ne contient pas littéralement “Payment Required”. Résultat : le fallback ne se déclenche pas.

La correction est une seule section au niveau racine de oh-my-openagent.jsonc :

"runtime_fallback": {
  "enabled": true,
  "retry_on_errors": [402, 429, 500, 502, 503, 504],
  "max_fallback_attempts": 3,
  "cooldown_seconds": 60,
  "timeout_seconds": 30,
  "notify_on_fallback": true,
  "restore_primary_after_cooldown": false
}

Avec ce bloc, les chaînes de fallback déjà définies par catégorie sont enfin activées. Si Ollama Cloud répond 402 ou 429, OMO tente automatiquement le modèle de fallback suivant. restore_primary_after_cooldown: false évite de rebasculer vers le modèle Ollama épuisé.

Comment invoquer agents et catégories directement

Mentions @

Raccourci	Route vers	Usage typique
@oracle	Oracle	Architecture, sécurité, debugging difficile
@librarian	Librarian	Documentation, exemples, internals de librairies
@explore	Explore	Trouver des motifs, références, conventions
@plan "…"	Prometheus	Créer un plan structuré avant de coder

Tous les agents enregistrés apparaissent aussi dans le picker OpenCode (@sisyphus, @hephaestus, @prometheus, @atlas, @momus, @metis, @sisyphus-junior, @multimodal-looker).

Différence entre @plan "…" et /plan

• @plan "ma description" est une mention d’agent : on envoie directement un message à Prometheus avec l’intention à planifier. Le texte entre guillemets devient le prompt de planification. C’est rapide et ciblé.
• /plan est une commande slash intégrée : elle active le mode planification de l’agent plan (ou Prometheus selon la config) et attend que l’on poursuive la conversation pour affiner le plan. C’est plus interactif et adapté quand l’idée n’est pas encore claire.

En pratique, @plan "refactor le parser JSON" lance un plan sur une requête précise, tandis que /plan ouvre un dialogue structuré avant de rédiger le plan final.

Délégation par catégorie

Sisyphus ne code pas en dur un agent pour chaque micro-tâche. Il délègue par catégorie :

• task(category="visual-engineering", ...) → route vers le modèle visual-engineering.
• task(category="quick", ...) → route vers le modèle quick.
• task(subagent_type="explore", ...) → route vers l’agent Explore.

Cette séparation est la raison d’être des catégories : Sisyphus choisit le type de travail sans connaître le modèle exact.

Modes et commandes

Mot-clé / commande	Effet
ultrawork / ulw	Mode exécution parallèle d’agents
search / find	Focus recherche web et documentation
analyze / investigate / audit / deep-dive	Analyse approfondie de contexte
hyperplan / hpp	Revue de plan adversariale
/start-work	Active Atlas sur le dernier plan Prometheus
/plan	Passe en mode planification structurée
/refactor	Refactoring assisté LSP + AST-grep
/review-work	Lance des agents QA en parallèle
/handoff	Génère un résumé de contexte pour une nouvelle session

Raccourcis essentiels : modèles, thinking et agents

Ces raccourcis TUI sont les plus utilisés quand on travaille avec un stack multi-modèle. Tous sont documentés dans la référence OpenCode Keybinds.

Raccourci	Action	Pourquoi c’est utile
Ctrl+X M	Ouvrir le sélecteur de modèles pour l’agent courant	Basculer entre les modèles (ex. passer de Kimi à DeepSeek) sans quitter la session. C’est le raccourci le plus pratique pour tester un modèle différent sur la même tâche.
Ctrl+T	Cycle les variantes du modèle courant (thinking/reasoning)	Active ou désactive le raisonnement profond sur le modèle en cours. Ex. démarrer une tâche simple sans thinking, puis passer à max si le raisonnement s’avère nécessaire. Respecte les variantes configurées dans votre oh-my-openagent.jsonc.
F2 / Shift+F2	Aller au modèle / au modèle précédent récemment utilisé	Changement instantané sans dialogue — idéal quand on alterne entre deux modèles (ex. Kimi ↔ DeepSeek).
Tab / Shift+Tab	Cycle les agents principaux (Sisyphus ↔ Hephaestus ↔ Prometheus…)	Passer d’un agent à l’autre sans taper @mention. Avec Oh My OpenAgent, chaque agent a sa catégorie et donc son modèle propre.
Ctrl+X A	Ouvrir le sélecteur d’agents	Liste complète des agents enregistrés — utile quand on a plus de 5 agents et qu’on ne les connaît pas tous par cœur.

Note importante : Ctrl+R seul est le raccourci pour renommer la session courante, pas pour changer de modèle. Le raccourci modèle est Ctrl+X M (leader Ctrl+X + M). Ctrl+T ne modifie pas le modèle — il cycle ses variants (thinking, effort de raisonnement). Pour changer le modèle lui-même, utilisez Ctrl+X M ou F2.

Répartition mensuelle du coût

Composant	Coût	Notes
Ollama Cloud Pro (annuel)	15 €/mois	Forfait plat, 3 modèles cloud simultanés, quotas GPU généreux (15 €/mois = 200 $/an ÷ 12)
Extra usage Ollama Cloud	0–10 €/mois	Quand on atteint les limites de session, ou pour du Kimi K3 ponctuel
OpenCode Zen pay-per-use	0–10 €/mois	Presque entièrement la catégorie writing ; fallbacks occasionnels
TOTAL	~15–35 €/mois	15–20h/semaine de codage soutenu

Sur les mois faibles ou les congés, le total peut tomber à ~15 €, car l’extra usage et Zen ne sont pas consommés.

Pourquoi c’est le meilleur ratio inférence/prix : on ne paie pas au token, mais au temps GPU. Les sessions ont des limites qui se réinitialisent toutes les 5 heures ; les limites hebdomadaires se réinitialisent tous les 7 jours (le lundi, alignées sur le même instant pour tous les comptes). Sur un modèle d’usage moyen comme DeepSeek V4 Flash, le forfait Pro couvre un usage quotidien quasi illimité — bien plus intéressant qu’une API au token pour un usage intensif de codage/agents. Les 15 €/mois proviennent du tarif annuel : 200 $/an ÷ 12 ≈ 16,67 $/mois, soit environ 15 €/mois (conversion approximative, le site ne publie pas de prix en euros), et ~2 mois offerts par rapport au mensuel (20 $/mois). Plus de détails : Ollama Cloud pricing.

Coût réel pour 100 requêtes : Pay As You Go vs forfait

Voici un exemple réel de facturation Pay As You Go sur Ollama Cloud pour des sessions de codage standards :

Modèle	Requêtes facturées	Coût Pay As You Go	Coût approximatif pour 100 requêtes	Usage Level Ollama
kimi-k2.7-code	99	3,25 $	~3,28 $	High
deepseek-v4-flash:0731	124	0,78 $	~0,63 $	Medium

À titre de comparaison, 5 heures de forfait Ollama Cloud Pro (la limite de session qui se réinitialise toutes les 5 h) coûtent environ 1 $ au tarif annuel (200 $/an). Sur kimi-k2.7-code, ces 5 h permettent d’exécuter environ 400 à 500 requêtes/sessions. Autrement dit, avec le forfait, 100 requêtes sur Kimi K2.7 reviennent à environ 0,20–0,25 $, soit 13 à 16 fois moins cher que le Pay As You Go.

Comment lire le coût d’un modèle avant de l’utiliser : sur la page d’un modèle Ollama Cloud, consultez son niveau d’Usage (affiché sous le nom du modèle) :

• Medium (ex. deepseek-v4-flash) = consommation moyenne, raisonnable en forfait, encore abordable en Pay As You Go.
• High (ex. kimi-k2.7-code, glm-5.3, minimax-m3) = consommation élevée, à réserver au forfait ou à n’utiliser en Pay As You Go qu’avec parcimonie.
• Extra High (ex. deepseek-v4-pro) = à éviter en Pay As You Go sauf urgence.

Ce n’est pas un prix au token : Ollama Cloud facture au temps GPU. Une requête courte et contextuelle coûte moins qu’une longue session de raisonnement. Le niveau Usage reste néanmoins le meilleur indicateur rapide pour comparer deux modèles entre eux.

Attention au Pay As You Go Ollama : c’est ~20× plus cher que le forfait. Une session de 5h (≈ 1 $) permet d’exécuter 400 à 600 sessions sur Kimi K2.7. Ajouter 5 $ en Pay As You Go ne permet d’exécuter que 100 à 150 sessions sur Kimi K2.7. À n’utiliser qu’avec parcimonie, ou pour des modèles exclusifs Pay As You Go comme Kimi K3 (cher, disponible uniquement en Pay As You Go). Si cela se reproduit régulièrement, on dépasse vite 20 $/mois : envisagez un abonnement supérieur ou le plan Max (momentanément indisponible à cause de la forte demande sur Ollama Cloud).

L’économie ne vient pas d’utiliser le modèle le plus faible partout. Elle vient de garder la majeure partie du travail dans un forfait plat, et de payer à l’usage uniquement là où l’option gratuite est réellement suffisante.

Modèles gratuits OpenCode Zen : la plateforme propose occasionnellement des modèles gratuits (ex. deepseek-v4-flash-free, mimo-v2.5-free, nemotron-3-ultra-free). Ils sont très intéressants pour diminuer le budget, mais leur disponibilité change trop souvent pour être étudiée dans cet article. Si vous en trouvez un qui fonctionne, utilisez-le pour la catégorie writing — vous économiserez le reste de votre facture Zen.

Confidentialité et résidence des données

Tous les modèles Ollama Cloud tournent sur l’infrastructure NVIDIA US/EU d’Ollama. Kimi, GLM et DeepSeek sont des modèles open-weights tirés de HuggingFace. Les données ne transitent pas par des endpoints API chinois, et les conditions d’Ollama restent zero-logging, zero-retention.

OpenCode Zen n’est utilisé que pour la catégorie writing et les rares fallbacks. La majeure partie du raisonnement sur le code ne quitte jamais Ollama Cloud.

Configuration Automatique

Si vous préférez laisser un agent s’occuper de tout, copiez-collez le prompt ci-dessous directement dans la console OpenCode (Ctrl+Enter pour envoyer sans soumettre, puis Enter pour valider). L’agent Sisyphus créera les fichiers de configuration, appliquera les patches OMO et vous guidera pour la connexion.

Configure mon OpenCode avec un stack multi-modèle Oh My OpenAgent, en suivant exactement les configs publiées dans l'article https://www.pivert.org/opencode-oh-my-openagent-building-a-multi-model-ai-coding-stack-for-e30-month/ :

1. Installe Oh My OpenAgent si absent : npm i -g oh-my-openagent
2. Crée ~/.config/opencode/ s'il n'existe pas
3. Récupère les deux fichiers de configuration depuis l'article (opencode.jsonc et oh-my-openagent.jsonc)
4. Écris-les dans ~/.config/opencode/
5. Vérifie qu'il n'y a pas une config en .json qui pourrait rentrer en conflit avec notre version avec commentaire .jsonc pour opencode et oh-my-openagent . Vérifie également qu'il ne reste pas une ancienne configuration de oh-my-opencode.json (ou jsonc)
6. Applique les patches OMO pour détecter ollama-cloud et respecter les overrides de modèle (exécute node restore_omo.js ou crée-le)
7. Vérifie avec bunx oh-my-openagent doctor
8. Guide-moi pour /connect (Ollama Cloud) et opencode auth login (Zen)

Une fois terminé, confirme-moi que tout est configuré et dis-moi comment lancer OpenCode.

Référence : l’article OpenCode + Oh My OpenAgent : un stack multi-modèle à ~15–35 €/mois fait office de base de connaissances complète (routage par catégories, fallback, modèles, coût).

Configuration Manuelle

Si Oh My OpenAgent n’est pas encore installé

• Installez le plugin :

npm i -g oh-my-openagent

• Créez le répertoire de config s’il n’existe pas :

mkdir -p ~/.config/opencode

• Copiez les fichiers de configuration ci-dessous dans ~/.config/opencode/.

• Appliquez les patches OMO (requis pour détecter le provider ollama-cloud et respecter les overrides de modèle) :

node restore_omo.js

• Connectez OpenCode à Ollama Cloud via /connect dans le terminal.

Si vous utilisez aussi OpenCode Zen, lancez opencode auth login pour le provider opencode.

Si Oh My OpenAgent est déjà installé

• Sauter l’étape 1.
• Copiez les fichiers de configuration ci-dessous dans ~/.config/opencode/.
• Vérifiez que les patches sont appliqués :

bunx oh-my-openagent doctor

Si des problèmes sont signalés, relancez node restore_omo.js.

• Connectez OpenCode à Ollama Cloud via /connect dans le terminal.

Si vous utilisez aussi OpenCode Zen, lancez opencode auth login pour le provider opencode.

opencode.jsonc

{
    "$schema": "https://opencode.ai/config.json",

    //
    // DEFAULT MODEL
    //
    // DeepSeek V4 Flash via Ollama Cloud est le modèle par défaut d’OpenCode.
    // C’est le fallback ultime pour tout agent qui n’a pas de modèle explicite.
    // Il est sur Ollama Cloud (forfait plat) et non sur Zen (pay-per-use)
    // parce qu’on veut que les appels fréquents (et les erreurs Ollama)
    // restent dans le forfait Ollama Pro.
    //
    "model": "ollama-cloud/deepseek-v4-flash",

    //
    // PROVIDERS
    //
    // Ollama Cloud est déclaré comme un provider "openai-compatible".
    // L’authentification se fait via la commande /connect d’OpenCode
    // (stockée dans ~/.local/share/opencode/auth.json), donc pas de clé API
    // écrite en dur ici.
    //
    "provider": {
        "ollama-cloud": {
            "npm": "@ai-sdk/openai-compatible",
            "name": "Ollama Cloud",
            "models": {
                //
                // DeepSeek V4 Pro : raisonnement premium, 1 M de contexte.
                // On déclare les flags de compatibilité parce que ce modèle
                // DeepSeek via l’API-compatible d’Ollama a besoin de
                // contenu "reasoning" et de contenu "assistant" pour les appels
                // d’outils. Sans ces flags, certains outils échouent.
                //
                "deepseek-v4-pro": {
                    "name": "DeepSeek V4 Pro",
                    "compat": {
                        "supportsToolChoice": false,
                        "requiresReasoningContentForToolCalls": true,
                        "requiresAssistantContentForToolCalls": true
                    },
                    "limit": {
                        "context": 1048576,
                        "output": 65536
                    }
                },

                //
                // DeepSeek V4 Flash : modèle principal par défaut, compactage,
                // et tâches rapides. 1 M de contexte, outils, thinking, vision.
                // Même compatibilité spécifique que V4 Pro.
                //
                "deepseek-v4-flash": {
                    "name": "DeepSeek V4 Flash",
                    "compat": {
                        "supportsToolChoice": false,
                        "requiresReasoningContentForToolCalls": true,
                        "requiresAssistantContentForToolCalls": true
                    },
                    "limit": {
                        "context": 1048576,
                        "output": 65536
                    }
                },

                //
                // Kimi K2.7-code : modèle d’orchestration et d’implémentation
                // complexe. 256 K de contexte, outils, thinking, vision.
                // On le met sur Ollama Cloud (pas Zen) pour rester dans
                // le forfait plat.
                //
                "kimi-k2.7-code": {
                    "name": "Kimi K2.7 Code",
                    "limit": {
                        "context": 262144,
                        "output": 65536
                    }
                },

                //
                // GLM 5.2 : grand contexte (~976 K) à coût plus faible que
                // GLM 5.3. Idéal pour la planification et l’infrastructure,
                // qui ont besoin de contexte long sans raisonnement maximal.
                //
                "glm-5.2": {
                    "name": "GLM 5.2",
                    "limit": {
                        "context": 976000,
                        "output": 65536
                    }
                },

                //
                // GLM 5.3 : le modèle open-weights de codage le plus fort
                // disponible sur Ollama Cloud. Utilisé pour la catégorie deep
                // (architecture, debugging difficile, sécurité).
                //
                "glm-5.3": {
                    "name": "GLM 5.3",
                    "limit": {
                        "context": 976000,
                        "output": 65536
                    }
                },

                //
                // GLM 5.3-flash : version multimodale et flash de GLM 5.3.
                // Tarifé comme un flash, avec ~976 K de contexte.
                // Parfait pour visual-engineering (captures, UI, diagrammes).
                //
                "glm-5.3-flash": {
                    "name": "GLM 5.3 Flash",
                    "limit": {
                        "context": 976000,
                        "output": 65536
                    }
                },

                //
                // MiniMax M3 : fallback multimodal pour visual-engineering.
                // 512 K de contexte, vision, raisonnement.
                //
                "minimax-m3": {
                    "name": "MiniMax M3",
                    "limit": {
                        "context": 512000,
                        "output": 65536
                    }
                }
            }
        }
    },

    //
    // AGENTS
    //
    "agent": {
        // Built-in compaction agent : on force le compactage de contexte
        // à utiliser DeepSeek V4 Flash. Grand contexte (1 M), bon marché,
        // et suffisant pour produire des résumés de continuation.
        // Cet override est natif dans OpenCode ; pas besoin de plugin.
        "compaction": {
            "model": "ollama-cloud/deepseek-v4-flash"
        }
    },

    //
    // PLUGINS
    //
    "plugin": [
        "oh-my-openagent"
    ]
}

oh-my-openagent.jsonc

//
// OH-MY-OPENAGENT CONFIGURATION — category-driven model routing
//
// VERSION PUBLIQUE
//
// Copiez ce fichier dans ~/.config/opencode/oh-my-openagent.jsonc et installez
// le plugin oh-my-openagent. Connectez OpenCode à Ollama Cloud via /connect
// avant d’utiliser les modèles ollama-cloud/*.
//
// ──────────────────────────────────────────────────────────────────────────────
// Les modèles sont définis par catégorie uniquement. Les agents héritent de
// leur catégorie. Cela supprime la duplication de configuration et permet de
// modifier les coûts en changeant une seule catégorie.
//
// Pourquoi Ollama Cloud comme provider principal ?
//   - Forfait plat (15 €/mois avec 3 modèles simultanés).
//   - Open-weights (Kimi, GLM, DeepSeek) hébergés sur l’infra EU/US d’Ollama.
//   - Les modèles Zen (opencode/*) restent des fallbacks et la catégorie writing.
//
// ──────────────────────────────────────────────────────────────────────────────

{
  "$schema": "https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/dev/assets/oh-my-opencode.schema.json",

  //
  // AGENTS
  //
  // Chaque agent est assigné à une catégorie. Le modèle effectif vient de la
  // catégorie, pas de l’agent. Les règles d’écriture empêchent certains agents
  // d’éditer ou de redéléguer, ce qui maintient chacun dans son rôle.
  //
  "agents": {
    // Sisyphus reçoit 100 % des messages. Il est dans une catégorie dédiée
    // pour pouvoir optimiser son coût indépendamment du reste.
    "sisyphus": {
      "category": "orchestrator",
      "prompt_append": "CRITICAL: Do NOT implement code directly. Delegate all implementation via `sisyphus_task` to the correct sub-agent."
    },

    // Oracle, Hephaestus : raisonnement profond, catégorie deep.
    "oracle": { "category": "deep" },
    "hephaestus": {
      "category": "deep",
      // Par défaut le plugin force Hephaestus sur un modèle GPT.
      // On l’autorise explicitement à utiliser le modèle de sa catégorie.
      "allow_non_gpt_model": true
    },

    // Prometheus / Plan : planification structurée.
    "prometheus": { "category": "planning" },
    "plan": { "category": "planning" },

    // Metis : analyse pré-planification, raisonnement maximal.
    "metis": { "category": "ultrabrain" },

    // Momus : critique de plan. On le garde sur Kimi (pas GPT) autant que possible.
    "momus": { "category": "unspecified-high" },

    // Librarian, Explore, Atlas : tâches à haut volume, modèles flash suffisants.
    "librarian": { "category": "quick" },
    "explore": { "category": "quick" },
    "atlas": { "category": "unspecified-low" },

    // Sisyphus-Junior : worker d’implémentation complexe.
    "sisyphus-junior": { "category": "unspecified-high" },

    // Multimodal-Looker : vision/UI.
    "multimodal-looker": { "category": "visual-engineering" }
  },

  //
  // CATEGORIES
  //
  // C’est ici que sont définis les modèles. Chaque catégorie a :
  //   - un modèle principal (obligatoire)
  //   - une variante et des flags optionnels (thinking, température)
  //   - une chaîne de fallback_models
  //
  "categories": {
    // Tâches triviales : le moins cher possible, DeepSeek V4 Flash.
    "quick": {
      "model": "ollama-cloud/deepseek-v4-flash",
      "variant": "default",
      "fallback_models": [
        "opencode/deepseek-v4-flash"
      ]
    },

    // Tâches modérées : même modèle, variante plus équilibrée.
    "unspecified-low": {
      "model": "ollama-cloud/deepseek-v4-flash",
      "variant": "balanced",
      "fallback_models": [
        "opencode/deepseek-v4-flash"
      ]
    },

    // Tâches complexes multi-fichiers : Kimi K2.7-code.
    "unspecified-high": {
      "model": "ollama-cloud/kimi-k2.7-code",
      "variant": "high",
      "fallback_models": [
        "opencode/kimi-k2.6",
        "moonshot.ai/kimi-k2.7-code"
      ]
    },

    // Raisonnement technique premium : GLM 5.3, le plus fort du catalogue Ollama.
    "deep": {
      "model": "ollama-cloud/glm-5.3",
      "variant": "max",
      "thinking": {
        "type": "enabled",
        "budgetTokens": 32000
      },
      "fallback_models": [
        "ollama-cloud/deepseek-v4-pro",
        "ollama-cloud/kimi-k2.7-code",
        {
          "model": "opencode/gemini-3.1-pro",
          "variant": "high"
        }
      ]
    },

    // Frontend / UI / UX / vision : GLM 5.3-flash (multimodal, tarif flash).
    "visual-engineering": {
      "model": "ollama-cloud/glm-5.3-flash",
      "fallback_models": [
        "ollama-cloud/minimax-m3",
        "opencode/gemini-3.5-flash-lite",
        "ollama-cloud/deepseek-v4-pro",
        {
          "model": "opencode/gemini-3.1-pro",
          "variant": "high"
        }
      ]
    },

    // Raisonnement maximal : Kimi K2.7-code en variante max avec thinking.
    "ultrabrain": {
      "model": "ollama-cloud/kimi-k2.7-code",
      "variant": "max",
      "thinking": {
        "type": "enabled",
        "budgetTokens": 32000
      },
      "fallback_models": [
        "opencode/kimi-k2.6",
        "moonshot.ai/kimi-k2.7-code"
      ]
    },

    // Documentation : seule catégorie qui démarre sur Zen, car le modèle gratuit
    // suffit et préserve le quota Ollama pour le code.
    "writing": {
      "model": "ollama-cloud/deepseek-v4-flash",
      "fallback_models": [
        "opencode/deepseek-v4-flash",
        "ollama-cloud/deepseek-v4-flash"
      ]
    },

    // Infrastructure : GLM 5.2, grand contexte et température basse pour des
    // réponses très déterministes (Terraform, K8s, Ansible).
    "infrastructure": {
      "model": "ollama-cloud/glm-5.2",
      "temperature": 0.15,
      "fallback_models": [
        "ollama-cloud/kimi-k2.7-code"
      ]
    },

    // Planification : GLM 5.2 en variante max avec thinking. Moins cher que
    // DeepSeek V4 Pro tout en gardant un long contexte.
    "planning": {
      "model": "ollama-cloud/glm-5.2",
      "variant": "max",
      "thinking": {
        "type": "enabled",
        "budgetTokens": 32000
      },
      "fallback_models": [
        "ollama-cloud/kimi-k2.7-code"
      ]
    },

    // Orchestrateur (Sisyphus) : Kimi K2.7-code. La question ouverte est de
    // savoir si DeepSeek V4 Flash suffit pour déléguer correctement, vu que
    // Sisyphus reçoit 100 % des messages.
    "orchestrator": {
      "model": "ollama-cloud/kimi-k2.7-code",
      "variant": "high",
      "fallback_models": [
        "opencode/deepseek-v4-flash",
        "ollama-cloud/deepseek-v4-flash"
      ]
    }
  },

  //
  // RUNTIME FALLBACK
  //
  // Oh My OpenAgent a un mécanisme de fallback, mais il est désactivé par défaut
  // et sa liste retry_on_errors par défaut est [429, 500, 502, 503, 504].
  // Ollama Cloud Pro renvoie une erreur 402 avec le message
  // "extra usage auto reload monthly max reached..." quand le quota de session
  // est épuisé. Ce message ne correspond pas au motif "Payment Required", donc
  // sans l’ajout explicite de 404, le fallback ne se déclenchait pas.
  //
  // Cette section active le fallback et ajoute 402 à la liste, de sorte que
  // les fallback_models définis par catégorie soient réellement utilisés.
  //
  "runtime_fallback": {
    "enabled": true,
    "retry_on_errors": [402, 429, 500, 502, 503, 504],
    "max_fallback_attempts": 3,
    "cooldown_seconds": 60,
    "timeout_seconds": 30,
    "notify_on_fallback": true,
    // On ne revient pas automatiquement au modèle principal épuisé.
    "restore_primary_after_cooldown": false
  },

  //
  // CONCURRENCY
  //
  // Ollama Cloud Pro permet 3 modèles simultanés ; OpenCode Zen tolère 5.
  //
  "providerConcurrency": {
    "ollama-cloud": 3,
    "opencode": 5
  }
}

Ressources

• Ollama Cloud Pro pricing : https://ollama.com/pricing#individuals
• OpenCode Zen pricing : https://opencode.ai/docs/zen
• OpenCode Zen model list : https://opencode.ai/zen/v1/models
• Ollama Cloud models : https://ollama.com/search?c=cloud
• Oh My OpenAgent site : https://omo.dev
• Oh My OpenAgent repo : https://github.com/code-yeongyu/oh-my-openagent

---

Note de l’auteur : Cet article décrit la configuration en production au 30 août 2026. Il est réécrit à chaque changement de routage et évite délibérément les comparaisons historiques pour que le lecteur ne voie que l’état actuel.