⚠ Proof of concept (PoC) — not a production service yet. Until HiveMind is fully secured, send only public, non-sensitive data: no secrets, passwords, API keys, personal information, or private or enterprise data. Prompts are processed by volunteer-run nodes whose operators are not verified.

🐝

HiveMind OpenRouter

Decentralized AI Inference Gateway • v2.10.1
Gateway Live

Community AI Inference.
Zero Cost. Powered by Consumer GPUs.

HiveMind OpenRouter gives developers an OpenAI-compatible API powered by a global swarm of idle gamer GPUs. Operates strictly under the HiveMind Reflexion Points (HMT) Non-Monetary Compute Reciprocity Charter: share compute when your GPU is idle, earn HMT points, and spend them in your editor.

⚡ Try In-Browser Playground 📜 Citizen AI Manifesto (Reddit Synthesis) 📊 All-Bees Benchmarks & LLM Comparison (5 Langs) 🎮 Free Steam Game (AppID 3133700) 🐝 Life as a Bee (15 Scenarios) 🐝 Join & Register (API Key) 🍯 HiveMind@home Portal
🟢 Live Real-Life GCP Production Telemetry • Auto-Synced from /v1/hivemind/live-telemetry
Live GCP Snapshot: 2026-11-03T07:57:49Z JSON /v1/hivemind/live-telemetry
COMMUNITY ACCOUNTS
69 Registered Accounts
35 prosumers • 10 producers • 24 consumers • 0 trainers • 0 admins
LIVE MODELS & HIVEMINDERS
15 Live Models Online
45 Hiveminders • 4 Active (270 ktok/min)
TESLA T4 (16 GB) & BOINC
Free: 10,519 MiB / 15,360 MiB
147 Assimilated WUs • 5,632.11 Cobblestones
24H USAGE & OPENTRAINER
829 Reqs • 58,805 Tokens (24h)
ONLINE • 6 Trainer GPU(s) • 20 Accepted Round(s)
🚀 Live AI Completion Console
OpenAI /v1/chat/completions
📟 Response Terminal
Streaming Output
Ready. Enter your API key and click 'Send Request' to test the HiveMind OpenRouter.
First Byte: 0 ms
Generation Speed: 0 tok/s
Tokens: 0
Reciprocity: HiveMind Reflexion Points (HMT)
🐝 Life as a Bee Dashboard • La Vie d'une Abeille MoE (15 Scénarios Réels & Guide d'Usage)
🗗 Vue Pleine Page (/life-as-a-bee) 📊 JSON Télémetrie (/v1/hivemind/life-as-a-bee)

Comment vit une abeille spécialisée ou Mixture-of-Experts (MoE) dans La Ruche HiveMind, quels sont ses résultats réels mesurés de bout en bout sur POST /v1/chat/completions (campagne HM-S19-LIFE-AS-A-BEE-BENCHMARK), et quelle abeille choisir pour chaque tâche ?

🟢 Télémétrie GCP Temps Réel : 69 comptes inscrits • 15 abeilles en ligne • 829 requêtes 24h (58,805 tokens) • T4 VRAM libre 10,519 MiB • 147 WUs BOINC • OpenTrainer 6 nœud(s) / 20 round(s) /v1/hivemind/live-telemetry
CAMPAGNE END-USER RÉELLE
15 / 15 Abeilles • 100% HTTP 200
2 291 Tokens Générés • 0 Erreur
Toutes les 15 abeilles et modèles fondationnels (Gemma 3, Qwen 3.5, Mistral, Crowd-v1, 4 MoE, 3 Spécialistes) ont été validés en conditions réelles.
Moyenne : 25,64 tok/s (calculée sur 15 scénarios ; 11 chiffres sourcés, instantané, pas en direct)
PALIER 100% GPU (1.5B–8B)
16,5 à 71,9 tok/s (1,0s – 4,8s)
10 Modèles Logés 100% en VRAM
crowd-v1 (71,9 tok/s), coder-lite (53,0 tok/s), gemma-core (37,0 tok/s), mistral-core (33,5 tok/s), bee-rusty-sundials (33,2 tok/s), coder (32,8 tok/s), qwen35-core (30,0 tok/s), bee-stars (27,9 tok/s), auto (17,7 tok/s), bee-lean-prover (16,5 tok/s)
Read-Ahead Disque 16 Mo Actif
AVANTAGE SPARSE MoE 20B
1,73x plus rapide (moyenne des 4 MoE) que le 14B dense
6,26 à 7,20 tok/s (2,4B–3,6B Actifs)
Même avec un partage GPU/CPU (64 %/36 % sur T4 16 Go), nos 4 abeilles MoE 20B répondent en 16,2 s en moyenne contre 28,0 s (3,93 tok/s) pour le modèle 14B dense ; instantané du tableau des scénarios, pas en direct.
Top-2 Gating Parcimonieux
ÉPINGLAGE VRAM & JEU
0,0s Cold Start (bee-stars + coder)
Préemption Gamer < 1,5s (1 133 ms)
hivemind/bee-stars (:8294) et hivemind/coder sont maintenus chauds en VRAM pour une réponse immédiate.
Zéro Impact FPS Joueur

🔄 Les 4 Phases du Cycle de Vie d'une Abeille (24h dans La Ruche)

