> For the complete documentation index, see [llms.txt](https://docs.robinmesh.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.robinmesh.com/providers/native-worker.md).

# Native Worker

`robinmesh-node` is a single Rust binary that does everything a serious provider needs: it drives your GPU backend, fetches model weights, works the job queue, and talks to the settlement contracts on-chain.

Compared with the browser tier, native workers serve much larger models and earn more per job. Add an active $RMESH stake and each completed job pays out at 85% of its credit value.

***

## What you need

| Requirement     | Details                                                                                  |
| --------------- | ---------------------------------------------------------------------------------------- |
| OS              | Linux (recommended), macOS, Windows                                                      |
| GPU             | NVIDIA (CUDA), Apple Silicon (Metal), or AMD (ROCm)                                      |
| VRAM            | 8GB at minimum, enough for the smallest native-tier models                               |
| Ethereum wallet | Needed to register and to receive USDG (MetaMask, Rabby, or Robinhood Wallet)            |
| Disk            | 50GB+ free for weights; a 70B model alone takes \~40GB                                   |
| Network         | A stable link. The closer you are to users latency-wise, the better for your reputation. |

***

## Installing the daemon

### Linux (CUDA)

```bash
curl -sSL https://install.robinmesh.com | bash
```

The script fetches `robinmesh-node` along with the CUDA backend, checking your NVIDIA driver version first so it can pick the matching binary variant.

Confirm the install:

```bash
robinmesh-node --version
# robinmesh-node 0.1.0 (cuda-12.4)
```

### macOS (Apple Silicon)

```bash
curl -sSL https://install.robinmesh.com/mac | bash
```

On macOS the node runs Metal through llama.cpp, and every Apple Silicon generation (M1 through M4) works. Because the chip's unified memory is addressed directly, a 36GB M3 Max has plenty of room for 27B parameter models.

### Windows (CUDA)

Grab the installer from `robinmesh.com/downloads` and run the `.exe`. It places `robinmesh-node` on your PATH and sets up the CUDA backend for you.

### AMD (ROCm)

```bash
curl -sSL https://install.robinmesh.com/rocm | bash
```

You need ROCm 5.6 or later, on RDNA 2 hardware (RX 6000 series) or newer.

***

## Bringing a node online

### Step 1: Register

```bash
robinmesh-node register --wallet <your-ethereum-wallet-address>
```

Registration does three things:

* generates a keypair for the node itself, distinct from your wallet
* sends a registration transaction to the `worker_registry` contract
* has your wallet sign that registration

Your wallet will ask you to approve the transaction (delivered by QR code or deeplink).

The node's keypair lands in `~/.robinmesh/worker.json`. Keep a backup: this key signs every proof-of-completion you submit, and your on-chain reputation is bound to it.

### Step 2: Add models

```bash
robinmesh-node models list    # browse the catalog
robinmesh-node models add qwen3-8b
robinmesh-node models add llama-3.3-70b
```

Weights come down from the RobinMesh model registry into `~/.robinmesh/models/`. Every download is checked against a SHA-256 checksum before the model joins your serving list.

Want the VRAM footprint before committing to a download? Ask for the model info:

```bash
robinmesh-node models info llama-3.3-70b
# Model: llama-3.3-70b
# Parameters: 70B
# Format: GGUF Q4_K_M
# VRAM required: 43GB
# Tier: Max
# Earnings per job: $0.300 (unstaked) / $0.340 (staked)
```

### Step 3: Stake $RMESH (optional, worth doing)

You can earn without staking, but a stake gets you the 85% payout rate plus elevated routing priority. The full walkthrough lives in the \[Staking guide]\(

).

### Step 4: Run it

```bash
robinmesh-node start
```

On startup the node:

1. loads your chosen models into GPU memory
2. advertises its capabilities to the orchestrator mesh
3. starts pulling jobs
4. prints each completion and its earnings to the terminal

For unattended operation on Linux, install it as a service:

```bash
robinmesh-node install-service
systemctl enable robinmesh-node
systemctl start robinmesh-node
```

***

## Configuration

Everything lives in `~/.robinmesh/config.toml`.

```toml
[node]
wallet = "0x7c41f9b8d2a6e3054cf18a9b62d47e0c93f5a1b8"
worker_keypair = "~/.robinmesh/worker.json"

[models]
# Models loaded when the node starts
active = ["qwen3-8b", "mistral-7b"]

[gpu]
# Detected from your hardware automatically; set explicitly to override.
# Valid values: cuda, metal, rocm
backend = "cuda"
# Upper bound on the share of VRAM robinmesh-node may claim
vram_limit = 0.85

[networking]
# Listening port for inbound orchestrator connections
port = 8765
# Set manually if public IP detection gets it wrong
# public_ip = "1.2.3.4"

[logging]
level = "info"
# Also write logs here, in addition to stdout
file = "~/.robinmesh/logs/node.log"
```

***

## Watching your node

While the node runs, a local dashboard serves at `http://localhost:3001` with:

* current jobs and how deep the queue is
* hourly earnings and lifetime USDG
* GPU utilization and VRAM consumption
* your on-chain reputation score
* job counts and latency broken down per model

The same node exposes a local status API:

```bash
curl http://localhost:3001/status | jq
```

```json
{
  "status": "running",
  "wallet": "0x7c41f9b8d2a6e3054cf18a9b62d47e0c93f5a1b8",
  "active_models": ["qwen3-8b", "mistral-7b"],
  "jobs_completed_24h": 342,
  "usdg_earned_24h": 27.36,
  "reputation_score": 847,
  "stake_active": true,
  "payout_rate": "85%"
}
```

***

## Upgrading

```bash
robinmesh-node update
```

This pulls the newest binary and swaps it in place of the old one. Nodes running as a service get restarted automatically once the swap completes.

Existing model weights survive upgrades; a re-download is only needed if a new model format version ships.

***

## Choosing hardware

| GPU                              | VRAM  | Recommended models                  | Estimated earnings / hour |
| -------------------------------- | ----- | ----------------------------------- | ------------------------- |
| RTX 3060                         | 12GB  | Qwen3 8B, Mistral 7B                | $0.15 to $0.30            |
| RTX 3090 / 4090                  | 24GB  | Qwen3 8B, Mistral 7B, Llama 3.2 13B | $0.40 to $0.80            |
| 2x RTX 3090 (multi-GPU, Q1 2027) | 48GB  | Llama 3.3 70B, DeepSeek R1          | $1.50 to $3.00            |
| M2 Max 38GPU                     | 32GB  | Qwen3 8B, Llama 3.2 27B             | $0.50 to $1.00            |
| M3 Ultra 76GPU                   | 128GB | Llama 3.3 70B, DeepSeek R1          | $1.50 to $3.00            |
| A100 80GB                        | 80GB  | All models                          | $2.00 to $4.00            |

These figures assume a steady stream of jobs. What you actually earn moves with network demand, which models you host, and where your reputation score sits.

{: .note } Pooling two or more GPUs under one node is planned for Q1 2027. Until then, each node drives exactly one GPU.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.robinmesh.com/providers/native-worker.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
