Executive Summary

IAMINE is a decentralized AI network where anyone can contribute computing power — CPU or GPU — to run LLM inference and earn $IAMINE tokens.

Unlike centralized AI services that lock inference behind expensive APIs and proprietary infrastructure, IAMINE distributes inference across heterogeneous machines worldwide. A laptop with 4 GB of RAM and a server with 64 GB of VRAM cooperate in the same pool, each running the model best suited to their hardware.

The Problem

The current AI landscape suffers from fundamental structural issues:

• Centralization: AI inference is controlled by a handful of corporations (OpenAI, Anthropic, Google). They set the prices, the rules, and the limits.
• GPU scarcity: Access to high-end GPUs is expensive and limited. Cloud GPU pricing is prohibitive for individuals and small teams.
• Wasted compute: Millions of machines sit idle worldwide — gaming PCs, workstations, servers — with no way to monetize their unused computing power.
• Privacy concerns: Every prompt sent to a centralized service is logged, stored, and potentially used for training. Users have no control over their data.
• Single points of failure: When a centralized service goes down, every user is affected. There is no redundancy, no fallback.

The Solution — IAMINE Network

IAMINE solves these problems with an open-source, distributed inference pool:

• Open-source distributed pool: Workers connect via WebSocket to a coordination layer. The pool routes requests to the best available worker.
• Earn by contributing: Workers contribute CPU/GPU cycles and earn $IAMINE tokens proportional to their contribution.
• Smart routing (deficit scoring): A fair load-balancing algorithm ensures that workers with the most capacity — and the most debt to the network — get priority for incoming jobs.
• Multi-platform: Windows, Linux, macOS. Install in 60 seconds. One command.
• Heterogeneous: Models from 0.8B to 35B parameters cooperate in the same pool. The small models handle simple queries fast; the large models handle complex reasoning.
• OpenAI-compatible API: Any tool that speaks the OpenAI API can use IAMINE — OpenCode, Cursor, aider, Open WebUI, and more.

Architecture — The Atomic Model

IAMINE follows a biological evolution in three phases:

Phase 1 — The Atom (current)

One nucleus (VPS running the pool) surrounded by electrons (workers contributing compute).

Phase 2 — The Molecule (federation)

Multiple autonomous atoms that help each other. Discovery via seed list and gossip protocol. Trust established via Ed25519 challenge-response with 4 trust levels (unknown, seen, trusted, bonded). Cross-atom routing when local capacity is saturated.

Phase 3 — The Cell (organism)

Coordinated molecules with specializations: CHAT, CODE, RAG, EDGE, TRAINING. A simplified Raft consensus ensures coherence. A global capability registry enables auto-routing across molecules.

Technical Features

L1 / L2 / L3 Memory

Conversations are stored in a three-tier memory system:

• L1 (RAM): Active conversation context. Fast, ephemeral.
• L2 (Compaction): Summarized context. Reduces token count while preserving meaning.
• L3 (PostgreSQL): Persistent storage. Conversations survive server restarts, worker reassignments, and network events.

Vectorized RAG (pgvector)

Facts extracted from conversations are vectorized and stored in PostgreSQL via pgvector. Retrieval-augmented generation enriches responses with relevant prior context. All data is encrypted with zero-knowledge encryption — even the server cannot read your facts.

Native Tool-Calls

The pool natively supports OpenAI-style tool-calls. Coding agents like OpenCode, Cursor, and aider can use IAMINE as a drop-in replacement for OpenAI. File writes, code execution, and multi-step reasoning work out of the box.

Think Tool

When a small model (e.g., 9B) encounters a problem beyond its capability, it can delegate to a larger model (30B+) automatically via the think tool. The user sees a seamless response; the pool handles the orchestration.

Pool Assist (Automatic Fallback)

If all workers of a given tier are busy, the pool automatically falls back to the next available tier. The doctrine is zero-503: the network never returns an error without attempting a response.

Memory Opt-in (GDPR Compliant)

Memory is strictly opt-in. Users choose whether their conversations are persisted. When opted out, data is ephemeral and destroyed at the end of the session. Full GDPR compliance.

Economy — $IAMINE Token

The $IAMINE token is the native unit of exchange in the network. It aligns incentives between contributors and consumers.

Fair Routing via Deficit Scoring

The pool uses a deficit scoring algorithm to balance load fairly. Workers that have contributed the most compute but received the fewest jobs accumulate a "deficit" that gives them priority for the next incoming request. This ensures that no worker is starved and that the network remains balanced.

Roadmap

Getting Started

Join the network in 60 seconds. One command installs the worker and auto-detects your hardware (CPU threads, RAM, GPU) to pick the best model for your machine.

That's it. Your machine is now contributing compute to the IAMINE network and earning $IAMINE tokens.

Join the Network