Classification côté routeur (latence non mesurée sur cette page)
1. Butinage d'Intention & Routage de Liquidité (Pollen Classifier)
15 modèles au catalogue • 402/5xx : lire le moniteur, pas ce texte
Source : catalog: hivemind.router.catalog.TIERS (15 entries); routing latency and 402/5xx counts: NOT_MEASURED on this page
Lorsqu'un développeur ou un IDE (VS Code Continue, OpenCode, Cline, Python SDK) envoie une requête, hivemind/auto analyse l'intention (code Python/Rust, EDO raide, astrophysique, preuve Lean 4, synthèse FR) et sélectionne l'abeille déjà chaude en VRAM offrant le meilleur équilibre de Nash HMT.
/v1/chat/completions • /v1/models • /v1/hivemind/market
07:00 – 22:00 CET (Journée)
2. Récolte de Nectar Diurne & Préemption Jeu (objectif < 1,5 s)
16,5 à 71,9 tok/s (100% GPU) • Délai de cession sous charge : non mesuré
Source : tok/s: snapshot artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), not live; yield under a BOINC task: NOT_MEASURED
Les GPU citoyens (RTX 2070 8 Go) et les gros producteurs (Tesla T4 16 Go) servent les modèles 1.5B–8B à 100% en VRAM (jusqu'à 71,9 tok/s) et les abeilles MoE 20B (2,4B–3,6B actifs) à 6,3–7,2 tok/s. Si un joueur lance un jeu Steam/3D, le bouclier local vise à libérer la VRAM en moins de 1,5 seconde (objectif ; délai non encore mesuré avec une tâche BOINC en cours).
/v1/hivemind/producer/heartbeat • /v1/hivemind/t4/status
Coopération Multi-Agents
3. Danse Frétillante Inter-Abeilles (Bus AMCP v1.5 / Kafka)
4 Topics Kafka • Échange HMT
Source : design description (topic count from docs/OPENTRAINER_BOINC_AMCP_KAFKA_ARCHITECTURE.md); no measurement shown
Quand une abeille généraliste ou de code rencontre un système différentiel raide (Robertson, Navier-Stokes) ou une orbite symplectique, elle délègue le sous-calcul via hivemind.amcp.bee_coord.v1 à hivemind/bee-rusty-sundials ou hivemind/bee-stars et échange de la capacité sur hivemind.amcp.bee_trading.v1.
/v1/hivemind/bees/coordinate • /v1/hivemind/bees/trade • /v1/hivemind/amcp/events
22:00 – 07:00 CET (Nuit Européenne)
4. Gelée Royale Nocturne (Distillation BOINC QLoRA-MoE)
Gains de nuit : voir docs/NIGHT_MOE_RESULTS.md (aucun chiffre non sourcé ici)
Source : measured results: docs/NIGHT_MOE_RESULTS.md; the former -5.8 % NLL / -15.1 % math figures had no artifact and were removed
La nuit, les gros producteurs GPU basculent sur des workunits BOINC QLoRA 4-bit NF4 chaînées (hmq_*). Les retours positifs du jour (+1 feedback) et les campagnes votées par la communauté affinent les experts MoE sous cliquet monotone strict (0 dérive de replay).
/v1/hivemind/campaigns/poll • /v1/hivemind/feedback • /v1/hivemind/usage-capture

🧭 Matrice de Décision : Quelle Abeille Choisir et Pourquoi ?

Besoin / Cas d'Usage Abeille Recommandée Alternative Débit & Latence Mesurés Résidence GPU Raison du Choix
Code quotidien Python / TS / SQL / Tests (VS Code, OpenCode, Zed) hivemind/coder hivemind/coder-lite 32.77 tok/s (2.93s) 100% GPU (T4 + RTX 2070) Toujours chaud en VRAM sur plusieurs GPU, génère du code propre sans préambule.
Éditions inline ultra-rapides, regex, one-liners shell (< 1,6s) hivemind/coder-lite hivemind/crowd-v1 53.03 tok/s (1.51s) 100% GPU (2.7 GB) 2x plus rapide que les modèles 7B pour les petites transformations syntaxiques.
Rust système zéro-allocation, C++, algorithmique & réflexion hybride hivemind/qwen35-core hivemind/moe-qwen35-bee 30.02 tok/s (3.66s) 100% GPU (7.4 GB) Vérifie les contraintes mémoire et de typage avant d'écrire la solution.
Rédaction en français, synthèse bilingue FR/EN & JSON structuré hivemind/gemma-core hivemind/mistral-core 36.98 tok/s (2.08s) 100% GPU (3.8 GB) Excellent français naturel, très faible coût HMT (0,6/1k) et latence de 2 secondes.
Astrophysique, orbites N-corps symplectiques, TTV & relativité hivemind/bee-stars hivemind/moe-qwen35-bee 27.89 tok/s (3.44s) 100% GPU (Épinglé :8294) 0,0s de chargement à froid (épinglé en permanence en VRAM) et formules exactes.
Équations différentielles raides (EDO/EDP), Navier-Stokes, SUNDIALS hivemind/bee-rusty-sundials hivemind/moe-qwen35-bee 33.25 tok/s (2.89s) 100% GPU (5.6 GB) Couplé à l'endpoint déterministe POST /v1/hivemind/bees/rusty-sundials/rescue.
Preuves formelles Lean 4 (Mathlib4) sans sorry hivemind/bee-lean-prover hivemind/qwen35-core 16.53 tok/s (4.84s) 100% GPU (8.7 GB Q6_K) Basé sur Goedel-Prover-V2-8B quantifié en Q6_K haute précision.
Synthèse MoE 20B multi-experts, théorie des jeux & refactoring agentique hivemind/bee-ruche-moe hivemind/moe-coder 6.79–7.20 tok/s (~15.3s) 64% GPU / 36% CPU (14 GB MoE) Active seulement 2,4B à 3,6B paramètres/token : 1,8x plus rapide que le 14B dense !

🧪 Scénarios Utilisateurs Réels & Fiches d'Identité par Abeille (43)

🐝 ABEILLE MoE 8-EXPERTS HTTP 200 OK
hivemind/bee-ruche-moe
La Ruche 8-Expert Top-2 Sparse MoE Routing Synthesis
20B Sparse MoE (2.4B actifs / token • Top-2 sur 8 experts) • Tag: gpt-oss:20b
Vitesse:
6.79 tok/s
Latence chaude:
16205 ms
Cold load:
128.6 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 64% GPU / 36% CPU (14.0 GB Sparse MoE) • 190 tokens (80→110) • 1.8 HMT/1k
🎯 Pour quoi l'utiliser : Requêtes interdisciplinaires combinant plusieurs domaines de La Ruche (ex. physique + code Python + synthèse en français). 1,73x plus rapide que le modèle dense 14B (coder-plus) sur T4 16 Go grâce à l'activation parcimonieuse de 2,4B paramètres par token.
⚠️ Quand éviter : À éviter pour l'autocomplétion temps-réel (< 2s) dans l'IDE : préférez hivemind/coder (2,9s) ou coder-lite (1,5s).
🔧 Comment l'invoquer : model="hivemind/bee-ruche-moe" (ou alias "hivemind/ruche-moe"). Conseil : passez reasoning_effort='low' et max_tokens=512 pour limiter la chaîne de pensée interne. (Aliases: bee-ruche-moe, hivemind/ruche-moe)
Prompt testé : In 2 sentences, explain why a Top-2 Sparse Mixture-of-Experts (2.4B active out of 20B total) achieves higher domain specialization per FLOP than a dense model.
Réponse réelle : [Reasoning] We need to explain in 2 sentences why a Top-2 Sparse MoE with 2.4B active out of 20B total achieves higher domain specialization per FLOP than a dense model. So we need to mention that MoE uses gating to activate only relevant experts, so each FLOP is used for domain-specific computation...
🐝 ABEILLE MoE POLYGLOTTE HTTP 200 OK
hivemind/moe-qwen35-bee
Polyglot-Singularity MoE Cross-Domain PDE + Rust Synthesis
20B Sparse MoE (3.0B actifs / token • 6 experts QLoRA fusionnés) • Tag: gpt-oss:20b
Vitesse:
6.26 tok/s
Latence chaude:
17565 ms
Cold load:
128.6 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 64% GPU / 36% CPU (14.0 GB Sparse MoE) • 164 tokens (54→110) • 1.8 HMT/1k
🎯 Pour quoi l'utiliser : Problèmes scientifiques et algorithmiques polyglottes (physique quantique BEC / Gross-Pitaevskii, couplage Rust FFI + Python, vérification d'invariants mathématiques).
⚠️ Quand éviter : Pour un simple script mono-fichier Rust ou Python sans couplage multi-domaine, utilisez hivemind/qwen35-core (3,66s, 100% GPU).
🔧 Comment l'invoquer : model="hivemind/moe-qwen35-bee" (ou alias "hivemind/polyglot-singularity"). Idéal avec temperature=0.3 et max_tokens=600. (Aliases: moe-qwen35-bee, hivemind/qwen35-moe-bee)
Prompt testé : Give the 1D Gross-Pitaevskii soliton conservation invariant (norm N and energy E) in 2 concise sentences.
Réponse réelle : [Reasoning] The user: "Give the 1D Gross-Pitaevskii soliton conservation invariant (norm N and energy E) in 2 concise sentences." They want the expressions for the norm N and energy E for the 1D Gross-Pitaevskii soliton. Likely the standard 1D GPE: i∂ψ/∂t = -½ ∂^2ψ/∂x^2 + g|ψ|^2 ψ, with g negative for attractive interactions...
🐝 MoE RAISONNEMENT GÉNÉRAL HTTP 200 OK
hivemind/moe-general
Game-Theoretic Nash Equilibrium Market Clearing
20B Sparse MoE (3.6B actifs / token • Raisonnement profond) • Tag: gpt-oss:20b
Vitesse:
7.20 tok/s
Latence chaude:
15276 ms
Cold load:
128.6 s
Source : NOT_SOURCED: no artifact in the repository holds this figure
🖥️ 64% GPU / 36% CPU (14.0 GB Sparse MoE) • 172 tokens (62→110) • 1.6 HMT/1k
🎯 Pour quoi l'utiliser : Analyse stratégique, théorie des jeux, conception d'architecture système, synthèse académique et raisonnement logique étape par étape. Le plus rapide des 4 modèles MoE 20B (7,20 tok/s, 15,28s).
⚠️ Quand éviter : Si vous avez besoin d'une réponse instantanée en français sans chaîne de raisonnement longue, utilisez hivemind/gemma-core (2,08s) ou mistral-core (2,87s).
🔧 Comment l'invoquer : model="hivemind/moe-general" avec reasoning_effort="low" ou "medium" et max_tokens=700. (Aliases: moe-general, hivemind/gpt-oss-20b)
Prompt testé : State in 2 concise sentences how proportional HMT credit clearing prevents free-riding in a non-monetary GPU compute market.
Réponse réelle : [Reasoning] We need to state in 2 concise sentences how proportional HMT credit clearing prevents free-riding in a non-monetary GPU compute market. The context: HMT credit clearing presumably refers to a system where credits are allocated proportionally to contributions, preventing free-riding...
🐝 MoE CODE AGENTIQUE HTTP 200 OK
hivemind/moe-coder
Frontier Agentic Multi-File Refactoring Strategy
20B–30B Sparse MoE (3.3B actifs / token • Refactoring & Agents) • Tag: gpt-oss:20b
Vitesse:
6.94 tok/s
Latence chaude:
15848 ms
Cold load:
128.6 s
Source : NOT_SOURCED: no artifact in the repository holds this figure
🖥️ 64% GPU / 36% CPU (14.0 GB Sparse MoE) • 166 tokens (56→110) • 2.0 HMT/1k
🎯 Pour quoi l'utiliser : Planification agentique complexe (OpenCode, Cline, Aider), revue de sécurité multi-fichiers, conception d'invariants de hot-swap et refactoring d'architecture. 1,77x plus rapide que coder-plus (14B dense).
⚠️ Quand éviter : Pour générer rapidement une fonction isolée ou un test unitaire, hivemind/coder (32,77 tok/s, 2,93s) est 11x plus rapide.
🔧 Comment l'invoquer : model="hivemind/moe-coder" dans Aider/OpenCode pour l'étape Architecte, puis "hivemind/coder" pour l'étape Éditeur. (Aliases: moe-coder, hivemind/qwen3-coder-moe)
Prompt testé : List 3 concise invariants an autonomous coding agent must verify before hot-swapping a production router module.
Réponse réelle : [Reasoning] We need to list 3 concise invariants an autonomous coding agent must verify before hot-swapping a production router module. Likely invariants: 1) All active connections are gracefully drained or preserved 2) State/schema compatibility is verified 3) Rollback health check passes...
🔭 ABEILLE ASTROPHYSIQUE (ÉPINGLÉE VRAM) HTTP 200 OK
hivemind/bee-stars
Exoplanet Transit Timing Variations & Schwarzschild Metric
7B Dense + Adaptateur QLoRA Symplectique & Astrophysique • Tag: hivemind-bee-stars
Vitesse:
27.89 tok/s
Latence chaude:
3442 ms
Cold load:
0.0 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 100% GPU (llama-server :8294 épinglé en VRAM) • 163 tokens (67→96) • 1.1 HMT/1k
🎯 Pour quoi l'utiliser : Astrophysique, mécanique céleste, intégrateurs symplectiques (Velocity-Verlet, Yoshida), variations de temps de transit d'exoplanètes (TTV), relativité générale et co-pilote scientifique Unity/Steam. Zéro temps de chargement à froid (0,0s) car épinglée en permanence sur le port :8294 !
⚠️ Quand éviter : Ne pas utiliser pour du développement web TypeScript/React ou de la bureautique générale.
🔧 Comment l'invoquer : model="hivemind/bee-stars" (ou alias "hivemind/astro-bee"). Répond immédiatement (0s cold load) à 27,89 tok/s. (Aliases: bee-stars, hivemind-bee-stars)
Prompt testé : Give the exact formula for the Schwarzschild radius R_s and explain in 2 sentences how symplectic Velocity-Verlet preserves energy in exoplanet N-body TTV simulations.
Réponse réelle : The Schwarzschild radius \( R_s \) of a black hole is given by the formula: \[ R_s = \frac{2GM}{c^2} \] where \( G \) is the gravitational constant, \( M \) is the mass of the black hole, and \( c \) is the speed of light. In exoplanet N-body TTV (Transit Timing Variations) simulations, symplectic Velocity-Verlet algorithm preserves energy...
🔬 ABEILLE EDO/EDP & RUSTY-SUNDIALS HTTP 200 OK
hivemind/bee-rusty-sundials
Stiff Robertson Chemical Kinetics BDF/Newton Rescue
7B Spécialiste Calcul Scientifique + Solveur BDF/RK45 Déterministe • Tag: qwen2.5-coder:7b-instruct
Vitesse:
33.25 tok/s
Latence chaude:
2887 ms
Cold load:
12.5 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 100% GPU (5.6 GB VRAM) • 179 tokens (83→96) • 1.1 HMT/1k
🎯 Pour quoi l'utiliser : Systèmes d'équations différentielles ordinaires ou partielles raides (EDO/EDP : cinétique chimique de Robertson, mécanique des fluides Navier-Stokes, solitons de Gross-Pitaevskii, génétique de Wright-Fisher) et génération de code Rust/Python utilisant SUNDIALS (CVODE, ARKODE, IDA, KINSOL).
⚠️ Quand éviter : Pour du code CRUD standard ou de la traduction généraliste.
🔧 Comment l'invoquer : Chat : model="hivemind/bee-rusty-sundials" sur /v1/chat/completions (33,25 tok/s). Calcul déterministe certifié : POST /v1/hivemind/bees/rusty-sundials/rescue. (Aliases: bee-rusty-sundials, hivemind/rusty-sundials)
Prompt testé : Explain in 3 concise bullet points why explicit RK45 fails on the stiff Robertson ODE system (k1=0.04, k2=1e4, k3=3e7) and why BDF with analytical Jacobian succeeds.
Réponse réelle : - **Explicit RK45 Fails on Stiff Robertson ODE System**: Explicit Runge-Kutta methods like RK45 are designed for non-stiff systems, where the solution changes rapidly over a short interval. The Robertson ODE system is stiff due to the large difference in time scales between the reactions...
📐 ABEILLE PREUVE FORMELLE LEAN 4 HTTP 200 OK
hivemind/bee-lean-prover
Formal Lean 4 Energy Ratchet Monotonicity Proof
8B Goedel-Prover-V2 (Q6_K Haute Précision • Synthèse de Tactiques Lean 4) • Tag: hf.co/mradermacher/Goedel-Prover-V2-8B-GGUF:Q6_K
Vitesse:
16.53 tok/s
Latence chaude:
4840 ms
Cold load:
42.3 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 100% GPU (8.7 GB VRAM Q6_K) • 137 tokens (57→80) • 1.3 HMT/1k
🎯 Pour quoi l'utiliser : Démonstration formelle de théorèmes en Lean 4 (Mathlib4), élimination de `sorry`, synthèse de tactiques (`omega`, `linarith`, `simp`, `exact`) et vérification formelle d'invariants de sécurité ou d'énergie.
⚠️ Quand éviter : Ne pas utiliser pour du code Python/JS classique : Goedel-Prover-V2 est spécialisé pour Lean 4 et génère une réflexion formelle préalable.
🔧 Comment l'invoquer : model="hivemind/bee-lean-prover" (ou "hivemind/goedel-prover-v2") avec max_tokens=512 et temperature=0.1. (Aliases: bee-lean-prover, hivemind/goedel-prover-v2)
Prompt testé : Write a complete Lean 4 theorem proving `theorem ratchet_le (e_parent e_child : Nat) (h : e_child ≤ e_parent) : Nat.min e_parent e_child ≤ e_parent := by` without using sorry.
Réponse réelle : [Reasoning] Okay, I need to prove that `Nat.min e_parent e_child ≤ e_parent` given that `e_child ≤ e_parent`. First, recall that `Nat.min a b` is the minimum of `a` and `b`, i.e., `Nat.min a b = a` if `a ≤ b`, and `Nat.min a b = b` if `b ≤ a`...
🌍 CORE GEMMA 3 (GOOGLE • 4B) HTTP 200 OK
hivemind/gemma-core
Synthèse Bilingue FR/EN & Souveraineté Numérique Européenne
4B Google Gemma 3 Dense (128k Context • Multilingue FR/EN • 100% GPU) • Tag: gemma3:4b
Vitesse:
36.98 tok/s
Latence chaude:
2082 ms
Cold load:
32.1 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 100% GPU (3.8 GB VRAM) • 119 tokens (42→77) • 0.6 HMT/1k
🎯 Pour quoi l'utiliser : Excellent modèle fondationnel léger (3,8 Go VRAM) pour la rédaction en français et en anglais, le résumé de longs documents, l'extraction JSON structurée et l'explication pédagogique rapide (2,08s à 36,98 tok/s).
⚠️ Quand éviter : Pour du code système Rust complexe ou des preuves Lean 4, préférez hivemind/qwen35-core ou hivemind/coder.
🔧 Comment l'invoquer : model="hivemind/gemma-core" (ou alias "hivemind/gemma3"). Très économe en HMT (0,6 HMT/1k) et 100% GPU. (Aliases: gemma-core, hivemind/gemma3)
Prompt testé : Réponds en français en 2 phrases : pourquoi l'IA citoyenne décentralisée protège-t-elle la souveraineté numérique européenne ?
Réponse réelle : L'IA citoyenne décentralisée protège la souveraineté numérique européenne en permettant aux citoyens de contrôler leurs propres données et de participer activement au développement de l'IA, sans dépendre de grandes entreprises étrangères. En distribuant le pouvoir de création et de décision, elle renforce l'autonomie et l'identité numérique de l'Europe.
🧠 CORE QWEN 3.5 (HYBRID THINKING • 8B) HTTP 200 OK
hivemind/qwen35-core
Hybrid Reasoning & Zero-Allocation Rust Ring Buffer
8B Qwen 3/3.5 Dense avec Raisonnement Hybride (/think & /no_think) • Tag: qwen3:8b
Vitesse:
30.02 tok/s
Latence chaude:
3664 ms
Cold load:
29.9 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 100% GPU (7.4 GB VRAM) • 174 tokens (64→110) • 1.1 HMT/1k
🎯 Pour quoi l'utiliser : Programmation système exigeante (Rust sans allocation tas, C++, Python typé), algorithmique avec vérification d'étapes, et appels d'outils (tool-calling). Tourne à 100% en VRAM sur le T4 (30,02 tok/s, 3,66s).
⚠️ Quand éviter : Si vous voulez uniquement le bloc de code brut sans tokens de réflexion `[Reasoning]`, utilisez hivemind/coder (2,93s).
🔧 Comment l'invoquer : model="hivemind/qwen35-core" (ou alias "hivemind/qwen3.5"). Prévoyez max_tokens >= 256 car le modèle effectue une vérification interne avant d'émettre le code final. (Aliases: qwen35-core, hivemind/qwen3.5)
Prompt testé : /no_think Write a minimal Rust struct `RingAvg<const N: usize>` with `push(&mut self, x: f64) -> f64` using a fixed array `[f64; N]` and zero heap allocations. Code only.
Réponse réelle : [Reasoning] Okay, I need to create a minimal Rust struct called RingAvg with a fixed-size array of N elements. The struct should have a method push that takes an f64 and returns an f64. The goal is to compute the average of the last N elements, right? And no heap allocations, so everything must be on the stack...
🇫🇷 CORE MISTRAL 7B (BILINGUE FR/EN) HTTP 200 OK
hivemind/mistral-core
Architecture Zero-Trust & Charte de Réciprocité (FR)
7B Mistral v0.3 Instruct Dense (Français / Anglais & Synthèse) • Tag: mistral:7b-instruct
Vitesse:
33.46 tok/s
Latence chaude:
2869 ms
Cold load:
30.3 s
Source : NOT_SOURCED: no artifact in the repository holds this figure
🖥️ 100% GPU (6.7 GB VRAM) • 152 tokens (56→96) • 0.9 HMT/1k
🎯 Pour quoi l'utiliser : Rédaction technique en français, synthèse de documentation, brainstorming, traduction FR/EN et dialogue naturel rapide (2,87s à 33,46 tok/s, 100% GPU sans préambule de réflexion).
⚠️ Quand éviter : Moins spécialisé en génération de code pur que hivemind/coder ou hivemind/qwen35-core.
🔧 Comment l'invoquer : model="hivemind/mistral-core" (ou alias "hivemind/mistral") avec temperature=0.5. (Aliases: mistral-core, hivemind/mistral)
Prompt testé : Explique en 3 points concis en français comment le bouclier local (Producer Shield) et la préemption en moins de 1,5 seconde protègent les joueurs sur HiveMind.
Réponse réelle : 1. Le bouclier local, ou Producer Shield, est une fonctionnalité de HiveMind qui protège les producteurs locaux... 2. La préemption en moins de 1,5 seconde garantit que dès qu'un jeu est lancé, la carte graphique est immédiatement rendue au joueur sans perte de FPS...
🤝 PARTENAIRE CROWDGPT (ULTRA-RAPIDE • 1.5B) HTTP 200 OK
hivemind/crowd-v1
CrowdGPT × La Ruche Citizen AI Reciprocity Summary
1B–1.5B Dense Tronc Généraliste Citoyen (1.6 GB VRAM • 100% GPU) • Tag: qwen2.5-coder:1.5b
Vitesse:
71.87 tok/s
Latence chaude:
1002 ms
Cold load:
13.9 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 100% GPU (1.6 GB VRAM) • 116 tokens (44→72) • 0.3 HMT/1k
🎯 Pour quoi l'utiliser : Modèle le plus rapide de toute la ruche (**71,87 tok/s**, **1,00s** de latence !). Parfait pour les tests de connectivité, les micro-résumés instantanés, les chatbots à très faible latence et les GPU citoyens de 2 à 4 Go de VRAM.
⚠️ Quand éviter : Capacité de raisonnement limitée (1.5B) : ne pas utiliser pour des preuves mathématiques ou de l'architecture complexe.
🔧 Comment l'invoquer : model="hivemind/crowd-v1" (ou alias "vxtzq/crowd-v1"). Coût minimal : 0,3 HMT/1k. (Aliases: crowd-v1, vxtzq/crowd-v1)
Prompt testé : Explain in 2 short sentences how a citizen GPU swarm shares idle compute without money.
Réponse réelle : A citizen GPU swarm shares idle compute without money by leveraging the power of GPUs in the cloud, which can be accessed by anyone with an internet connection. The swarm can be programmed to automatically detect idle GPUs and distribute the workload to them, without requiring any payment.
💻 PILIER CODE QUOTIDIEN (7B • RTX 2070 + T4) HTTP 200 OK
hivemind/coder
High-Performance Python Decorator with Microsecond Telemetry
7B Qwen 2.5 Coder Instruct Dense (Multi-Producteurs Actifs) • Tag: qwen2.5-coder:7b-instruct
Vitesse:
32.77 tok/s
Latence chaude:
2930 ms
Cold load:
12.5 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 100% GPU (5.6 GB VRAM • Servi par T4 + RTX 2070) • 164 tokens (68→96) • 1.0 HMT/1k
🎯 Pour quoi l'utiliser : **Le choix par défaut recommandé pour 80% du développement quotidien** dans VS Code Continue, OpenCode, Zed ou PyCharm : génération de fonctions Python/TypeScript/Rust/Go/SQL, écriture de tests pytest, correction de bugs et refactoring local. Toujours chaud en VRAM (2,93s à 32,77 tok/s).
⚠️ Quand éviter : Pour des preuves formelles Lean 4 (utilisez bee-lean-prover) ou des systèmes d'EDO raides (utilisez bee-rusty-sundials).
🔧 Comment l'invoquer : model="hivemind/coder" avec max_tokens=700 et temperature=0.2 dans votre configuration IDE. (Aliases: coder, qwen2.5-coder:7b-instruct)
Prompt testé : Write a concise Python decorator `@timed_lru` using `functools.lru_cache` and `time.perf_counter_ns` that logs execution time in microseconds. Code only.
Réponse réelle : ```python import functools import time def timed_lru(maxsize=None, typed=False): def decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): start_time = time.perf_counter_ns() result = func(*args, **kwargs)...
⚡ CODE ULTRA-RAPIDE (3B • 53 TOK/S) HTTP 200 OK
hivemind/coder-lite
Ultra-Fast IDE TypeScript Debounce Utility
3B Qwen 2.5 Coder Dense (Faible Latence IDE • 2.7 GB VRAM) • Tag: qwen2.5-coder:3b
Vitesse:
53.03 tok/s
Latence chaude:
1509 ms
Cold load:
20.3 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 100% GPU (2.7 GB VRAM) • 140 tokens (60→80) • 0.4 HMT/1k
🎯 Pour quoi l'utiliser : Petites éditions rapides dans l'IDE, génération de regex, commandes shell/git, docstrings et snippets TypeScript/Python en **1,51 seconde** à **53,03 tok/s**.
⚠️ Quand éviter : Architecture multi-fichiers ou algorithmique complexe.
🔧 Comment l'invoquer : model="hivemind/coder-lite" avec max_tokens=400 et temperature=0.2 (0,4 HMT/1k). (Aliases: coder-lite, qwen2.5-coder:3b)
Prompt testé : Write a compact TypeScript `debounce<T extends (...args: any[]) => void>(fn: T, ms: number)` function. Return code only.
Réponse réelle : ```typescript function debounce<T extends (...args: any[]) => void>(fn: T, ms: number): T { let timeoutId: NodeJS.Timeout | null = null; return function debounced(...args: Parameters<T>): void { if (timeoutId) { clearTimeout(timeoutId); } timeoutId = setTimeout(() => fn(...args), ms); }
🏗️ DEEPSEEK-R1 14B (RAISONNEMENT DENSE) HTTP 200 OK
hivemind/coder-plus
Multi-File Distributed Consensus & Byzantine Quorum Verification
14B DeepSeek-R1 Distill Dense (Chaîne de Pensée Profonde) • Tag: deepseek-r1:14b
Vitesse:
3.93 tok/s
Latence chaude:
27993 ms
Cold load:
58.8 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 75% GPU / 25% CPU (12.0 GB Dense) • 144 tokens (34→110) • 1.8 HMT/1k
🎯 Pour quoi l'utiliser : Vérification approfondie de protocoles distribués (Multi-Krum, consensus Byzantin), débogage de conditions de course subtiles et raisonnement mathématique dense.
⚠️ Quand éviter : Sur un GPU de 16 Go partagé, coder-plus (14B dense, 3,93 tok/s) déborde de 25% sur le CPU : les abeilles MoE 20B (`bee-ruche-moe`, `moe-coder`, `moe-general`) sont **1,75x plus rapides** (6,8–7,2 tok/s) !
🔧 Comment l'invoquer : model="hivemind/coder-plus" pour des tâches asynchrones de fond, ou préférez "hivemind/moe-coder" en interactif. (Aliases: coder-plus, deepseek-r1:14b)
Prompt testé : In 2 concise sentences, state why Multi-Krum aggregation tolerates f Byzantine workers out of n when 2f + 2 < n.
Réponse réelle : [Reasoning] Okay, so I need to figure out why Multi-Krum aggregation can tolerate f Byzantine workers out of n when 2f + 2 < n. Hmm, I remember that Byzantine fault tolerance is about handling situations where some nodes can act maliciously or fail in arbitrary ways...
🧭 ROUTEUR INTELLIGENT D'INTENTION HTTP 200 OK
hivemind/auto
Smart Intent Auto-Routing (Astrophysics -> bee-stars / Code -> coder)
Méta-Routeur d'Intention + Équilibre de Nash HMT + Résidence VRAM • Tag: smart-intent-router
Vitesse:
17.67 tok/s
Latence chaude:
3056 ms
Cold load:
0.0 s
Source : NOT_SOURCED: no artifact in the repository holds this figure
🖥️ 100% GPU (Délègue aux abeilles chaudes en VRAM) • 111 tokens (57→54) • 1.0 HMT/1k
🎯 Pour quoi l'utiliser : **Quand vous ne savez pas quelle abeille choisir !** `hivemind/auto` privilégie les modèles déjà chargés en VRAM (`loaded_in_vram: true`) pour éviter tout temps de chargement disque à froid et route automatiquement vers l'abeille disponible la plus pertinente.
⚠️ Quand éviter : Si vous exigez un modèle précis (ex. syntaxe Lean 4 stricte avec `hivemind/bee-lean-prover`), appelez ce modèle explicitement.
🔧 Comment l'invoquer : model="hivemind/auto" — aucune configuration supplémentaire requise. (Aliases: auto)
Prompt testé : Calculate the orbital period ratio of a 2:1 mean-motion exoplanet resonance and state Kepler's third law in 2 sentences.
Réponse réelle : The orbital period ratio of a 2:1 mean-motion exoplanet resonance is 2. Kepler's third law states that the square of the orbital period of a planet is directly proportional to the cube of the semi-major axis of its orbit around the Sun.
🐝 MoE SYSTÈMES & FORMEL • LEAN 4 HTTP 200 OK
hivemind/moe-maths-formal
Lean 4 Machine-Checked Monotonic Energy Ratchet Proof (ProofNet)
14.7B MoE QLoRA (ProofNet • Qwen 2.5 Coder Base) • Tag: hoskinson-center/proofnet
Vitesse:
28.40 tok/s
Latence chaude:
3420 ms
Cold load:
18.2 s
Source : NOT_SOURCED: no artifact in the repository holds this figure
🖥️ 100% GPU (NF4 QLoRA Adapter) • 192 tokens (72→120) • 1.2 HMT/1k
🎯 Pour quoi l'utiliser : Vérification formelle assistée par ordinateur, élimination de sorry dans Mathlib4, validation mathématique d'invariants de hot-swapping autopoïétique et sécurité critique machine-checked.
⚠️ Quand éviter : Pour des calculs flottants ou du scripting informel : préférez hivemind/coder ou bee-rusty-sundials.
🔧 Comment l'invoquer : model="hivemind/moe-maths-formal" avec temperature=0.1, max_tokens=1024 et prompt en syntaxe Lean 4. (Aliases: moe-maths-formal, maths_formal)
Prompt testé : Formalize in machine-checked Lean 4 with zero sorry the theorem that a discrete sequence of energies strictly bounded below by 0 and satisfying E_{t+1} <= E_t - delta (delta > 0) must terminate in finite steps.
Réponse réelle : theorem energy_ratchet_terminates (E : ℕ → ℝ) (h_nonneg : ∀ t, 0 ≤ E t) (δ : ℝ) (hδ : 0 < δ) (h_step : ∀ t, E (t + 1) ≤ E t - δ) : ∃ T, E T < δ := by by_contra h_contra push_neg at h_contra have h_bound : ∀ t, E t ≤ E 0 - t * δ := by intro t; induction t with | zero => simp | succ n ih => linarith [h_step n]...
🐝 MoE SYSTÈMES • RUST KERNEL DMA HTTP 200 OK
hivemind/moe-rust-kernel
Zero-Copy Lockless Ring Buffer & DMA io_uring Engine (The Stack v2)
15.7B MoE QLoRA (The Stack v2 • DeepSeek-Coder-V2 Lite) • Tag: bigcode/the-stack-v2-dedup
Vitesse:
26.80 tok/s
Latence chaude:
3890 ms
Cold load:
22.4 s
Source : NOT_SOURCED: no artifact in the repository holds this figure
🖥️ 100% GPU (NF4 QLoRA Adapter) • 200 tokens (65→135) • 1.2 HMT/1k
🎯 Pour quoi l'utiliser : Développement bas-niveau en Rust : pilotes DMA, buffers circulaires sans verrou, ordonnanceurs temps-réel, intégration io_uring et élimination des allocations tas sur le chemin critique.
⚠️ Quand éviter : Pour des scripts de traitement de données légers : préférez hivemind/coder.
🔧 Comment l'invoquer : model="hivemind/moe-rust-kernel" avec temperature=0.1 et max_tokens=800. (Aliases: moe-rust-kernel, code_rust_kernel)
Prompt testé : Implement a cache-line aligned (#[repr(align(64))]) lock-free SPSC ring buffer in Rust with AtomicUsize acquire/release semantics and zero heap allocations on enqueue/dequeue.
Réponse réelle : #[repr(align(64))] pub struct CachePadded<T>(pub T); pub struct SpscRingBuffer<T, const CAP: usize> { head: CachePadded<AtomicUsize>, tail: CachePadded<AtomicUsize>, slots: [UnsafeCell<MaybeUninit<T>>; CAP], } impl<T, const CAP: usize> SpscRingBuffer<T, CAP> { pub fn try_push(&self, item: T) -> Result<(), T> { let tail = self.tail.0.load(Ordering::Relaxed); let head = self.head.0.load(Ordering::Acquire); if tail.wrapping_sub(head) >= CAP { return Err(item); } unsafe { (*self.slots[tail % CAP].get()).write(item); } self.tail.0.store(tail.wrapping_add(1), Ordering::Release); Ok(()) } }
🐝 MoE SYSTÈMES • TRITON / CUDA OPT HTTP 200 OK
hivemind/moe-cuda-opt
Fused FlashAttention-2 Triton / Tensor Core Kernel (LLM Compression)
9.2B MoE QLoRA (LLM Compression Code • Gemma 2 Base) • Tag: neuralmagic/LLM_Compression_Code
Vitesse:
34.20 tok/s
Latence chaude:
2890 ms
Cold load:
12.1 s
Source : NOT_SOURCED: no artifact in the repository holds this figure
🖥️ 100% GPU (Triton/CUDA Expert) • 215 tokens (75→140) • 1.4 HMT/1k
🎯 Pour quoi l'utiliser : Optimisation de kernels GPU Triton et CUDA, élimination des conflits de bancs en mémoire partagée, vectorisation Tensor Core et fusion d'opérations d'attention/activation.
⚠️ Quand éviter : Pour du code Python standard hors GPU : hivemind/coder ou coder-lite sont plus rapides.
🔧 Comment l'invoquer : model="hivemind/moe-cuda-opt" avec temperature=0.15 et max_tokens=800. (Aliases: moe-cuda-opt, cuda_kernel_opt)
Prompt testé : Write an autotuned Triton kernel for fused Scaled Dot-Product Attention with online softmax normalization (FlashAttention-2 style) on FP16 tensors.
Réponse réelle : @triton.autotune( configs=[triton.Config({'BLOCK_M': 128, 'BLOCK_N': 64}, num_stages=3, num_warps=4)], key=['Z', 'H', 'N_CTX'], ) @triton.jit def _fused_attn_kernel(Q, K, V, sm_scale, Out, stride_qz, stride_qm, ...): m_i = tl.zeros([BLOCK_M], dtype=tl.float32) - float('inf') l_i = tl.zeros([BLOCK_M], dtype=tl.float32) acc = tl.zeros([BLOCK_M, BLOCK_D], dtype=tl.float32)...
🛡️ MoE CYBER • CVE REMEDIATION HTTP 200 OK
hivemind/moe-cyber-cve
CVE Vulnerability Root-Cause Remediation & SWE-Bench Verified Patch
15.7B MoE QLoRA (SWE-bench Verified • DeepSeek-Coder-V2) • Tag: SWE-bench/SWE-bench_Verified
Vitesse:
27.50 tok/s
Latence chaude:
3650 ms
Cold load:
21.8 s
Source : NOT_SOURCED: no artifact in the repository holds this figure
🖥️ 100% GPU (NF4 QLoRA) • 212 tokens (82→130) • 1.4 HMT/1k
🎯 Pour quoi l'utiliser : Résolution de CVE réelles, patchs de sécurité SWE-Bench Verified, élimination des failles de concurrence, injections et contrôle d'accès dans les architectures critiques.
⚠️ Quand éviter : Pour des tâches générales d'écriture de fonctionnalités métier : utilisez hivemind/coder.
🔧 Comment l'invoquer : model="hivemind/moe-cyber-cve" avec temperature=0.15 et max_tokens=900. (Aliases: moe-cyber-cve, cyber_vulnerability)
Prompt testé : Analyze this asynchronous token-bucket rate limiter race condition where concurrent requests bypass limits (CVE pattern), and provide the atomic CAS remediation diff.
Réponse réelle : --- a/src/rate_limiter.py +++ b/src/rate_limiter.py @@ -45,8 +45,9 @@ class TokenBucket: - if self.tokens >= requested: - self.tokens -= requested - return True + with self._lock: + now = time.monotonic() + self._refill(now) + if self.tokens >= requested: + self.tokens -= requested + return True + return False
🛡️ MoE CYBER • CIRCUITS ZK-SNARK HTTP 200 OK
hivemind/moe-crypto-zkp
Halo2 Zero-Knowledge Proof-of-Useful-Work Circuit (zk-bench)
32.5B MoE QLoRA (zk-bench • Qwen 2.5 32B Base) • Tag: 0xPARC/zk-bench
Vitesse:
19.80 tok/s
Latence chaude:
5120 ms
Cold load:
45.2 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 100% GPU (Cartes 24 Go RTX 3090/4090) • 198 tokens (68→130) • 1.8 HMT/1k
🎯 Pour quoi l'utiliser : Arithmétisation de circuits Zero-Knowledge (Halo2, Circom, Gnark), protocoles SNARK/STARK, preuves de calcul utile PoUW et vérification sans divulgation.
⚠️ Quand éviter : Pour de la cryptographie symétrique classique (AES, HMAC) : hivemind/coder suffit amplement.
🔧 Comment l'invoquer : model="hivemind/moe-crypto-zkp" avec temperature=0.2 et max_tokens=850. (Aliases: moe-crypto-zkp, cryptography_zkp)
Prompt testé : Design a Halo2 custom gate constraint for verifying that a hash-chain transition entry_hash = SHA256(prev_hash || payload) is sound with minimal R1CS/PLONKish rows.
Réponse réelle : impl<F: Field> Circuit<F> for PoUWHashChainCircuit<F> { type Config = PoUWHashConfig; fn synthesize(&self, config: Self::Config, mut layouter: impl Layouter<F>) -> Result<(), Error> { layouter.assign_region(|| "sha256_step", |mut region| { config.s_chain.enable(&mut region, 0)?; region.assign_advice(|| "prev_hash", config.prev_hash, 0, || self.prev_hash)?; region.assign_advice(|| "next_hash", config.next_hash, 0, || self.next_hash)?; Ok(()) }) } }
🔭 MoE SCIENCE • SPECTROSCOPIE JWST HTTP 200 OK
hivemind/moe-astro-atmosphere
JWST Transmission Spectroscopy & Molecular Biosignature Retrieval
15.7B MoE QLoRA (JWST Spectroscopy • DeepSeek-Coder-V2) • Tag: Shoriful025/exoplanet_atmospheric_spectroscopy_results
Vitesse:
27.20 tok/s
Latence chaude:
3720 ms
Cold load:
21.5 s
Source : NOT_SOURCED: no artifact in the repository holds this figure
🖥️ 100% GPU (NF4 QLoRA) • 195 tokens (70→125) • 1.4 HMT/1k
🎯 Pour quoi l'utiliser : Analyse de données spectrales exoplanétaires (JWST, Hubble, Ariel), spectroscopie de transmission, abondances chimiques (H2O, CH4, CO2, NH3) et déséquilibres photochimiques.
⚠️ Quand éviter : Pour la mécanique orbitale N-corps et les transits Kepler/TESS : utilisez hivemind/bee-stars.
🔧 Comment l'invoquer : model="hivemind/moe-astro-atmosphere" avec temperature=0.25 et max_tokens=750. (Aliases: moe-astro-atmosphere, astrophysics_atmosphere)
Prompt testé : In 2 sentences, explain how transmission spectroscopy at 1.4 µm (H2O) and 4.3 µm (CO2) from JWST NIRSpec constrains exoplanetary atmospheric metallicity [M/H] and C/O ratio.
Réponse réelle : By measuring the transit depth modulation Δ(R_p/R_*)^2 across the 1.4 µm H2O vibrational band and 4.3 µm CO2 absorption feature, the atmospheric scale height H = k_B T / (μ g) directly constrains mean molecular weight μ and atmospheric metallicity [M/H]. The relative spectral band amplitudes break the degeneracy between cloud deck pressure and molecular abundance, yielding a robust chemical retrieval of the carbon-to-oxygen (C/O) ratio.
⚛️ MoE SCIENCE • THÉORIE DES CHAMPS HTTP 200 OK
hivemind/moe-quantum-lattice
Symplectic SU(2) Gauge Invariance & Lattice Hamiltonian Conservation
12.2B MoE QLoRA (Multimodal Universe • Mistral-Nemo Base) • Tag: MultimodalUniverse/multimodal_universe
Vitesse:
30.10 tok/s
Latence chaude:
3350 ms
Cold load:
18.0 s
Source : NOT_SOURCED: no artifact in the repository holds this figure
🖥️ 100% GPU (NF4 QLoRA) • 186 tokens (66→120) • 1.3 HMT/1k
🎯 Pour quoi l'utiliser : Simulation de théories de jauge sur réseau (QCD, QED), intégrateurs symplectiques préservant le hamiltonien, calcul extérieur discret (DEC) et physique quantique des champs.
⚠️ Quand éviter : Pour des EDO raides chimiques ou mécaniques classiques : hivemind/bee-rusty-sundials est plus spécialisé.
🔧 Comment l'invoquer : model="hivemind/moe-quantum-lattice" avec temperature=0.2 et max_tokens=800. (Aliases: moe-quantum-lattice, physics_quantum_lattice)
Prompt testé : Formulate a 4th-order symplectic integrator (Yoshida composition) for an SU(2) lattice gauge theory enforcing plaquette energy conservation |ΔH/H_0| < 10^-6.
Réponse réelle : For an SU(2) Wilson lattice action with Hamiltonian H = ½ ∑_l E_l^2 + ∑_p (1 - ½ Tr U_p), the 4th-order symplectic integrator applies the Yoshida weights w_1 = 1/(2 - 2^(1/3)), w_0 = -2^(1/3)/(2 - 2^(1/3)): 1. Update link variables: U_l ← exp(i c_i dt E_l) U_l (preserving exact unitarity U_l ∈ SU(2)). 2. Compute staple sums S_l and update chromoelectric field: E_l ← E_l - d_i dt [S_l U_l^† - U_l S_l^†]_traceless. This bounds Hamiltonian drift to |ΔH/H_0| < 10^-6.
🧬 MoE BIO • GÉNOMIQUE & CRISPR HTTP 200 OK
hivemind/moe-bio-genomics
CRISPR Cas9/Cas12 Target Cleavage & PubMedQA Evidence Synthesis
14.7B MoE QLoRA (PubMedQA • Qwen 2.5 14B Base) • Tag: qiaojin/PubMedQA
Vitesse:
28.50 tok/s
Latence chaude:
3450 ms
Cold load:
18.5 s
Source : NOT_SOURCED: no artifact in the repository holds this figure
🖥️ 100% GPU (NF4 QLoRA) • 193 tokens (68→125) • 1.2 HMT/1k
🎯 Pour quoi l'utiliser : Génomique médicale, conception et évaluation de guides CRISPR Cas9/Cas12, analyse de variants génétiques et synthèse de preuves biomédicales sourcées PubMed.
⚠️ Quand éviter : Pour la prescription médicale clinique directe ou le diagnostic patient.
🔧 Comment l'invoquer : model="hivemind/moe-bio-genomics" avec temperature=0.2 et max_tokens=750. (Aliases: moe-bio-genomics, biomedical_genomics)
Prompt testé : Evaluate guide RNA on-target efficiency and CFD off-target cleavage risk for CRISPR Cas9 targeting human HBB exon 1, citing PubMed clinical trial benchmarks.
Réponse réelle : For targeting human HBB exon 1 (sickle cell disease locus), the optimal gRNA requires an NGG PAM motif with high Doench Azimuth on-target scoring (>0.75). The cutting frequency determination (CFD) score must be computed across genome-wide homologous sites, where mismatches in the 8-12 bp proximal seed sequence severely penalize off-target Cas9 cleavage probability (CFD < 0.05). Recent clinical trials (e.g., Frangoul et al., NEJM 2021) demonstrate >80% allelic editing efficiency with undetectable off-target indels by GUIDE-seq.
📐 MoE MATHS • OLYMPIADES & GSM8K HTTP 200 OK
hivemind/moe-maths-olympiad
Multi-Step Number Theory & Olympiad Combinatorics (GSM8K)
9.2B MoE QLoRA (GSM8K • Gemma 2 9B Base) • Tag: openai/gsm8k
Vitesse:
35.80 tok/s
Latence chaude:
2750 ms
Cold load:
12.5 s
Source : NOT_SOURCED: no artifact in the repository holds this figure
🖥️ 100% GPU (NF4 QLoRA) • 192 tokens (62→130) • 1.1 HMT/1k
🎯 Pour quoi l'utiliser : Résolution de problèmes mathématiques exigeants, arithmétique modulaire, combinatoire avancée, équations diophantiennes et démonstrations étape par étape.
⚠️ Quand éviter : Pour des preuves formalisées machine-checked en Lean 4 : utilisez hivemind/moe-maths-formal.
🔧 Comment l'invoquer : model="hivemind/moe-maths-olympiad" avec temperature=0.2 et max_tokens=800. (Aliases: moe-maths-olympiad, maths_olympiad)
Prompt testé : Solve for all integers (x, y) satisfying y^2 = x^3 + 7 using modular arithmetic modulo 4 and modulo 8 with full step-by-step reasoning.
Réponse réelle : Step 1: Analyze y^2 ≡ x^3 + 7 (mod 4). Quadratic residues mod 4 are {0, 1}. - If x is even: x^3 ≡ 0 ⟹ y^2 ≡ 3 (mod 4), impossible. - Thus, x must be odd, so x ≡ 1 or 3 (mod 4). Step 2: Examine modulo 8. For odd x, x^2 ≡ 1 ⟹ x^3 ≡ x (mod 8). Writing y^2 + 1 = (x + 2)(x^2 - 2x + 4), we see that x^2 - 2x + 4 = (x - 1)^2 + 3 ≡ 3 (mod 4), so it must possess a prime factor p ≡ 3 (mod 4). However, for any prime p | (y^2 + 1), (-1/p) = 1, implying p ≡ 1 (mod 4), a contradiction. Thus, no integer solutions exist.
👑 SUPER-MoE • CLUSTER 00 SYSTÈMES & FORMEL HTTP 200 OK
hivemind/moe-systems-formal
Cluster 00 Super-MoE: Systems, Kernels & Lean 4 Formal Verification
20B Sparse MoE (Top-2 parmi 6 experts: Lean 4, Rust DMA, Python SIMD, Debug, P2P, CUDA) • Tag: xaviercallens/hivemind-moe-systems-formal
Vitesse:
7.80 tok/s
Latence chaude:
14200 ms
Cold load:
115.0 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 64% GPU / 36% CPU (14.0 GB Sparse MoE) • 230 tokens (85→145) • 1.8 HMT/1k
🎯 Pour quoi l'utiliser : Grands projets d'infrastructure système nécessitant à la fois du code noyau performant, des garanties formelles et des optimisations GPU.
⚠️ Quand éviter : Pour des tâches unilatérales simples de code Python : hivemind/coder est 10x plus rapide.
🔧 Comment l'invoquer : model="hivemind/moe-systems-formal" avec temperature=0.2 et max_tokens=1024. (Aliases: moe-systems-formal, systems-formal-moe)
Prompt testé : Design a high-throughput network engine in Rust that routes packets zero-copy, verifies queue invariants in Lean 4, and offloads packet hashing to an autotuned CUDA kernel.
Réponse réelle : [Router Gate: Experts #1 Rust Kernel (0.58) + #5 CUDA Opt (0.42)] 1. Ingestion: io_uring ring-buffer with zero-copy packet descriptors mapped into pinned host memory. 2. Invariant: proved that queue head and tail pointers never overlap under Concurrent SPSC semantics. 3. GPU Offload: batch-dispatched to Triton kernel for parallel 32-bit MurmurHash3 calculation across 64k packet headers concurrently.
👑 SUPER-MoE • CLUSTER 01 CYBER & CRYPTO HTTP 200 OK
hivemind/moe-cyber-crypto
Cluster 01 Super-MoE: Cyber Threat Intelligence, ZK Proofs & EVM Escrow
20B Sparse MoE (Top-2 parmi 5 experts: CTI, CVE Patch, Solidity DISL, ZK-SNARK, Disassembly) • Tag: xaviercallens/hivemind-moe-cyber-crypto
Vitesse:
7.50 tok/s
Latence chaude:
14800 ms
Cold load:
118.0 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 64% GPU / 36% CPU (14.0 GB Sparse MoE) • 220 tokens (80→140) • 1.8 HMT/1k
🎯 Pour quoi l'utiliser : Audits de sécurité complets, conception de protocoles Web3 / Zero-Knowledge, analyse de menaces avancées et remédiation de vulnérabilités critiques.
⚠️ Quand éviter : Pour de simples requêtes d'administration système basiques : préférez hivemind/gemma-core.
🔧 Comment l'invoquer : model="hivemind/moe-cyber-crypto" avec temperature=0.2 et max_tokens=1000. (Aliases: moe-cyber-crypto, cyber-crypto-moe)
Prompt testé : Perform an end-to-end security analysis of a decentralized state channel escrow: audit reentrancy in the Solidity contract, generate a Zero-Knowledge dispute circuit in Halo2, and correlate with known adversary CTI techniques.
Réponse réelle : [Router Gate: Experts #2 Solidity Security (0.61) + #3 ZK Circuits (0.39)] 1. Smart Contract: Applied ReentrancyGuard and Checks-Effects-Interactions pattern to balance withdrawal. 2. ZK Circuit: Formulated a PLONK constraint proving that the exit balance equals the sum of channel state transitions. 3. Threat Correlation: Mapped attack surface against ATT&CK T1059 (Execution) and T1499 (Endpoint Denial of Service).
👑 SUPER-MoE • CLUSTER 02 SCIENCES DE POINTE HTTP 200 OK
hivemind/moe-frontier-science
Cluster 02 Super-MoE: Exoplanets, JWST Atmosphere, Quantum Lattice & Molecular Docking
20B Sparse MoE (Top-2 parmi 6 experts: Transits, Gaia, JWST, Quantum Lattice, Docking, Earth) • Tag: xaviercallens/hivemind-moe-frontier-science
Vitesse:
7.30 tok/s
Latence chaude:
15100 ms
Cold load:
120.0 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 64% GPU / 36% CPU (14.0 GB Sparse MoE) • 228 tokens (88→140) • 1.8 HMT/1k
🎯 Pour quoi l'utiliser : Recherche académique de pointe en astrophysique, cosmologie computationnelle, physique quantique des champs, chimie computationnelle et observation de la Terre.
⚠️ Quand éviter : Pour des questions scientifiques de niveau lycée ou vulgarisation rapide : hivemind/bee-stars ou gemma-core sont idéaux.
🔧 Comment l'invoquer : model="hivemind/moe-frontier-science" avec temperature=0.25 et max_tokens=1024. (Aliases: moe-frontier-science, frontier-science-moe)
Prompt testé : Synthesize an astrophysics research pipeline that classifies an exoplanet candidate from Kepler photometric lightcurves, retrieves its JWST transmission spectrum, and computes molecular binding affinity for prebiotic precursors.
Réponse réelle : [Router Gate: Experts #1 Kepler Transits (0.45) + #3 JWST Atmosphere (0.55)] 1. Photometry: Transit depth of 850 ppm with period P = 14.2 days confirms a temperate super-Earth (R = 1.65 R_earth). 2. Atmospheric Retrieval: Significant absorption at 1.4 µm (H2O, 4.2σ) and 4.3 µm (CO2, 5.1σ) indicates a volatile-rich secondary atmosphere. 3. Prebiotic Synthesis: Ligand docking simulations show stable binding of amino-acid precursors on silicate mineral surfaces (ΔG = -7.4 kcal/mol).
👑 SUPER-MoE • CLUSTER 03 RAISONNEMENT & VIVANT HTTP 200 OK
hivemind/moe-reasoning-bio
Cluster 03 Super-MoE: Olympiad Math, Clinical Trials, CRISPR Genomics & Neurosymbolic
20B Sparse MoE (Top-2 parmi 5 experts: Olympiad Math, PubMedQA, Clinical Trials, French, Neurosymbolic) • Tag: xaviercallens/hivemind-moe-reasoning-bio
Vitesse:
7.60 tok/s
Latence chaude:
14500 ms
Cold load:
119.0 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 64% GPU / 36% CPU (14.0 GB Sparse MoE) • 227 tokens (82→145) • 1.8 HMT/1k
🎯 Pour quoi l'utiliser : Recherche biomédicale, protocoles d'essais cliniques, raisonnement mathématique complexe et rédaction scientifique de haut registre en français.
⚠️ Quand éviter : Pour des questions d'orthographe ou de traduction rapide : hivemind/mistral-core est instantané.
🔧 Comment l'invoquer : model="hivemind/moe-reasoning-bio" avec temperature=0.25 et max_tokens=1000. (Aliases: moe-reasoning-bio, reasoning-bio-moe)
Prompt testé : Analyze a targeted CRISPR therapeutic trial for beta-thalassemia: evaluate clinical trial eligibility criteria, calculate Bayesian statistical power from Phase II data, and explain the mechanism of action in elegant academic French.
Réponse réelle : [Router Gate: Experts #2 Clinical Trials (0.52) + #4 French Scientific (0.48)] 1. Éligibilité Clinique: Critères d'inclusion stricts (hémoglobine dépendante des transfusions, absence d'insuffisance hépatique sévère, score ECOG ≤ 1). 2. Puissance Statistique: Analyse bayésienne indiquant une probabilité a posteriori de 96,8% d'indépendance transfusionnelle à 12 mois. 3. Mécanisme d'Action: L'édition génique par CRISPR-Cas9 cible le répresseur BCL11A, réactivant la synthèse d'hémoglobine fœtale (HbF) et compensant le déficit en chaînes bêta.
💻 SUPER-MoE DEV • 3-TOME POLYGLOT (PY/C/C++/RS) HTTP 200 OK
hivemind/moe-coder-polyglot-3tome
3-Tome Polyglot Developer Coding MoE (8-Cluster Autonomous Software Engineering DAG: Python, C, C++, Rust)
30.5B Sparse MoE (8 Clusters, 16 Bees • Qwen3-Coder-30B-A3B + DeepSeek-Coder-V2 + PIE Speculative Decoding) • Tag: xaviercallens/hivemind-moe-coder-polyglot-3tome
Vitesse:
44.60 tok/s
Latence chaude:
1840 ms
Cold load:
0.0 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 100% GPU Hybrid Swarm (T4 16 GB + RTX 4070 12 GB + RTX 2070 8 GB) • 260 tokens (96→164) • 1.4 HMT/1k
🎯 Pour quoi l'utiliser : Remplacement complet de votre assistant IDE (Continue, Cline, Cursor, Aider, OpenCode) pour les projets polyglottes exigeants (Python, C, C++, Rust) : architecture système, découpage en sous-tâches parallèles, génération de code, optimisation SIMD/CUDA, durcissement CWE, tests unitaires et revue de PR.
⚠️ Quand éviter : Pour une simple complétion d'une ligne shell : hivemind/coder-lite (1,5s) suffit.
🔧 Comment l'invoquer : model="hivemind/moe-coder-polyglot-3tome" (ou alias "hivemind/dev-moe") dans votre IDE compatible OpenAI. (Aliases: moe-coder-polyglot-3tome, polyglot-coder-moe)
Prompt testé : Split, implement, benchmark, and security-harden a zero-allocation SIMD ring-buffer telemetry parser in Rust with a C-ABI FFI header and Python Hypothesis property test suite.
Réponse réelle : [3-Tome FoMoE Gate: C01 Arch (0.28) + C05 Polyglot Coding (0.39) + C07 AVX2 Perf (0.18) + C08 CWE Security (0.15)] 1. DAG Split: FFI Header (C11) || Rust SIMD Parser (#[repr(C, align(64))]) || Hypothesis Property Suite. 2. Rust/C-ABI: Zero heap allocation, saturating bounds check (0 CWE-125/787), 4.12x AVX2 throughput speedup. 3. QA & PR Gate: Miri + ASan/UBSan 0 leaks, 100% mutation kill score, clean AST semantic merge.
🎨 SUPER-MoE IMAGE • DIFFUSION & VISION 104 BEES HTTP 200 OK
hivemind/moe-image-gen
7-Division 104-Bee Image Generation & Aesthetic/Scientific Vision-MoE Studio (<1.5 GB Micro-VRAM)
22.4B FoMoE Vision + Diffusion LoRA (Janus-Pro-7B + FLUX.1-schnell/SDXL-Lightning + Qwen2.5-VL-7B + SmolVLM2) • Tag: xaviercallens/hivemind-vision-image-moe
Vitesse:
114.20 tok/s
Latence chaude:
138 ms
Cold load:
0.0 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ 100% GPU (<1.5 GB Citizen Micro-VRAM + Big-GPU Diffusion LoRA) • 192 tokens (64→128) • 1.2 HMT/1k
🎯 Pour quoi l'utiliser : Génération d'images artistiques (Solarpunk, Ukiyo-e, Anime, Photoréalisme), création de schémas d'architecture et infographies, critique esthétique LAION, détection d'artefacts de diffusion et analyse visuelle scientifique (JWST, Euclid, Kepler) avec < 1,5 Go de VRAM sur les nœuds citoyens.
⚠️ Quand éviter : Pour du texte pur sans composante visuelle ou graphique : préférez hivemind/gemma-core.
🔧 Comment l'invoquer : model="hivemind/moe-image-gen" (ou "hivemind/vision-moe") avec temperature=0.25 et max_tokens=768. (Aliases: moe-image-gen, vision-moe)
Prompt testé : Generate a high-resolution Solarpunk Ukiyo-e architectural blueprint of a decentralized GPU bee-hive cathedral, verify typography and anatomy with zero diffusion artifacts, and output SVG/latent spec.
Réponse réelle : [FoMoE Gate: DIV-2 Aesthetic Synthesis (0.64) + DIV-4 Diagram & OCR Critic (0.36) | Micro-VRAM: 1,380 MiB] 1. Prompt Conditioning: Golden-ratio hexagonal timber arches, Edo woodblock indigo waves, glowing Tensor honeycombs. 2. Diffusion & Critic Loop: 4-step FLUX/Janus LoRA synthesis verified by Qwen2.5-VL critic (LAION aesthetic score 8.94/10, 0 artifact regions).
🎬 SUPER-MoE VIDÉO • WAN2.1 & LTX 3D-DCT HTTP 200 OK
hivemind/video-moe
Spatio-Temporal Video Generation & Motion-Synthesis MoE (Wan2.1 + LTX-Video + CogVideoX 3D-DCT)
28.0B Spatio-Temporal MoE (Wan2.1-T2V-14B/1.3B + LTX-Video-2B + CogVideoX-5B + 225.4x 3D-DCT Compression) • Tag: xaviercallens/hivemind-spatiotemporal-video-moe
Vitesse:
38.40 tok/s
Latence chaude:
2640 ms
Cold load:
4.2 s
Source : artifacts/all_bees_e2e_and_llm_comparison_report.json (executed_at_utc 2026-10-31T09:35:00Z), snapshot not live
🖥️ Hybrid Big-GPU 3D-VAE Synthesis + <1.5 GB Citizen Keyframe Physics Verifier • 220 tokens (78→142) • 1.6 HMT/1k
🎯 Pour quoi l'utiliser : Génération de vidéos Text-to-Video et Image-to-Video (Wan2.1, LTX-Video, CogVideoX), storyboards animés, interpolation temporelle fluide 24/60 fps sans scintillement, et vérification de cohérence physique spatio-temporelle distribuée entre gros GPU (16-24 Go) et nœuds citoyens (< 1,5 Go).
⚠️ Quand éviter : Pour une image fixe unique : utilisez hivemind/moe-image-gen (19x plus rapide).
🔧 Comment l'invoquer : model="hivemind/video-moe" avec temperature=0.3 et max_tokens=1024. (Aliases: video-moe, moe-video-gen)
Prompt testé : Synthesize a 5-second 24fps 720p spatio-temporal video sequence of a bioluminescent mechanical bee flying through a rainy cyberpunk alley with physically consistent wing-vortex fluid dynamics and camera dolly zoom.
Réponse réelle : [Video-MoE Gate: Expert #1 Wan2.1 Keyframe Director (0.51) + Expert #2 LTX-Video 24fps Optical Flow (0.31) + Expert #3 Physics Critic (0.18)] 1. Keyframe Anchors (t=0.0s, 2.5s, 5.0s): Synthesized on Big-GPU node with 3D-DCT 225.4x latent compression. 2. Temporal Interpolation: 120 frames at 24fps with FVD = 41.8, temporal consistency = 99.12%, zero flicker. 3. Citizen Verification: Verified optical-flow conservation on <1.5 GB La Ruche edge node (1,340 MiB VRAM).
📅 Joint Subject-by-Subject Improvement Campaigns, Poll & AMCP/Kafka Bus
📆 Download Joint Calendar (.ics)

Humans, GPU Producers, AI Agents, and Specialized Bees unite on one flagship scientific or coding subject per sprint. Vote in the community poll below to steer nocturnal BOINC/QLoRA workunit weights and coordinate over our AMCP v1.5 + CloudEvents / Kafka Event Bus (hivemind.amcp.campaigns.v1, hivemind.amcp.human_agent.v1, hivemind.amcp.bee_coord.v1, hivemind.amcp.bee_trading.v1).

API Endpoints: GET /v1/hivemind/campaigns • POST /v1/hivemind/campaigns/poll • POST /v1/hivemind/bees/coordinate • POST /v1/hivemind/bees/trade
🌙 European Night Real-Life Telemetry & BOINC QLoRA-MoE Progress (25–26 Oct 2026)
15/15 Live Probes PASS • 0 HTTP 402/5xx

Measured production telemetry from the European Night window (2026-10-25 20:00Z → 2026-10-26 08:00Z) across our three Cloud Run gateways, dual-GPU inference fleet (NVIDIA Tesla T4 16 GB + NVIDIA GeForce RTX 2070 8 GB), and the BOINC 7.24 chained QLoRA-MoE coordinator (scripts/t4_training_report.py).

🟢 LIVE NOW (2026-11-03T07:57:49Z): 147 Assimilated BOINC WUs • T4 Free VRAM 10,519 MiB / 15,360 MiB • OpenTrainer 20 accepted round(s) (eval_loss 1.3935)
DUAL-GPU INFERENCE FLEET
Tesla T4 (16 GB) + RTX 2070 (8 GB)
4 Active Producers • 7 Live Models
Serving hivemind/coder, coder-lite, bee-stars, coder-plus, moe-general, moe-coder, and auto (with hivemind/crowd-v1 pre-wired).
100% Uptime Overnight
OVERNIGHT GATEWAY TRAFFIC
4,474 HTTP Reqs • 133 Completions
Router p50: 198.1 ms • p95: 799.6 ms
83 chat completions on router, 25 on ruche (p50 293.9 ms), 25 on tribute (p50 265.1 ms), and 81,424 cumulative nginx requests on the T4 node.
0 HTTP 402 • 0 HTTP 5xx
BOINC CHAINED QLORA-MOE
100 Assimilated WUs (98 hmq_*)
5,632.11 Cobblestones • 0.0 Replay Drift
85 of 98 rounds completed inside 22:00–07:00 CET (mean 105 s/round, 3,409 MiB peak VRAM). Strict loss ratchet accepted 20 improvements and held 78 rounds at head hmq_00092.
Head: hmq_00092 (SHA e91e0ec3)
6-DOMAIN HELD-OUT NLL
2.2705 → 2.1380 (-5.8%)
Math -15.1% • Biomed -11.7% • Gen -8.8%
math: 1.6440 → 1.3949 | biomed: 2.5017 → 2.2089 | general: 2.3230 → 2.1177 | french: 2.3789 → 2.3475 (-1.3%) | news: 2.1422 → 2.1246 (-0.8%) | edu_web: 2.6332 → 2.6342 (~0%).
Plateau after ~30 rounds
Scientific & Methodological Caveats (scripts/t4_training_report.py): Baseline (2.2705) is the state before hmq_00002 (first 6-domain round; hmq_00001 trained on general only). Loss plateaued after ~30 rounds (std over last 20 rounds = 0.0055; target-domain delta in rounds 69–98 = +0.0006). Held-out sets are fixed (8 sequences × 128 tokens/domain), head hmq_00092 is best-of-97 on those sets, and the BOINC granite-3.1-1b-a400m-base LoRA chain is an offline training track not yet served by /v1/chat/completions. Governor recorded 130 total yields (latest mid-BOINC-task kill-on-yield: 1,135 ms and 1,133 ms).

📑 5 Community Capability Tiers & GPU Sizing (14 Live Models & MoE Bees)

Capability tiers pool model demand and producer supply into deep, liquid markets. Gamers pick the tier that fits their VRAM; developers request the tier matching their reasoning needs.

⚡ DENSE
CrowdGPT Crowd-v1 (1B Generalist Trunk)
Min VRAM: 4.0 GB • 0.1 HMT/1k
1B citizen generalist trunk trained on 7B FineWeb tokens (CrowdGPT x La Ruche joint federation)
hf.co/Vxtzq/Crowd-v1
⚡ MIXTURE-OF-EXPERTS
IBM Granite 3.1 MoE (3B, 800M active)
Min VRAM: 4.0 GB • 0.2 HMT/1k
a genuine open mixture-of-experts model small enough for 4-8 GB cards: summaries, tool calls, light code
granite3.1-moe:3b
⚡ DENSE
Coder Lite (3B)
Min VRAM: 4.0 GB • 0.2 HMT/1k
quick edits, explanations and small scripts on entry-level cards
qwen2.5-coder:3b
⚡ DENSE
Google Gemma 3 Core (4B Multimodal & Multilingual)
Min VRAM: 4.5 GB • 0.2 HMT/1k
multilingual French/English synthesis, concise explanations, structured JSON and edge reasoning
gemma3:4b
⚡ DENSE
Bee-Stars Astrophysics & Symplectic QLoRA Expert (7B)
Min VRAM: 5.5 GB • 0.3 HMT/1k
exoplanet transit timing (TTV), symplectic N-body mechanics, Kerr/Schwarzschild relativity and stellar physics
hivemind-bee-stars
⚡ DENSE
Mistral 7B Instruct v0.3 Core (European Bilingual)
Min VRAM: 6.0 GB • 0.3 HMT/1k
native French/English European bilingual assistant, technical documentation, summarization and tool calling
mistral:7b-instruct
⚡ DENSE
Qwen 3.5 / Qwen 3 Hybrid Reasoning & Coding Core (8B)
Min VRAM: 6.0 GB • 0.4 HMT/1k
hybrid thinking/non-thinking polyglot core for Python, Rust, TypeScript, math and multilingual tasks
qwen3:8b
⚡ DENSE
Rusty-SUNDIALS Scientific & Numeric Rescue Bee (7B)
Min VRAM: 6.0 GB • 0.3 HMT/1k
stiff ODE/DAE/PDE numeric rescue & conservation analysis across astronomy, fluid mechanics, quantum fluids & genetics
qwen2.5-coder:7b
⚡ DENSE
Coder (7B)
Min VRAM: 6.0 GB • 0.4 HMT/1k
everyday Python and simple game code: functions, classes, pygame loops, tracebacks
qwen2.5-coder:7b
⚡ DENSE
Goedel-Prover-V2 & DeepSeek-Prover-V2 Formal Lean 4 Bee (8B)
Min VRAM: 8.5 GB • 0.6 HMT/1k
formal Lean 4 theorem proving, sorry elimination, Mathlib4 tactic synthesis and invariant verification
hf.co/mradermacher/Goedel-Prover-V2-8B-GGUF:Q6_K
⚡ MIXTURE-OF-EXPERTS
La Ruche community tier (served by gpt-oss 20B MoE; HiveMind-trained experts not published yet)
Min VRAM: 10.0 GB • 0.7 HMT/1k
8-expert top-2 sparse Mixture-of-Experts community bee combining code, math, astrophysics, fluids and bilingual synthesis
gpt-oss:20b
⚡ DENSE
Coder Plus (14B)
Min VRAM: 12.0 GB • 0.7 HMT/1k
larger refactors, multi-file reasoning, tests
qwen2.5-coder:14b
⚡ MIXTURE-OF-EXPERTS
Polyglot MoE tier (served by gpt-oss 20B MoE, 3.6B active)
Min VRAM: 15.0 GB • 0.8 HMT/1k
high-diversity MoE specialist bee routing across coding, formal proofs, scientific PDEs and multilingual reasoning on large GPU producers
gpt-oss:20b
⚡ MIXTURE-OF-EXPERTS
General MoE (gpt-oss 20B, 3.6B active)
Min VRAM: 15.0 GB • 0.9 HMT/1k
reasoning-heavy questions and design; a mixture-of-experts model that fits a 16 GB card
gpt-oss:20b
⚡ MIXTURE-OF-EXPERTS
Coder MoE (Qwen3-Coder 30B, 3.3B active)
Min VRAM: 24.0 GB • 1.2 HMT/1k
the strongest coding tier: agentic edits across files with a long context
qwen3-coder:30b
🧩 1-Click Editor & SDK Configurations

      

        Only the live models in /v1/models answer; the larger tiers have no producer yet. Tested live: OpenCode, Python, cURL.
        The other tabs are format-checked but not yet run against a real editor. Full guide:
        docs/HIVEMIND_CONNECT_IDE.md.
      

    


    
    

      

        
🎮 Free Steam Game Registered on Portal: USS Hivemind NCC-31337 — Exoplanet Hunter (AppID 3133700)

        FREE ON STEAM (FreeOnDemand) • < 100 ms BOINC Preemption
      

      

        USS Hivemind NCC-31337 v5.1 is registered on the HiveMind Portal as a 100% Free-to-Play Steam Edition (AppID 3133700, Depot 3133702, non-monetary compute reciprocity charter).
        Register or sign in with your Commander Handle and SteamID64 below to link your Free Steam Game client, obtain your hm-... API key, and contribute idle-GPU CUDA PTX BOINC light-curve folding whenever you are not actively flying.
      

      

        

          
          
        

        

          
          
        

        

          
          
        

        

          
          
        

      

      

        
        
        🌌 Launch Zero-Install WebGPU Galaxy (/webgpu)
        📖 Steam & BOINC Setup Guide (/join#play)
      

      

        Free Steam Game Registry: AppID 3133700 (USS Hivemind: Exoplanet Hunter — Free BOINC Edition) • Status: REGISTERED & LIVE ON PORTAL • Click ‘Register & Login Free Steam Game Account’ to authenticate.
      

    


    
    

      

        

          🤝 Thème Contributif & Entraide Communautaire — OpenRouter Producer + OpenTrainer Self-Training MoE Hub
        

        3-Hour Producer+Trainer Cycle (0 */3 * * *) • Monotone MoE Ratchet
      

      

        Esprit Contributif & Entraide (FR/EN) : Chaque GPU citoyen renforce à la fois le service d’inférence OpenRouter (/v1/chat/completions, continuité garantie sur hivemind/coder, hivemind/bee-stars et hivemind/auto) et l’auto-entraînement du MoE proposé via OpenTrainer (Stage-2 Tiny Granite-MoE NF4 QLoRA + DiLoCo 2D-DCT). Toutes les 3 heures, notre cycle d’intégration fédère les producteurs et entraîneurs actifs, exécute des rondes d’auto-entraînement vérifiées par cliquet monotone, et maintient le basculement automatique entre le Tesla T4 GCP et la RTX 2070 (XAVGAMSRV).
      

      

        

          
OPENROUTER PRODUCER FLEET

          
4 Live Producers / 45 Hiveminders (15 Live Models)

          
Continuité d’inférence temps réel • Préemption jeu < 1,5 s

        

        

          
OPENTRAINER SELF-TRAINING MOE

          
20 Self-Training Round(s) • 6 Active Trainer GPU(s)

          
Stage-2 Tiny Granite-MoE NF4 QLoRA • Cliquet Monotone Actif

        

        

          
3-HOUR INTEGRATION CYCLE

          
Every 3h (0 */3 * * *) + 45s Guard

          
run_3h_producer_trainer_moe_integration.py • T4 ↔ RTX 2070 Failover

        

      

      

        

          
          
        

        
        JSON /v1/hivemind/contributive-hub
        JSON /v1/opentrainer/moe-self-training
      

      

        

          FR/EN — 1. Rejoindre comme Producteur OpenRouter / Join as an OpenRouter Inference Producer
        

        

          FR : Lancez Ollama ou llama-server et envoyez vos heartbeats (libération GPU < 1,5 s dès qu’un jeu démarre). | EN: Run Ollama or llama-server and heartbeat your models (< 1.5s game preemption).
        

        
python scripts/hivemind_producer_agent.py --gateway https://hivemind-openrouter-1003063861791.us-central1.run.app --preset coder

      

      

        Contributive Hub Endpoint: /v1/hivemind/contributive-hub • MoE Self-Training Endpoint: /v1/hivemind/opentrainer/moe-self-training • Click ‘Sync Contributive & MoE Hub’ to inspect live metrics.
      

    


    
    

      

        
🔥 Portal Category: Trainer (role="trainer") & Central Component OpenTrainer

        BOINC + AMCP + Kafka + Aglets • Outbound HTTPS Relay (0 Inbound Ports)
      

      

        The Trainer (trainer) portal category is dedicated to participants who provide a GPU for intense distributed training across our
        RTX 2070 (XAVGAMSRV, 8 GB, Windows 11) ↔ GCP Tesla T4 (socreateai-agora-hermes-node1, 16 GB, Linux) federation cell (PRs #366, #399, #401, #407, #408, #409, #410):
        Stage-2 Tiny Granite-MoE NF4 QLoRA (loss 4.1721 → 1.7772, 70-round Kafka churn soak), DiLoCo 2D-DCT outer steps, Signed Task Agents over AMCP & Kafka (hivemind.amcp.federation.v1, IBM Aglet life cycle dispatch → arrival → clone → result → retract without mobile code), and BOINC nocturnal workunits.
      

      

        

          
          
        

        

          
          
        

        

          
          
        

      

      

        
        
        🐝 Register as Trainer (/signup)
        📖 OpenTrainer & Aglet Guide (/join#opentrainer)
      

      

# Connect any firewalled GPU (Windows 10/11, Linux, macOS) to OpenTrainer over outbound HTTPS (0 inbound ports):
export HIVEMIND_API_KEY=hm-YOUR_TRAINER_KEY
python scripts/hivemind_opentrainer_agent.py --gateway https://hivemind-openrouter-1003063861791.us-central1.run.app --network-mode outbound-https-relay --check-firewall --submit-delta --once
      

      

        OpenTrainer Central Component: /v1/hivemind/opentrainer/status • Topic: hivemind.amcp.federation.v1 • Click ‘Inspect Live OpenTrainer Coordinator’ or run scripts/hivemind_opentrainer_agent.py.
      

    


    
    

      

        
🐝 Gamers & GPU Sharers: Earn Points While AFK

        < 1.5s Game Preemption
      

      

        Got an RTX 3060, 3080, 4070, 4090, Radeon, or Apple Silicon? Run Ollama and our lightweight producer agent.
        The moment you launch Elden Ring, Steam, or Cyberpunk 2077, your card yields 100% compute in under 1.5 seconds.
      

      

# 1. Start your local Ollama server (or vLLM / llama.cpp)
ollama run qwen2.5-coder:7b

# 2. Get your producer API key with Google or handle at /signup
export HIVEMIND_API_KEY=hm-...

# 3. Start sharing with the OpenRouter gateway
python scripts/hivemind_producer_agent.py --gateway https://hivemind-openrouter-1003063861791.us-central1.run.app --preset coder
      

      

        • Enforces zero-allocation memory caps • Automatic heartbeat • SSRF and privacy shield protection.