IAMINE Pool — Live Network
Real-time view of the distributed AI network. Each node is a worker contributing compute power.
0
Workers
0
Total t/s
0
Jobs
-
Best Model
Your PC has unused power. We turn it into AI. Join the network in 60 seconds with a single command. CPU or GPU, no cloud, no hassle.
curl -sL https://iamine.org/install.sh | bash
irm https://iamine.org/install.ps1 | iex
pip install iamine-ai -i https://iamine.org/pypi --extra-index-url https://pypi.org/simple && python -m iamine worker --auto
pip install llama-cpp-python --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu124Real-time view of the distributed AI network. Each node is a worker contributing compute power.
Job distribution, credits and performance across all workers.
| Worker | Model | t/s | Jobs | Share | $IAMINE |
|---|
Every worker that joins unlocks more powerful AI. Level up together.
See what your PC can do. We find the best AI model for you.
Join the IAMINE network now with a single command:
pip install iamine-ai -i https://iamine.org/pypi --extra-index-url https://pypi.org/simple && python -m iamine worker --auto
curl -sL https://iamine.org/install.sh | bashirm https://iamine.org/install.ps1 | iexpip install iamine-ai -i https://iamine.org/pypi --extra-index-url https://pypi.org/simple
This will install IAMINE, download the optimal model for your machine, and connect to the pool automatically.
pip uninstall iamine-ai -y
del wallet.json config.json && rmdir /s /q models
Win
rm -rf wallet.json config.json models/
Linux
Your earned $IAMINE credits on the pool are preserved even after uninstall.
Contribute compute. Earn tokens. Simple.
Every AI request processed generates $IAMINE proportional to your compute.
Tradeable on DEX. Your compute power has real value.
Spend $IAMINE for premium models and priority inference.
Holders vote on models, fees, and network upgrades.
When the $IAMINE token is deployed on-chain, you will be able to export your earned tokens to any EVM-compatible wallet.
Multi-chain wallet. Add IAMINE token with one click.
The most popular Web3 wallet. Export and trade freely.
Contribute compute, earn credits. Use credits to access the AI API. 1 request served = 1 request earned.
OpenAI-compatible. Works with any client.
python -m iamine ask "What is quantum computing?"
curl https://iamine.org/v1/api/chat \
-H "Content-Type: application/json" \
-d '{"api_token":"iam_xxx","messages":[{"role":"user","content":"Hello"}]}'
import requests
r = requests.post("https://iamine.org/v1/api/chat", json={
"api_token": "iam_xxx",
"messages": [{"role": "user", "content": "Hello"}]
})
print(r.json()["choices"][0]["message"]["content"])
Use IAMINE as a backend for Open WebUI. Copy these settings:
| API Base URL | https://iamine.org/v1 |
| API Key | iam_YOUR_TOKEN |
docker run -d -p 3000:8080 \
-e OPENAI_API_BASE_URL=https://iamine.org/v1 \
-e OPENAI_API_KEY=iam_YOUR_TOKEN_HERE \
--name open-webui \
ghcr.io/open-webui/open-webui:main| Endpoint | Method | Description | Auth |
|---|---|---|---|
| /v1/chat/completions | POST | OpenAI-compatible chat (auto conv_id) | Bearer token |
| /v1/messages | POST | Anthropic-compatible (Claude Code) | x-api-key |
| /v1/api/chat | POST | Chat (1 credit/request) | api_token |
| /v1/status | GET | Pool status | - |
| /v1/pool/power | GET | Pool power analysis | - |
| /v1/wallet/{token} | GET | Check balance | token in URL |
| /v1/models/available | GET | List server models | - |
| /v1/models | GET | List worker models | - |
| /v1/admin/models | GET | Model tiers + unlock status | - |
Start a worker on this machine to see it here, or log in to manage multiple workers.
curl -sL https://iamine.org/install.sh | bash
irm https://iamine.org/install.ps1 | iex— or —
Use IAMINE with your favorite tools. The API is OpenAI-compatible.
Use OpenCode as an AI coding agent in your terminal, powered by the IAMINE network. Reads files, writes code, runs commands — all via the distributed pool.
npm install -g opencode-ai@latest
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"iamine": {
"npm": "@ai-sdk/openai-compatible",
"name": "IAMINE Pool",
"options": {
"baseURL": "https://iamine.org/v1",
"apiKey": "{env:IAMINE_API_KEY}"
},
"models": {
"iamine": {
"name": "IAMINE Smart Pool",
"limit": { "context": 131072, "output": 4096 }
}
}
}
}
}
export IAMINE_API_KEY=iam_YOUR_TOKEN
opencode
$env:IAMINE_API_KEY = "iam_YOUR_TOKEN"
opencode
# My Project
## Backend
Tu tournes sur le pool distribue IAMINE.
Tu as un contexte illimite (L1/L2/L3).
## Regles
- Ecris du Python propre avec type hints
- Utilise write pour creer des fichiers
- Reponds en francais
/iamine
— Bootstrap and initialize a project
cd my-project && iamine init
Downloads the OPENCODE.md template from iamine.org with a confirmation prompt. Add -y to skip confirmation.
/iamine A note manager in Python with SQLite, tags and markdown export
The IAMINE pool generates optimized SPEC.md and OPENCODE.md for your project. Then say: "Read SPEC.md and start development".
Connect Open WebUI to the IAMINE network for a ChatGPT-like interface.
docker run -d -p 3000:8080 \
-e OPENAI_API_BASE_URL=https://iamine.org/v1 \
-e OPENAI_API_KEY=iam_YOUR_TOKEN \
--name open-webui \
ghcr.io/open-webui/open-webui:main
iamine — the pool handles smart routing. Memory commands (save, restore, remember) work directly in the Open WebUI chat.All tools below benefit from IAMINE's L1/L2/L3 compaction — your conversations are never lost, even across sessions. The pool manages memory server-side via PostgreSQL.
No configuration needed. Just connect any OpenAI-compatible client and get unlimited context automatically.
The pool automatically injects a "think" tool into conversations. When Scout (9B, fast) encounters a complex task, it delegates to a larger model (30B+) transparently. You get the best of both worlds: speed for simple questions, depth for hard ones.
think toolIAMINE supports persistent memory commands in any connected client. Your conversations and personal facts are saved server-side with AES encryption.
| Command | Alias | Effect |
|---|---|---|
enregistre |
save |
Saves the current conversation to your account |
restaure |
restore |
Lists and loads saved conversations |
souviens-toi |
remember |
Memorizes personal facts in the RAG (retrieved automatically) |
Use Cursor IDE with IAMINE as the AI backend.
| API Key | iam_YOUR_TOKEN |
| Override URL | https://iamine.org/v1 |
| Model | iamine |
Generate optimized SPEC.md and OPENCODE.md files for your project. The pool AI creates a complete project blueprint ready for OpenCode, Cursor, or aider.
Use aider for AI pair programming with IAMINE.
export OPENAI_API_BASE=https://iamine.org/v1
export OPENAI_API_KEY=iam_YOUR_TOKEN
aider --model openai/iamine
$env:OPENAI_API_BASE = "https://iamine.org/v1"
$env:OPENAI_API_KEY = "iam_YOUR_TOKEN"
aider --model openai/iamine
Add IAMINE as a provider in Continue.
{
"models": [{
"title": "IAMINE Pool",
"provider": "openai",
"model": "iamine",
"apiBase": "https://iamine.org/v1",
"apiKey": "iam_YOUR_TOKEN"
}]
}
from openai import OpenAI
client = OpenAI(
base_url="https://iamine.org/v1",
api_key="iam_YOUR_TOKEN"
)
response = client.chat.completions.create(
model="iamine",
messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)
curl https://iamine.org/v1/api/chat \
-H "Content-Type: application/json" \
-d '{
"api_token": "iam_YOUR_TOKEN",
"messages": [{"role": "user", "content": "Hello!"}]
}'
# Check balance
python -m iamine wallet
# Ask a question (costs 1+ $IAMINE)
python -m iamine ask "What is quantum computing?"
# See recommended model for your machine
python -m iamine recommend
Turn your smartphone into an AI worker. Scan the QR code to pair your phone with your IAMINE account.
IAMINE is a decentralized AI inference network that transforms idle computing power into a shared artificial intelligence resource. By contributing CPU cycles, participants earn $IAMINE tokens proportional to their compute contribution. These tokens can be spent to access AI models more powerful than any single participant could run locally. The network uses smart routing to optimally match requests to workers based on context size, model capability, and performance.
Access to powerful AI is concentrated in the hands of a few corporations. Running a high-quality language model requires expensive hardware (GPUs, large RAM) that most people don't have. Meanwhile, billions of PCs sit idle with unused CPU cycles. The current AI economy extracts value from users (their data, their attention) without giving back. There is no way for individuals to participate in the AI economy as producers, only as consumers.
IAMINE inverts the model: anyone with a PC becomes an AI provider. The network consists of three components:
The core innovation of IAMINE is its intelligent request routing. Unlike simple round-robin load balancers, IAMINE considers:
IAMINE simulates infinite conversation memory through a 3-level compaction system. Account holders get encrypted persistent memory — no conversation limit, zero data leaks.
When context fills up, old messages are summarized and archived. The summary is re-summarized when it grows (meta-compaction). Archived data is AES-encrypted with a key derived from your account token — even database administrators cannot read your conversations. Everything is deleted when the session expires. The result: talk for hours without losing context, with end-to-end privacy.
Workers cooperate through the pool. When a conversation needs compaction, the pool delegates the summarization to an idle worker — freeing the main worker to keep serving the user. The pool acts as a trust broker: it knows every worker, their capabilities, and their state. Workers don't need to trust each other directly — they trust the pool.
The $IAMINE token creates a self-sustaining economy:
| Model | Earn (serve 100 tokens) | Cost (use per request) |
|---|---|---|
| Qwen 0.5B | +0.5 $IAMINE | 1 $IAMINE |
| Qwen 1.5B | +1.0 | 2 |
| Qwen 3B | +2.0 | 3 |
| Qwen 7B | +4.0 | 5 |
| Qwen 14B | +8.0 | 15 |
| Qwen 32B | +15.0 | 30 |
| Qwen 72B | +25.0 | 50 |
Larger models cost more to use but earn more for workers who serve them. This incentivizes participants to upgrade their hardware, strengthening the network.
Every 30 seconds, the pool randomly rewards an online worker with 0.5 to 3 $IAMINE. Rare bonus drops (5-15) and jackpots (20-50) keep the excitement alive. The longer you stay online, the more chances you get. New workers receive a 500 $IAMINE welcome bonus on first connection.
As the network grows, larger models become available — but they require workers with sufficient resources (RAM, compute) to run them. The pool tracks total power and worker capabilities to determine which models can be served. This creates a virtuous cycle: powerful workers unlock premium models and earn more tokens.
IAMINE takes privacy seriously. Free demo users get ephemeral conversations in RAM only — zero persistence. Account holders benefit from L3 encrypted archives: conversation history is AES-encrypted with a key derived from your personal account token. Even server administrators cannot read your data. All conversation data (L1, L2, L3) is automatically purged after 1 hour of inactivity. No logs, no training on user data. Workers process requests in real-time and do not persist any content.
--auto.