CELLULE.AI

Decentralized AI, powered by the community. Share your compute power. Join the network.

--
Workers Online
--
Tokens / sec
--
Jobs Completed

Why Cellule.ai?


🧠

Cross-Session Memory

Your conversations follow you via API. Unique on the LLM market. Save, restore, delete — from any tool.

💻

Multi-Platform

Windows, Linux, macOS. CPU and GPU. From your laptop to your server.

🌐

Heterogeneous Pool

Models from 0.8B to 35B cooperate. The small one is fast, the big one is smart.

🔒

Privacy First

Zero-knowledge encryption. Opt-in memory. GDPR compliant.

🔌

OpenAI Compatible

Works with OpenCode, Cursor, aider, Open WebUI, and any compatible tool.

Unique on the LLM market

Your conversations follow you


Most LLM providers give you a stateless API. Cellule.ai persists your conversations server-side and lets you save, restore, or delete them from any client — OpenWebUI, Cursor, OpenCode, curl, whatever. Your context lives in the molecule, not in the client.

💾

Save

save / enregistre

Persist the current conversation in your account. Works in any chat client.

🔄

Restore

restore / restaure <num>

Bring back a saved conversation. List with restaure, then pick one by number or ID.

🗑️

Delete

delete / supprime <num|all>

Remove one conversation or all at once. Opt-in memory + GDPR compliant.

These commands work inside any chat, across any tool that talks to cellule.ai/v1. Type save / enregistre in OpenWebUI, then open Cursor tomorrow and type restaure — your context is there.

Agent Memory

Your agents learn and remember


Every coding session builds knowledge. Cellule.ai captures observations, consolidates them into episodes, extracts durable facts, and detects workflow patterns. Your agent gets smarter with every interaction — across sessions, across pools.

T1

Observations

Every inference, code review, and tool call is captured automatically. Zero effort.

T2

Episodes

Observations consolidate into session summaries. What you did, what worked, what failed.

T3

Semantic Facts

Durable knowledge extracted from episodes: preferences, patterns, architecture decisions. Linked by a relationship graph.

T4

Procedures

Recurring workflow patterns detected automatically. Your agent knows what works before you ask.

🔍

Hybrid Retrieval

Vector similarity + relationship graph + procedural matching. Stale memories fade with Ebbinghaus decay. Frequently used ones strengthen.

🔗

MCP Compatible

Any MCP-compatible agent (Claude Code, OpenCode, Cursor) plugs into the collective memory. One command: iamine mcp-server

🛡️

Zero-Knowledge

All content encrypted with your token (PBKDF2 + Fernet). The pool stores your memories but cannot read them. GDPR delete across the federation.

Memory syncs across federated pools. Move between pools, your knowledge follows. Like RAID for intelligence.

How it works


Contribute

Install in 60 seconds. Your CPU or GPU serves an AI model to the network.

Participate

Your compute powers the network. $IAMINE tokens track your contribution — not yet deployed, coming in alpha.

Use

Spend your tokens to access models your PC could never run. 30B+ models at your fingertips.

Live Network


--
Workers Online
--
Total t/s
--
Models Available
--
Uptime

Federated Pools

Loading federated network…

Build with Cellule.ai


OpenAI-compatible API. Use OpenCode, Cursor, or any tool. The pool handles routing, tool-calls, and think delegation automatically.

22+ t/s Native tool-calls Think tool
Get started
opencode — cellule.ai

Compatible tools


L'API Cellule.ai est compatible OpenAI. Utilisez votre outil de coding favori avec smart routing, mémoire persistante et tool-calls natifs.

Cellule.ai API config
base_url https://cellule.ai/v1 api_key acc_YOUR_TOKEN model iamine/auto
API OpenAI-compatible. Pointez n'importe quel outil ci-dessous sur ces 3 params.

ClawCode

Open-source Claude Code rewrite in Rust. Model-agnostic CLI agent.

cargo install agent-code
pip install iamine-ai -i https://cellule.ai/pypi --extra-index-url https://pypi.org/simple
iamine init clawcode --token acc_YOUR_TOKEN
Setup
1. iamine init clawcode --token acc_xxx
2. Launch agent and describe what you want to build
3. Code directly — no slash command needed — Cellule.ai is your backend
claw-code.io →

Cursor

VS Code-based AI IDE. Override the API URL to use Cellule.ai as your backend.

https://cellule.ai/v1
acc_YOUR_TOKEN
iamine
Setup
1. Cursor Settings → Models → OpenAI API Key
2. Paste your token + Override URL + Model name
3. Start coding — Cellule.ai handles the rest
tools_aider_step1: "1. Install aider + set your token as env variable", tools_aider_step2: "2. Launch aider with Cellule.ai as backend", tools_aider_step3: "3. Start coding — git commits are handled automatically",
cursor.com →

aider

Git-based CLI pair-programming. Very efficient for refactoring and targeted fixes.

pip install aider-chat
export OPENAI_API_KEY=acc_YOUR_TOKEN
aider --model openai/iamine --openai-api-base https://cellule.ai/v1
Setup
1. Install aider + set your token as env variable
2. Launch aider with Cellule.ai as backend
3. Start coding — git commits are handled automatically
aider.chat →

