Already on Ubuntu with NVIDIA drivers installed? Click below to automatically check if your machine meets the requirements — no copy-paste needed.

Runs all 10 checks on your machine instantly — no copy-paste needed. Requires the Node Builder server to be running at localhost:8185.

Download pre-filled config files. All mainnet settings are already correct — just fill in your 3 personal values and run the script. No copy-paste errors, no guessing.

Think of it as renting out your gaming PC's GPU to process AI requests. When someone uses an AI app built on Lightchain, their request gets routed to a worker node like yours. You provide the computing power, they pay in LCAI, you keep the earnings. Your computer does the work, you get paid while you sleep.

Yes — that's your stake, which is a security deposit that proves you're a serious operator. You get it back when you stop running the node. The 1 extra LCAI (above 50,000) is just to satisfy the minimum. You keep ownership of it the whole time; it's just locked while you're registered.

A gaming PC with an NVIDIA GPU (RTX 3080 or better), at least 32GB of RAM, and 100GB+ of free storage. MacBooks don't work. AMD graphics cards don't work. Most modern gaming desktops qualify — if you bought it for gaming in the last 3-4 years, there's a good chance it'll work. The GPU does the AI processing, so that's the most important part.

The official setup requires Ubuntu Linux. You can install Ubuntu as your main OS, or set up dual-boot to run Ubuntu alongside Windows (you choose at startup). Running inside a virtual machine (like VirtualBox) is NOT recommended — it can't properly access your GPU. Ubuntu is free to download and install, and it's what Step 2 of this wizard covers.

Docker is a tool that runs software in an isolated container — like a locked box that keeps the node software separate from the rest of your computer. You don't need to understand how it works. You just install it, and the wizard handles the rest. Think of it as a safe sandbox where the node lives.

Ollama is the software that runs the AI model (llama3) on your computer. When a job comes in from the network, Ollama processes it using your GPU. Think of it as a mini ChatGPT running locally on your machine. You install it, pull the model, and your node uses it to answer AI requests and earn LCAI.

A private key is the password to a crypto wallet — except it can never be changed or recovered if lost. Anyone who has it controls that wallet completely. The wizard has you generate a separate worker wallet just for the node — different from your main wallet. That way, even in the worst case, your main LCAI balance is untouchable. Write your worker private key down on paper and store it somewhere safe. Never share it. Never put it in an email or chat.

Staking means depositing LCAI as a security deposit when you register your node. This 50,001 LCAI stays locked in the contract while your node is active. You're not spending it — it's still yours. You get it back when you officially stop running the node (deregister). The stake exists so operators have skin in the game and behave reliably.

Slashing means losing part of your stake as a penalty — approximately 7,500 LCAI. This happens if you deregister your node while it still has pending jobs. The fix is simple: never deregister suddenly. If something goes wrong, restart the Docker container first. Only deregister when you're sure there are no pending jobs. The slash is rare and entirely avoidable with careful operation.

Ideally yes — your node only earns when it's online and available. Downtime means missed jobs. Two things help: a UPS (uninterruptible power supply, about $60-150) protects you during power outages, and a phone hotspot gives you backup internet if your ISP goes down. Your node can come back online after being off without losing your stake — you just don't earn while it's offline.

Each completed job pays approximately 0.016 LCAI to your node. How many jobs you get depends on your stake (more stake = higher routing priority), network traffic, and uptime. The network is still young — there are only about 13 community nodes right now. Job volume will increase as more dApps launch on Lightchain. Right now is early-adopter territory: low competition, high future upside.

The node runs inside Docker (isolated) and only talks to official Lightchain endpoints — it doesn't open any ports to the internet on its own. Your worker private key is used only for signing transactions, not for accessing your main wallet. Using a VPN as recommended adds another layer. Keep your Ubuntu system updated, don't run random scripts from strangers, and you're fine.

Most things that look like errors are actually normal. "WebSocket EOF" every hour is the auth token refreshing — completely expected. "worker_ollama_up=0" is cosmetic and doesn't affect jobs. "batch release succeeded" is actually great news (payouts processing). If you're not sure, paste the log line into the AI assistant and ask — it knows the difference between real errors and normal noise.

You use two completely separate wallets. Your funder wallet (your main wallet) holds your LCAI and sends the 50,001 stake to get the node registered. Your worker wallet is a brand new wallet you generate just for the node — it only needs a small amount of LCAI for gas fees. This way your main funds are never at risk even if something goes wrong with the node config.

A VPN routes your internet traffic through a different server, which bypasses blocks your internet provider might have in place. Some ISPs (Cox is a known one) block the connections your node needs to reach the Lightchain network. If your setup commands keep timing out or failing to connect, try Mullvad VPN first — connect it before starting your node. Not everyone needs it, but it's worth having ready.

VRAM is your GPU's dedicated memory — separate from your regular RAM. The AI model (llama3) needs about 5GB of it to run. To check how much you have, open a terminal and type: nvidia-smi. Look for the memory line (e.g. "8192 MiB"). If you have 8GB or more, you're fine. If you have other GPU-heavy apps running (like image generation software), you may need to close them to free up VRAM.

This is the #1 issue for running operators. The container may restart, but if Ollama isn't running or VPN isn't connected, jobs silently stop. Here's the one-time fix that makes your node bulletproof after any reboot:

sudo systemctl enable docker

sudo systemctl enable ollama

docker update --restart unless-stopped lcai-worker

mullvad auto-connect set on
mullvad connect

This is the most frustrating scenario — logs look healthy, container is up, but no jobs. Work through this checklist in order:

docker logs lcai-worker --tail 30 2>&1 | grep -i websocket

mullvad status

ollama list | grep llama3-8b

curl -s -X POST https://workers-api.mainnet.lightchain.ai/graphql \
  -H "Content-Type: application/json" \
  -d '{"query":"{ jobs(first:5,orderBy:submittedAt,orderDirection:desc) { id state submittedAt } }"}' | python3 -m json.tool

First, read the logs to find the real error:

docker logs lcai-worker --tail 100 2>&1

If it's disconnecting more frequently (every few minutes):

mullvad relay set location us    # try US servers
mullvad reconnect

First, check your actual stake — you may not have been slashed yet:

curl -s -X POST https://workers-api.mainnet.lightchain.ai/graphql \
  -H "Content-Type: application/json" \
  -d '{"query":"{ workers(where:{id:\"YOUR_WORKER_ADDRESS\"}) { stake offenseCount suspendedUntil } }"}' | python3 -m json.tool

Something's wrong and you need to restart everything cleanly. Run these commands in order:

mullvad connect && mullvad status

sudo systemctl start ollama
sleep 5
curl http://localhost:11434/api/tags | python3 -m json.tool

ollama cp llama3:8b llama3-8b

docker restart lcai-worker 2>/dev/null || docker restart lightchain-worker 2>/dev/null

docker logs -f lcai-worker 2>/dev/null || docker logs -f lightchain-worker 2>/dev/null

The bug: the indexer watches WorkerRegistry events but doesn't reset is_registered to true when a new WorkerJoined event follows an earlier ExitFinalized. So the API is wrong — your on-chain state is correct.