A decentralized AI compute cooperative where contributors earn inference credits by donating idle GPU/CPU time — measured in FLOPs, not crypto.

imece 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.

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.

Motivation

AI 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.

imece 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.

A 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.

How It Works

Contribute idle compute → earn GFT tokens → spend tokens on AI inference

Token formula:

T_earned = FLOPs_delivered × Hardware_Multiplier × Reliability_Factor

Token cost per inference:

T_spent = FLOPs_per_model × Output_tokens × Precision_factor

All tokens are:

• Denominated in GigaFLOPs (objective, hardware-agnostic)
• Non-transferable and non-tradeable by design
• Tied to the wallet that earned them

Architecture

The framework has four components:

Distributed Inference Architecture

imece implements a custom layer-sharding system for distributed inference:

• 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.

This makes the token economy architecturally honest — earned tokens are backed by compute that directly contributes to real AI inference.

Hardware Multiplier Tiers

Multipliers 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.

Grid-Aware Scheduling

The coordination layer implements energy-aware task scheduling using real-time grid data:

P_grid = w1×(1−L) + w2×(1−C) + w3×R

Where 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.

General Diagram

                 +----------------------+
                 |      User / DApp     |
                 |  (requests inference)|
                 +----------+-----------+
                            |
                            v
                 +----------------------+
                 |   Coordination Layer |
                 |  - Node registry     |
                 |  - Shard scheduler   |
                 |  - Grid-aware routing|
                 |  - Token issuance    |
                 +----------+-----------+
                            |
        +-------------------+-------------------+
        |                                       |
        v                                       v
+---------------------+              +----------------------+
| Distributed Pipeline|              |  Fallback Inference  |
|  (Volunteer Nodes)  |              | (Centralized backend)|
|                     |              |  e.g., Groq / others |
+----------+----------+              +----------+-----------+
           |                                    ^
           | activations                        |
           v                                    |
+---------------------+                         |
|  Contributor Nodes  |                         |
|  - Benchmark        |                         |
|  - Serve layers     |                         |
|  - Earn GFT         |                         |
+---------------------+                         |
                                                |
                    +---------------------------+
                    |
                    v
           +----------------------+
           |   Token Ledger       |
           | - GFT balances       |
           | - Hash-chained log   |
           +----------------------+

Paper

imece: A FLOP-Based Token Framework for Decentralized AI Access Aslan Kose — Independent Researcher arXiv preprint — to be submitted upon public release of this codebase

Status

• Framework design and specification complete
• Academic paper drafted
• Coordination Layer — FastAPI + PostgreSQL
• Token Ledger — hash-chained, tamper-evident
• Hardware multiplier system — 8 tiers with interpolation
• Grid-aware scheduler — P_grid formula
• Shard registry + pipeline scheduler
• Distributed inference pipeline — custom layer sharding proven
• Auto-reconnect on coordinator restart
• Inference challenge verification + reliability factor
• Test suite — 52 passing tests
• Contributor client — cross-platform, simulation + production mode
• Public beta release
• Real model weights — load HuggingFace models on volunteer nodes (community)
• Fallback inference integration — Groq-based centralized fallback implemented

Contributing

We welcome community contributions, particularly:

• Real model serving — integrate torch + transformers for 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() within coordination/api/inference.py. 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.

Please open an Issue to discuss before submitting a pull request.

License

MIT License

Author

Aslan Kose — IT professional, independent researcher GitHub: @jstdv

imece emerged from a conviction that the communities bearing the cost of AI infrastructure should also be empowered to benefit from it.