Continue.dev

Extension VS Code et JetBrains pour completion et chat IA dans l'IDE.

continue.dev
continue.dev →

Open WebUI

Interface web complete self-hosted. Chat multi-conversations, historique, templates. Compatible OpenAI.

openwebui.com
⚠ Settings → Interface → disable Title Auto-Generation (et Tags Auto-Generation) pour éviter les JSON fuits dans le chat.
openwebui.com →

On recrute


Chaque pool analyse en temps reel ses capacites et detecte automatiquement ses lacunes.

Comment ca marche ? Quand vous lancez un worker avec iamine worker --auto, il interroge les pools du reseau, evalue ou il sera le plus utile, et rejoint automatiquement le pool qui a le plus besoin de ses capacites. Un worker qui comble un manque critique recoit naturellement plus de jobs — et gagne plus de $IAMINE. Si un pool tombe, les workers migrent automatiquement vers un pool compatible. Chaque pool vise l’autosuffisance : pouvoir traiter 100% des requetes sans dependre d’un autre pool.

Analyse des besoins du reseau...
Rejoindre le reseau
EARLY ACCESS — ALPHA

$IAMINE

Contribuez votre puissance de calcul. Gagnez des tokens. Token pas encore deploye on-chain.

Projet en developpement actif. Les fonctionnalites token ci-dessous sont des previews — rien n'est encore deploye sur blockchain.

+

Participate

Every AI request you serve is tracked. $IAMINE tokens will reflect your contribution to the network.

~

Trade

When deployed, tokens will be transferable. Your participation has value within the network.

*

Use

Use $IAMINE tokens to access network resources and vote on its direction.

%

Govern

Les detenteurs votent sur les modeles, frais et evolutions du reseau.

Exporter vers votre wallet Preview

Quand le token $IAMINE sera deploye on-chain, vous pourrez exporter vos tokens gagnes vers n'importe quel wallet compatible EVM.

🦊

Rabby Wallet

Wallet multi-chain. Ajoutez le token \ en un clic.

🔶

MetaMask

Le wallet Web3 le plus populaire. Exportez et tradez librement.

Comment ca marchera :
1Connectez votre wallet (Rabby, MetaMask, ou n'importe quel wallet EVM)
2Entrez votre token API (acc_xxx) pour verifier votre solde
3Choisissez le montant a exporter et confirmez la transaction
Les tokens $IAMINE apparaissent dans votre wallet — tradez sur n'importe quel DEX
Le contrat du token sera publie ici apres deploiement.
Chain: TBD (Hyperliquid / Base / Arbitrum) · Standard: ERC-20 · Supply: proportionnel au compute du reseau

API Reference


100% compatible OpenAI. Drop-in replacement: changez la baseURL de votre client et c'est parti.

Base URL
https://cellule.ai/v1
POST/chat/completions

Inference OpenAI-compatible avec smart routing, mémoire persistante L1/L2/L3 et tool-calls natifs.

curl https://cellule.ai/v1/chat/completions \
  -H "Authorization: Bearer acc_xxx" \
  -d '{"model":"iamine","messages":[{"role":"user","content":"hi"}]}'
GET/models

Liste les modeles disponibles. Renvoie {id: iamine} (smart routing automatique cote pool).

curl https://cellule.ai/v1/models \
  -H "Authorization: Bearer acc_xxx"
GET/account/my-workers

Solde, credits, total gagne et liste de tes workers lies au compte.

curl https://cellule.ai/v1/account/my-workers \
  ?session_id=YOUR_SESSION
POST/account/memory

Active/desactive la memoire persistante (opt-in). RGPD compliant, droit a l oubli inclus.

curl -X POST https://cellule.ai/v1/account/memory \
  -d '{"session_id":"xxx","enabled":true}'
Full Swagger Documentation →

Start earning in 2 minutes


EARLY ACCESS — ALPHA

Le reseau s’adapte a votre materiel. Que vous ayez un laptop ou un serveur GPU, le pool vous place la ou vous etes le plus utile.

PLUG & PLAY

Mode Auto

Une commande. Le reseau detecte votre materiel, telecharge le meilleur modele, et vous place automatiquement dans le pool qui a le plus besoin de vous.

pip install iamine-ai -i https://cellule.ai/pypi --extra-index-url https://pypi.org/simple && python -m iamine worker --auto
Auto-detection Auto-update Smart placement
AVANCE

Mode Proxy

Vous gerez vos propres LLM (llama-server, vLLM, Ollama). Le reseau route le trafic vers vos backends. Ideal pour les power users avec du materiel deja configure.

pip install iamine-ai -i https://cellule.ai/pypi --extra-index-url https://pypi.org/simple && python -m iamine proxy -c proxy.json
Multi-backend Full control GPU optimized
Full proxy guide →

Minimum

4 GB RAM, any CPU

~0.5 $IAMINE/min

Power

32+ GB RAM, GPU

~25 $IAMINE/min
Join the network
OR

Run your own pool

Once the worker base grows, run your own pool to host workers and federate with the molecule. 3 minutes via docker compose.

docker compose tutorial →

Cellule.ai — Try it

6 messages remaining
AI belongs to those who run it. 6 messages to try — no account needed. Create an account to join the network.