{"slug": "imece-a-decentralized-ai-compute-cooperative", "title": "Imece – a decentralized AI compute cooperative", "summary": "Imece has launched an open-source decentralized AI compute cooperative that allows contributors to donate idle GPU and CPU time in exchange for non-transferable inference credits denominated in floating-point operations (FLOPs). The platform uses a custom layer-sharding system for distributed inference, with hardware multipliers and energy-aware task scheduling that routes computation toward regions with low electricity demand and high renewable availability. By turning idle global compute capacity into a cooperative resource, Imece aims to democratize AI inference access away from centralized data centers.", "body_md": "A decentralized AI compute cooperative where contributors earn inference credits by donating idle GPU/CPU time — measured in FLOPs, not crypto.\n\nimece is an open-source framework that allows anyone to contribute idle compute resources in exchange for AI inference credits — denominated in floating-point operations (FLOPs), not cryptocurrency.\n\n**The core idea:** You donate idle GPU/CPU time → you earn GigaFLOP-Tokens (GFT) → you spend GFT to access AI inference. No speculation. No financial value. Just compute for compute.\n\nAI inference is increasingly powerful but increasingly centralized. Access is gated by capital, not contribution. Meanwhile, millions of GPUs sit idle every night across the world, in different time zones, on different grids.\n\nimece turns that idle capacity into a global cooperative — one where the communities that bear the cost of AI infrastructure are also empowered to benefit from it.\n\nA secondary benefit: because contributor nodes are globally distributed across time zones, computation naturally migrates toward regions with low electricity demand and high renewable availability at any given hour — a passive energy-efficiency property that centralized data centers cannot replicate.\n\n```\nContribute idle compute → earn GFT tokens → spend tokens on AI inference\n```\n\nToken formula:\n\n```\nT_earned = FLOPs_delivered × Hardware_Multiplier × Reliability_Factor\n```\n\nToken cost per inference:\n\n```\nT_spent = FLOPs_per_model × Output_tokens × Precision_factor\n```\n\nAll tokens are:\n\n- Denominated in GigaFLOPs (objective, hardware-agnostic)\n- Non-transferable and non-tradeable by design\n- Tied to the wallet that earned them\n\nThe framework has four components:\n\n| Component | Role |\n|---|---|\nContributor Client |\nBenchmarks device, serves transformer model layers, manages token wallet |\nCoordination Layer |\nDispatches tasks, assigns hardware multipliers, issues tokens, routes inference |\nToken Ledger |\nAppend-only hash-chained log of all GFT issuance and redemption |\nInference Cluster |\nCustom distributed pipeline (volunteer nodes) primary, centralized fallback |\n\nimece implements a custom layer-sharding system for distributed inference:\n\n**Primary:** Volunteer contributor nodes each serve a contiguous slice of transformer layers. Inference requests flow through the pipeline — activations pass from node to node until the final output is generated. Contributors earn tokens proportional to FLOPs delivered. Any HuggingFace-compatible transformer model can be served — LLaMA 3, Mistral, Mixtral, and others.**Fallback:** A centralized inference service — used when the volunteer pipeline is unavailable, ensuring reliable access at all times. The current implementation includes a Groq fallback path, with additional providers welcome as community contributions.\n\nThis makes the token economy architecturally honest — earned tokens are backed by compute that directly contributes to real AI inference.\n\n| Hardware Class | Example Devices | Multiplier |\n|---|---|---|\n| Mobile / Edge | Smartphone SoCs, Raspberry Pi | 0.05× |\n| CPU Only | Desktop / server CPUs | 0.10× |\nEntry Consumer GPU (integrated) |\nIntel UHD, AMD Radeon integrated | 0.50× |\nMid Consumer GPU (baseline) |\nRTX 3060, RX 6700 XT | 1.00× |\n| High Consumer GPU | RTX 4080, RX 7900 XTX | 2.00× |\n| Prosumer GPU | RTX 4090, RTX 6000 Ada | 3.00× |\n| Professional Accelerator | A40, L40S | 5.00× |\n| Data Center Accelerator | A100, H100, H200 | 8.00× |\n\nMultipliers are derived from a composite AI Performance Index (API) combining matrix multiplication throughput, memory bandwidth, and batch inference latency. Hardware changes trigger a quarantine period to prevent swap attacks.\n\nThe coordination layer implements energy-aware task scheduling using real-time grid data:\n\n```\nP_grid = w1×(1−L) + w2×(1−C) + w3×R\n```\n\nWhere L = grid load, C = carbon intensity, R = renewable fraction. Tasks are preferentially routed to nodes in regions with low grid demand and high renewable generation.\n\n```\n                 +----------------------+\n                 |      User / DApp     |\n                 |  (requests inference)|\n                 +----------+-----------+\n                            |\n                            v\n                 +----------------------+\n                 |   Coordination Layer |\n                 |  - Node registry     |\n                 |  - Shard scheduler   |\n                 |  - Grid-aware routing|\n                 |  - Token issuance    |\n                 +----------+-----------+\n                            |\n        +-------------------+-------------------+\n        |                                       |\n        v                                       v\n+---------------------+              +----------------------+\n| Distributed Pipeline|              |  Fallback Inference  |\n|  (Volunteer Nodes)  |              | (Centralized backend)|\n|                     |              |  e.g., Groq / others |\n+----------+----------+              +----------+-----------+\n           |                                    ^\n           | activations                        |\n           v                                    |\n+---------------------+                         |\n|  Contributor Nodes  |                         |\n|  - Benchmark        |                         |\n|  - Serve layers     |                         |\n|  - Earn GFT         |                         |\n+---------------------+                         |\n                                                |\n                    +---------------------------+\n                    |\n                    v\n           +----------------------+\n           |   Token Ledger       |\n           | - GFT balances       |\n           | - Hash-chained log   |\n           +----------------------+\n```\n\n**imece: A FLOP-Based Token Framework for Decentralized AI Access**\nAslan Kose — Independent Researcher\n*arXiv preprint — to be submitted upon public release of this codebase*\n\n- Framework design and specification complete\n- Academic paper drafted\n- Coordination Layer — FastAPI + PostgreSQL\n- Token Ledger — hash-chained, tamper-evident\n- Hardware multiplier system — 8 tiers with interpolation\n- Grid-aware scheduler — P_grid formula\n- Shard registry + pipeline scheduler\n- Distributed inference pipeline — custom layer sharding proven\n- Auto-reconnect on coordinator restart\n- Inference challenge verification + reliability factor\n- Test suite — 52 passing tests\n- Contributor client — cross-platform, simulation + production mode\n- Public beta release\n- Real model weights — load HuggingFace models on volunteer nodes\n*(community)* - Fallback inference integration — Groq-based centralized fallback implemented\n\nWe welcome community contributions, particularly:\n\n**Real model serving**— integrate`torch`\n\n+`transformers`\n\nfor production inference on volunteer nodes. The activation server already supports real model loading via HuggingFace — GPU nodes with sufficient VRAM can load and serve model layer slices today.**Fallback inference**— Groq fallback is already implemented in`_fallback_inference()`\n\nwithin`coordination/api/inference.py`\n\n. Contributions to add additional providers such as Together AI or self-hosted Ollama are welcome.**Grid API integration**— replace mock grid data with real ENTSO-E or EIA grid operator APIs.** Security hardening**— formal analysis of the token issuance and challenge verification protocols.\n\nPlease open an Issue to discuss before submitting a pull request.\n\nMIT License\n\n**Aslan Kose** — IT professional, independent researcher\nGitHub: [@jstdv](https://github.com/jstdv)\n\n*imece emerged from a conviction that the communities bearing the cost of AI infrastructure should also be empowered to benefit from it.*", "url": "https://wpnews.pro/news/imece-a-decentralized-ai-compute-cooperative", "canonical_source": "https://github.com/jstdv/imece", "published_at": "2026-05-30 03:43:02+00:00", "updated_at": "2026-05-30 04:15:28.307218+00:00", "lang": "en", "topics": ["artificial-intelligence", "ai-infrastructure", "ai-ethics", "ai-tools", "ai-research"], "entities": ["imece"], "alternates": {"html": "https://wpnews.pro/news/imece-a-decentralized-ai-compute-cooperative", "markdown": "https://wpnews.pro/news/imece-a-decentralized-ai-compute-cooperative.md", "text": "https://wpnews.pro/news/imece-a-decentralized-ai-compute-cooperative.txt", "jsonld": "https://wpnews.pro/news/imece-a-decentralized-ai-compute-cooperative.jsonld"}}