Turn your idle PC into a node of the distributed LLM network. One-liner install on Linux/macOS, one download on Windows.
Why ? Without workers, there is no network. Every CPU or GPU joining brings more capacity, lower latency, better model coverage. Your machine earns community credits ($IAMINE) proportional to the compute it actually delivers.
Zero config. The worker auto-detects your hardware (CPU / GPU / RAM), picks the right GGUF model from the Cellule catalog (Qwen 2B / 4B / 30B MoE), downloads it, and joins the network. Best for anyone who just wants to contribute idle compute without touching an LLM stack.
python -m iamine worker --autoBring your own LLM. If you already run llama-server, Ollama, LocalAI, vLLM... the proxy forwards inference to YOUR endpoint instead of downloading a new model. You control which model runs, on which port, with which quantization. Read the full guide before launching.
python -m iamine proxy --upstream http://localhost:8000The OS guides below cover the Worker (default) flow. If you want the proxy mode, same OS tabs apply for installing iamine-ai; only the final launch command changes.
curl -sSL https://cellule.ai/install-worker.sh | bashThe installer detects your distro, checks Python 3.12+, creates a user-local venv at ~/.cellule-worker, installs iamine-ai, and sets up a systemd --user service so the worker survives reboots.
~/.cellule-worker venviamine-ai from https://cellule.ai/pypi~/.config/systemd/user/cellule-worker.servicepython3.12 -m venv ~/.cellule-worker
source ~/.cellule-worker/bin/activate
pip install --upgrade pip
pip install iamine-ai -i https://cellule.ai/pypi --extra-index-url https://pypi.org/simple
python -m iamine worker --auto# Status
systemctl --user status cellule-worker
# Live logs
journalctl --user -u cellule-worker -f
# Restart
systemctl --user restart cellule-worker
# Stop + disable
systemctl --user disable --now cellule-workerThe default install ships CPU-only llama-cpp-python. For GPU, rebuild with the right flags:
# NVIDIA CUDA
CMAKE_ARGS="-DGGML_CUDA=on" ~/.cellule-worker/bin/pip install --force-reinstall --no-binary=:all: llama-cpp-python
# AMD ROCm
CMAKE_ARGS="-DGGML_HIPBLAS=on" ~/.cellule-worker/bin/pip install --force-reinstall --no-binary=:all: llama-cpp-pythoncurl -sSL https://cellule.ai/install-worker.sh | bashSame installer as Linux — detects macOS, creates ~/.cellule-worker, and installs a launchd agent at ~/Library/LaunchAgents/ai.cellule.worker.plist so the worker auto-starts at login.
llama-cpp-python ships with Metal support on macOS.
brew install [email protected] if missingbrew install [email protected]
python3.12 -m venv ~/.cellule-worker
~/.cellule-worker/bin/pip install --upgrade pip
~/.cellule-worker/bin/pip install iamine-ai -i https://cellule.ai/pypi --extra-index-url https://pypi.org/simple
~/.cellule-worker/bin/python -m iamine worker --auto# Status
launchctl list | grep cellule
# Live logs
tail -f ~/.cellule-worker/worker.log
# Stop
launchctl unload ~/Library/LaunchAgents/ai.cellule.worker.plist
# Start again
launchctl load ~/Library/LaunchAgents/ai.cellule.worker.plistDownload the ZIP for your variant, right-click → Properties → Unblock (SmartScreen), extract the folder anywhere, and double-click the .exe inside. See full release.
Extract the ZIP anywhere. Inside the folder you'll find cellule-worker-cpu.exe (or cuda/proxy) plus an _internal folder of dependencies. Double-click the .exe. The folder stays self-contained — you can move or copy it, just keep the structure.
assigned_model.json and config.json in the exe's folder (or wherever you launched from), relaunch..exe — PREPROD / BETA to testThree pre-built ZIP archives are published to GitHub Releases. Each contains the .exe plus its dependencies in a self-contained folder. PREPROD — please report any issue you hit.
| Variant | For | Size | Typical speed |
|---|---|---|---|
cellule-worker-cpu.zip |
Any Windows PC (no GPU required) | ~47 MB | 5–15 t/s on modern CPUs (Qwen 2B–4B) |
cellule-worker-cuda.zip |
Windows PC with NVIDIA GPU (CUDA 12+) | ~300–500 MB | 50–200 t/s on NVIDIA RTX (Qwen 4B–14B) |
cellule-proxy.zip |
You already run your own LLM (llama-server / Ollama / vLLM / LocalAI) | ~15–25 MB | Depends on your upstream LLM (you bring it) |
Installation steps (both variants):
.zip from GitHub Releases..exe — the worker benches your hardware, picks a model, and joins the network automatically..github/workflows/build-worker-exe.yml — 100% reproducible. If you prefer, use Option B (pip) below to install from source yourself.
Open PowerShell (not cmd.exe) and run:
# Install Python 3.12 first if missing — winget install Python.Python.3.12
py -3.12 -m venv "$env:USERPROFILE\.cellule-worker"
& "$env:USERPROFILE\.cellule-worker\Scripts\pip.exe" install --upgrade pip
& "$env:USERPROFILE\.cellule-worker\Scripts\pip.exe" install iamine-ai -i https://cellule.ai/pypi --extra-index-url https://pypi.org/simple
& "$env:USERPROFILE\.cellule-worker\Scripts\python.exe" -m iamine worker --auto# Create a scheduled task that starts the worker at logon
$action = New-ScheduledTaskAction -Execute "$env:USERPROFILE\.cellule-worker\Scripts\python.exe" -Argument "-m iamine worker --auto"
$trigger = New-ScheduledTaskTrigger -AtLogon
$settings = New-ScheduledTaskSettingsSet -StartWhenAvailable -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 2)
Register-ScheduledTask -TaskName "CelluleWorker" -Action $action -Trigger $trigger -Settings $settingswinget install Python.Python.3.12llama-cpp-python)$env:CMAKE_ARGS="-DGGML_CUDA=on"
& "$env:USERPROFILE\.cellule-worker\Scripts\pip.exe" install --force-reinstall --no-binary=:all: llama-cpp-python--auto mode: it benches your hardware (CPU, GPU, RAM, tokens/s).cellule.ai and picks the one where its capability fills a gap best (M12 placement).$IAMINE) accumulate in your account for every inference your worker completes.worker_wallet_snapshots.
| Model | RAM | Disk | Speed target (CPU) | GPU |
|---|---|---|---|---|
| Qwen 3.5 2B | 3 GB+ | 1.3 GB | 8+ t/s | optional |
| Qwen 3.5 4B | 5 GB+ | 2.7 GB | 8+ t/s | optional |
| Qwen 3.5 9B | 8 GB+ | 5.5 GB | 8+ t/s | recommended |
| Qwen 3.5 27B | 20 GB+ | 16 GB | 4+ t/s | recommended |
| Qwen 3.5 35B-A3B (MoE) | 25 GB+ | 21 GB | 4+ t/s | recommended |
Don't know your specs ? Run the worker in --auto and it picks the best fit. Too small ? It will refuse gracefully and tell you why.
Proxy mode plugs an existing OpenAI-compatible LLM server into Cellule. The pool forwards inference requests to your upstream, you earn community credits per completion served.
# 1. Start your local LLM server (example with llama.cpp)
llama-server -m /path/to/model.gguf --port 8000
# 2. In another terminal, start the Cellule proxy pointing at it
python -m iamine proxy --upstream http://localhost:8000 --model my-model-name→ Full proxy mode documentation (template, config, troubleshooting)
systemctl --user disable --now cellule-worker
rm -rf ~/.cellule-worker ~/.config/systemd/user/cellule-worker.service
systemctl --user daemon-reloadlaunchctl unload ~/Library/LaunchAgents/ai.cellule.worker.plist
rm -rf ~/.cellule-worker ~/Library/LaunchAgents/ai.cellule.worker.plistUnregister-ScheduledTask -TaskName "CelluleWorker" -Confirm:$false
Remove-Item -Recurse -Force "$env:USERPROFILE\.cellule-worker"Install the C++ build chain:
sudo apt install build-essential cmakexcode-select --installCheck logs (see "Manage the service" above). Common causes: no network to cellule.ai:443, Python version too old, firewall blocking WebSocket.
The worker only runs inferences when the network routes a job to it. Between jobs it's idle. You can cap CPU via systemd (CPUQuota=50%) or launchd (Nice = 10).
~/.cellule-worker and the OS's user-service directory. No system-wide changes without your explicit permission.← Back to homepage · Federation explained · Run your own pool · GitHub