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.
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 ?
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.
Même avec un partage GPU/CPU (64%/36% sur T4 16 Go), nos 4 abeilles MoE 20B répondent en ~15,3s contre 28,0s (3,93 tok/s) pour le modèle 14B dense.
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)
0 – 35 ms (Temps réel)
1. Butinage d'Intention & Routage de Liquidité (Pollen Classifier)
15 Modèles Actifs • 0 HTTP 402/5xx
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.
2. Récolte de Nectar Diurne & Préemption Jeu < 1,5 s
16,5 à 71,9 tok/s (100% GPU) • Yield 1,13 s
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 libère 100% de la VRAM en moins de 1,5 seconde.
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.
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).
🎯 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...
⚠️ 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...
🎯 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...
🎯 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
🎯 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-SUNDIALSHTTP 200 OK
hivemind/bee-rusty-sundials
Stiff Robertson Chemical Kinetics BDF/Newton Rescue
🎯 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...
🎯 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)
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`...
🎯 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
🎯 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)
🎯 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
🎯 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.
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.
🎯 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.
🎯 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)
🎯 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...
🖥️ 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.
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.
📅 Joint Subject-by-Subject Improvement Campaigns, Poll & AMCP/Kafka Bus
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).
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.
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
⚡ 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
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.
🐝 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