Run a node

Join the swarm

One GPU, one stage of the model. If you can run a 16 GB consumer card on a home connection, you can help pretrain a large language model and earn points for verified work. ESC trading fees pay the nodes; stake e/acc to run one.

Stake & register →

Minimum stake

Target: about $300, within a $200–600 band, kept there by rules-based re-pegs of min_stake. Re-pegs are planned, not live.

Hardware

Pick your tier

Tiers follow the open-source Node0 client this network runs. The coordinator checks your hardware against the run's tier when you connect.

llama_8B_Cmain run

Full GPU

LLaMA-8B shape · d=4096 · 1 block per stage · 32 stages

›NVIDIA GPU, 16 GB+ VRAM (RTX 3090 / 4080 / 4090 class or better)
›32 GB system RAM
›80 GB free disk (Docker image)
›Linux, or Windows with WSL2 + CUDA

The network's production tier. Activations cross stage boundaries 100× compressed.

llama_1B_Csmall GPUs

Entry GPU

LLaMA-1B shape · d=2048 · 2 blocks per stage · 8 stages

›NVIDIA GPU, 8 GB+ VRAM
›16 GB system RAM
›Linux or WSL2

Same recipe at a size that fits older and laptop GPUs.

laptop_demolocal / CI

Laptop demo

Tiny LLaMA · d=256 · byte vocabulary · 2 stages

›Apple Silicon (MPS) or any CPU
›8 GB RAM
›No GPU needed

For trying the full stake → train → settle → claim loop locally.

All tiers: Python 3.11 or Docker, one GPU per node, an open TCP port.

Setup

Four steps to a training node

01
Get e/acc
Hold at least min_stake e/acc (the program's min_stake: 50,000 in production, 10,000 on localnet) in a wallet you control. On mainnet it trades on PumpSwap; localnet bootstrap mints test tokens to each node owner. Use a dedicated wallet, not your savings.
02
Create a node hot key
On the GPU machine, generate a fresh Solana keypair. It only signs the coordinator's auth challenge and never holds funds, so a compromised machine can't move your stake.
shell
```
$ solana-keygen new --no-bip39-passphrase -o ~/.config/solana/eacc-hot.json
$ solana-keygen pubkey ~/.config/solana/eacc-hot.json
```
03
Register & stake
From your wallet, register the hot key and stake at least min_stake on the Stake page, or with the CLI (dry-run unless --live).
shell
```
$ swarmctl register --node-key <HOT_KEY_PUBKEY>
$ swarmctl stake --amount <MIN_STAKE>
```

Run the node

Generate the start script and launch it. The node signs a nonce with its hot key; the coordinator checks your NodeAccount on-chain and admits it to the stage that needs capacity most.

on the GPU machine

$ git clone <eacc-swarm repo> && cd eacc-swarm/node
# writes start_server.sh; add --use_docker to run in Docker
$ python3 generate_script.py --keypair ~/.config/solana/eacc-hot.json --owner <OWNER_WALLET_PUBKEY> \
$   --coordinator_url https://coordinator.152-42-151-246.sslip.io --host_port 31330 --announce_port 31330
$ ./start_server.sh

Connect a wallet to pre-fill your owner address. The hot key file stays on the GPU machine; the owner wallet never does.

Check it's working

Watch run.out (Docker) or logs/server.log. A healthy node logs a successful authorization, downloads its stage's state from a peer, then reports processed batches and averaging rounds with other peers. It shows up on the Network page within a few minutes.

Lifecycle

What happens after you start

01
Authorize
Hot-key signature verified; stake, status and pause flag checked on-chain.
02
Assign
Placed on the least-provisioned stage; a returning node keeps its stage.
03
Sync
Downloads the current weights for its stage from same-stage peers.
04
Train
Receives microbatches, sends compressed activations forward and gradients back.
05
Earn
Attested work and online time become points; spot checks keep them honest.

FAQ

Questions node runners ask

Still stuck? The node logs and the Network page usually tell you which step failed.

Before you stake

Staked e/acc is locked during unbonding (14 days in production), exposed to the token's price, and can be slashed if your node fails verification. Rewards depend entirely on trading-fee income and can be zero. Only stake what you can afford to lose, from a dedicated hot wallet.