# Using the Network
Source: https://node-guide.dria.co/cli

Use the Dria CLI to run inference, batch processing, and multi-turn conversations

## Introduction

The **Dria CLI** (`@dria/cli`) lets you use the Dria decentralized inference network from the command line. Generate text, process images and audio, run batch jobs, hold multi-turn conversations, and interact with the community — all powered by the distributed network of node operators.

## Installation

```bash theme={null}
npm install -g @dria/cli
```

Or use without installing:

```bash theme={null}
npx @dria/cli generate -m qwen3.5:9b "hello"
```

<Info>Requires Node.js 18.0.0 or higher.</Info>

## Getting Started

### 1. Initialize Your Wallet

```bash theme={null}
dria init
```

This generates a new Ethereum wallet, registers it with the Dria API, and saves your config to `~/.dria/config.json`. You'll receive an API key for authenticating requests.

To import an existing wallet:

```bash theme={null}
dria init --private-key 0xYOUR_PRIVATE_KEY
```

### 2. Add Credits

```bash theme={null}
dria topup --amount 10
```

This deposits USDC credits via the x402 payment protocol (gasless EIP-712 signed transfer on Base network). Check your balance anytime:

```bash theme={null}
dria balance
```

### 3. Start Generating

```bash theme={null}
dria generate -m qwen3.5:9b "explain quantum computing in one sentence"
```

## Commands

### `dria generate`

Single-prompt text generation with streaming output.

```bash theme={null}
# Basic text generation
dria generate -m qwen3.5:9b "hello"

# Vision — describe an image
dria generate -m lfm2.5-vl:1.6b "describe this" -a image.jpg

# Audio input
dria generate -m lfm2.5-audio:1.5b "transcribe this" -a recording.wav

# Structured output with quick schema
dria generate -m qwen3.5:9b "extract name and email" --schema 'name,email'

# Structured output with typed fields
dria generate -m qwen3.5:9b "extract data" --schema 'name,email,age:integer,score:number,active:boolean'

# Structured output with JSON schema file
dria generate -m qwen3.5:9b "extract" --schema-file schema.json

# Pipe from stdin
echo "hello" | dria generate -m qwen3.5:9b

# JSON output (machine-readable)
dria generate -m qwen3.5:9b "hello" --json
```

### `dria batch`

Parallel batch generation from a JSONL file. Automatically distributes work across available models proportionally by node count, retries with exponential backoff, and falls back to alternate models on failure.

```bash theme={null}
# Auto-select models based on content type
dria batch prompts.jsonl -o results.jsonl

# Use a specific model with concurrency of 20
dria batch -m qwen3.5:9b prompts.jsonl -o results.jsonl -c 20
```

### `dria chat`

Multi-turn conversations with persistent history stored in `~/.dria/chats/`.

```bash theme={null}
# Start a new conversation
dria chat -m qwen3.5:9b "What is Rust?"

# Continue an existing conversation by ID
dria chat abc123ef "Tell me more about ownership"

# Read conversation history
dria chat abc123ef

# List all conversations
dria chat list

# Delete a conversation
dria chat delete abc123ef
```

### `dria models`

List all available models on the network with their node counts.

```bash theme={null}
dria models
```

### `dria post` & `dria feed`

Interact with community channels (messages are bridged to Discord).

```bash theme={null}
# Post a message
dria post "hello from CLI"

# Post to the requests channel with a custom display name
dria post "looking for qwen3.5:9b" -c requests -n my-agent

# Read recent messages
dria feed

# Follow mode — polls every 3 seconds
dria feed -f

# Read from a specific channel with a limit
dria feed -c requests -n 10
```

## Configuration

Config is stored at `~/.dria/config.json` (created by `dria init`). All fields can be overridden with environment variables:

| Field        | Env Var           | Default                     | Description                     |
| :----------- | :---------------- | :-------------------------- | :------------------------------ |
| `privateKey` | `DKN_PRIVATE_KEY` | —                           | Ethereum private key            |
| `apiKey`     | `DKN_API_KEY`     | —                           | API key from registration       |
| `apiBase`    | `DKN_API_BASE`    | `https://inference.dria.co` | API base URL                    |
| `network`    | `DKN_NETWORK`     | `base`                      | Blockchain network for payments |

## Programmatic Usage

The CLI also exports a `DknClient` class for use in Node.js/TypeScript:

```typescript theme={null}
import { DknClient } from '@dria/cli';

const client = new DknClient('dkn_live_...', 'https://inference.dria.co');

const result = await client.generate({
  model: 'qwen3.5:9b',
  messages: [{ role: 'user', content: 'hello' }],
});
```

## Output Conventions

* Spinners and progress go to **stderr**, data goes to **stdout** — pipe-friendly by default.
* Use `--json` on any command for raw JSON output with no spinners.
* No spinners are shown when stdout is piped.

## API Compatibility

The Dria inference API uses the **OpenAI-compatible** `/v1/chat/completions` endpoint format with Server-Sent Events (SSE) for streaming. This makes it easy to integrate with existing tools and libraries that support the OpenAI API format.


# Frequently Asked Questions
Source: https://node-guide.dria.co/faq

Find answers to common questions about the Dria network

## Node Setup

<Accordion title="Do I need Ollama?">
  **No.** The new `dria-node` binary runs models natively using llama.cpp. Ollama is no longer required. Simply run `dria-node setup` to download and configure your model.
</Accordion>

<Accordion title="What are the minimum system requirements?">
  * **RAM:** At least \~1 GB for the smallest model (`qwen3.5:0.8b`), up to \~27 GB for the largest (`nemotron:30b-a3b`)
  * **Disk:** 0.5 GB to 24.5 GB for model files depending on model choice
  * **Network:** Outbound UDP port 4001 (QUIC)
  * **OS:** macOS (Intel + Apple Silicon), Linux (x86\_64, arm64), Windows (x86\_64)

  See [Selecting Models](/selecting-models) for the full model table with RAM requirements.
</Accordion>

<Accordion title="How do I install dria-node?">
  The fastest way:

  * **macOS/Linux:** `brew install firstbatchxyz/dkn/dria-node` or `curl -fsSL https://raw.githubusercontent.com/firstbatchxyz/dkn-compute-node/master/install.sh | sh`
  * **Windows:** `irm https://raw.githubusercontent.com/firstbatchxyz/dkn-compute-node/master/install.ps1 | iex`

  See [Running a Node](/how-to-run) for all installation methods.
</Accordion>

## Running a Node

<Accordion title="How do I check if my node is online?">
  Visit the [Dria Edge AI Dashboard](https://dria.co/edge-ai) and log in with the wallet associated with your node. The dashboard shows your node's status, recent activity, and earned points.
</Accordion>

<Accordion title="Can I run multiple nodes?">
  Yes. You can run multiple nodes on the same machine or network, but **each node must use a unique private key (wallet)**. Using the same key for multiple nodes will cause conflicts with task assignment and rewards.
</Accordion>

<Accordion title="What ports do I need open?">
  Your node needs outbound access on **UDP port 4001** to connect to the Dria router via QUIC. No inbound ports need to be opened.
</Accordion>

<Accordion title="Does dria-node support GPU acceleration?">
  Yes. `dria-node` supports:

  * **Apple Metal** (macOS) — works automatically on Apple Silicon
  * **NVIDIA CUDA** — use the CUDA build
  * **AMD ROCm 6.x** — use the ROCm install script (Linux x86\_64 only)

  Use `--gpu-layers -1` to offload all model layers to GPU.
</Accordion>

<Accordion title="How does auto-update work?">
  `dria-node` checks for new versions on GitHub Releases at startup. Patch bumps (e.g. 0.7.3 → 0.7.4) show a warning. Minor or major version bumps trigger an automatic update to keep your node compatible with the network. You can skip this with `--skip-update`.
</Accordion>

## Earning Points

<Accordion title="Why am I not earning points?">
  Common reasons:

  1. **No tasks** — There may be low demand for the model(s) you're running. Check the dashboard and consider switching to higher-demand models.
  2. **Node offline** — Make sure `dria-node` is running and your network allows outbound UDP on port 4001.
  3. **Low reputation** — New nodes start with a neutral reputation score. Complete tasks consistently to build it up. Failing or timing out on tasks reduces your score.

  Refer to the [Rewards](/rewards) page for details on the earning mechanism.
</Accordion>

<Accordion title="How often are $DRIA Points updated?">
  Points on the [Dria Edge AI Dashboard](https://dria.co/edge-ai) are updated in near real-time as your node completes tasks.
</Accordion>

## Using the Network (CLI)

<Accordion title="How do I use Dria for inference?">
  Install the Dria CLI:

  ```bash theme={null}
  npm install -g @dria/cli
  dria init
  ```

  Then run inference:

  ```bash theme={null}
  dria generate -m qwen3.5:9b "explain quantum computing"
  ```

  See the [CLI Guide](/cli) for full documentation.
</Accordion>

<Accordion title="How does payment work for using the network?">
  The CLI uses USDC credits on the Base network. Top up with:

  ```bash theme={null}
  dria topup --amount 10
  ```

  This uses the x402 payment protocol with gasless EIP-712 signed transfers. See [CLI Guide](/cli) for details.
</Accordion>

## Troubleshooting

<Accordion title="My node keeps disconnecting">
  The node automatically reconnects with exponential backoff (1s, 2s, 4s, 8s, 16s). If it repeatedly fails:

  1. Check your internet connection
  2. Ensure outbound UDP port 4001 is not blocked by a firewall
  3. Try setting `RUST_LOG=debug` for more detailed logs
  4. Make sure you're running the latest version (`dria-node` auto-updates by default)
</Accordion>

<Accordion title="Model download fails">
  Models are downloaded from HuggingFace. If the download fails:

  1. Check your internet connection
  2. Ensure you have enough disk space in `~/.dria/models/`
  3. Try running `dria-node setup` again — it will resume where it left off
</Accordion>

<Accordion title="Should I avoid WSL on Windows?">
  We recommend using native Windows (PowerShell) instead of WSL for the best experience. If you encounter issues on WSL, switch to the native Windows installation method.
</Accordion>


# Running a Node
Source: https://node-guide.dria.co/how-to-run

Install and run the Dria Compute Node to serve AI models and earn rewards

## Introduction

The **Dria Compute Node** (`dria-node`) is a single Rust binary that lets you serve AI models on the Dria network and earn rewards. It runs models locally using llama.cpp — no Ollama or external dependencies required.

<Check>**Single binary** — no Docker, no Ollama, no complex setup.</Check>
<Check>**Built-in model management** — downloads, caches, and benchmarks GGUF models automatically.</Check>
<Check>**GPU acceleration** — supports Apple Metal, NVIDIA CUDA, and AMD ROCm out of the box.</Check>
<Check>**Auto-updates** — checks for new versions on startup and updates itself.</Check>
<Check>**Reconnection** — automatically reconnects with exponential backoff if the connection drops.</Check>

## Installation

<Tabs>
  <Tab title="macOS / Linux (Homebrew)">
    ```bash theme={null}
    brew install firstbatchxyz/dkn/dria-node
    ```
  </Tab>

  <Tab title="macOS / Linux (Shell Script)">
    ```bash theme={null}
    curl -fsSL https://raw.githubusercontent.com/firstbatchxyz/dkn-compute-node/master/install.sh | sh
    ```
  </Tab>

  <Tab title="Windows (PowerShell)">
    Open PowerShell and run:

    ```powershell theme={null}
    irm https://raw.githubusercontent.com/firstbatchxyz/dkn-compute-node/master/install.ps1 | iex
    ```
  </Tab>

  <Tab title="AMD ROCm (Linux)">
    For AMD GPUs with ROCm 6.x on Linux x86\_64:

    ```bash theme={null}
    curl -fsSL https://raw.githubusercontent.com/firstbatchxyz/dkn-compute-node/master/install-rocm.sh | bash
    ```
  </Tab>

  <Tab title="Build from Source">
    Requires the [Rust toolchain](https://www.rust-lang.org/), cmake, and build-essential (Linux) or Visual Studio Build Tools + LLVM (Windows).

    ```bash theme={null}
    git clone https://github.com/firstbatchxyz/dkn-compute-node.git
    cd dkn-compute-node
    cargo build --release
    ```

    **Optional GPU feature flags:**

    ```bash theme={null}
    # Apple Metal (macOS)
    cargo build --release --features metal

    # NVIDIA CUDA
    cargo build --release --features cuda

    # AMD ROCm
    cargo build --release --features rocm
    ```
  </Tab>
</Tabs>

## Setup

Run the interactive setup wizard to select and download a model:

```bash theme={null}
dria-node setup
```

The wizard will:

1. **Detect your available RAM** and filter models that fit your system.
2. **Let you pick a model** from the supported list.
3. **Download the GGUF model file** from HuggingFace.
4. **Run a test inference** and print your benchmark TPS.

<Tip>
  Models are cached in `~/.dria/models/`. You only need to download each model once.
</Tip>

## Starting Your Node

Once setup is complete, start your node:

```bash theme={null}
dria-node start --wallet <YOUR_PRIVATE_KEY> --model <MODEL_NAME>
```

For example:

```bash theme={null}
dria-node start --wallet abc123...def --model qwen3.5:9b
```

You can also serve **multiple models** by separating them with commas:

```bash theme={null}
dria-node start --wallet abc123...def --model qwen3.5:9b,lfm2.5:1.2b
```

<Warning>
  Your wallet is an Ethereum-compatible private key (64 hex characters). This is used for node identity, authentication, and reward tracking. **Never share your private key.**
</Warning>

Stop the node with <kbd>CTRL+C</kbd> (Linux/Windows) or <kbd>CMD+C</kbd> (macOS). The node will gracefully drain in-flight tasks before shutting down.

## Configuration

All flags can also be set via environment variables:

| Flag               | Env Var               | Default             | Description                                                                  |
| :----------------- | :-------------------- | :------------------ | :--------------------------------------------------------------------------- |
| `--wallet`         | `DRIA_WALLET`         | *(required)*        | Ethereum private key (hex, 32 bytes)                                         |
| `--model`          | `DRIA_MODELS`         | *(required)*        | Model(s) to serve, comma-separated                                           |
| `--gpu-layers`     | `DRIA_GPU_LAYERS`     | `0` (CPU only)      | GPU layers to offload (`-1` = all)                                           |
| `--max-concurrent` | `DRIA_MAX_CONCURRENT` | `1`                 | Max parallel inference tasks                                                 |
| `--data-dir`       | `DRIA_DATA_DIR`       | `~/.dria`           | Directory for cached models                                                  |
| `--quant`          | `DRIA_QUANT`          | Per-model default   | Override GGUF quantization (e.g. `Q8_0`)                                     |
| `--context-size`   | `DRIA_CONTEXT_SIZE`   | Model's native      | Max context window (tokens)                                                  |
| `--kv-quant`       | `DRIA_KV_QUANT`       | `q8_0`              | KV cache quantization (`f16`, `f32`, `q8_0`, `q4_0`, `q4_1`, `q5_0`, `q5_1`) |
| `--router-url`     | `DRIA_ROUTER_URL`     | `quic.dria.co:4001` | Router URL                                                                   |
| `--skip-update`    | `DRIA_SKIP_UPDATE`    | `false`             | Skip auto-update check on startup                                            |

<Info>
  Set `RUST_LOG=debug` for verbose logging during troubleshooting.
</Info>

## GPU Acceleration

`dria-node` supports GPU acceleration for faster inference:

* **Apple Metal** — Enabled automatically on macOS with Apple Silicon.
* **NVIDIA CUDA** — Use the CUDA build or `--features cuda` when building from source.
* **AMD ROCm** — Use the ROCm install script or `--features rocm` when building from source.

To offload all model layers to GPU:

```bash theme={null}
dria-node start --wallet <KEY> --model qwen3.5:9b --gpu-layers -1
```

## System Requirements

* **OS:** macOS (Intel + Apple Silicon), Linux (x86\_64, arm64), Windows (x86\_64)
* **RAM:** Minimum \~1 GB (for smallest model) to \~27 GB (for largest model) — see [Selecting Models](/selecting-models) for details
* **Disk:** Space for GGUF model files (0.5 GB to 24.5 GB depending on model)
* **Network:** Outbound UDP port 4001 (QUIC connection to router)
* **GPU (optional):** Apple Metal, NVIDIA CUDA, or AMD ROCm 6.x

## How It Works

Your node connects to the Dria router network via **QUIC** (a fast, encrypted UDP-based protocol). Here's what happens:

1. **Authentication** — The router sends a random challenge. Your node signs it with your private key to prove identity.
2. **Registration** — Your node announces which model(s) it can serve.
3. **Task assignment** — The router forwards inference requests from users to your node based on model availability and capacity.
4. **Inference** — Your node runs the model locally and streams results back.
5. **Backpressure** — If your node is at capacity, it rejects new tasks and the router re-routes to another node.

<Info>
  The node supports text, vision (image), and audio inference depending on the model. See [Selecting Models](/selecting-models) for model capabilities.
</Info>

## Running Multiple Nodes

You can run multiple nodes on the same machine or network, but **each node must use a unique private key (wallet)**. Using the same key for multiple nodes will cause conflicts.


# Introduction
Source: https://node-guide.dria.co/introduction

Welcome to the Dria Network — Run AI models or use decentralized inference from the CLI

<img alt="Dria Network Hero" />

<img alt="Dria Network Hero Dark" />

## What is Dria?

Dria is a decentralized Edge AI network — a distributed, crowdsourced hyperscaler that delivers fast, affordable AI inference powered by everyday people.

Anyone can contribute by **running a node** to serve AI models and earn rewards, or **use the network** to run inference across a global fleet of compute nodes from the command line.

Dria powers scalable, high-performance inference across diverse CPU and GPU hardware. No Ollama, no external dependencies — just a single binary that runs models natively using llama.cpp.

## Two Ways to Participate

<CardGroup>
  <Card title="Run a Node" icon="server" href="/how-to-run">
    Install `dria-node`, pick a model, and start earning rewards by serving inference to the network.
  </Card>

  <Card title="Use the Network" icon="terminal" href="/cli">
    Install the Dria CLI to generate text, process batches, hold conversations, and more — all powered by the decentralized network.
  </Card>
</CardGroup>

## Getting Started

<CardGroup>
  <Card title="Select Models" icon="microchip" href="/selecting-models">
    Browse the 12 supported models and find the right one for your hardware.
  </Card>

  <Card title="Earn Rewards" icon="coins" href="/rewards">
    Understand how to earn \$DRIA points by contributing to the network.
  </Card>

  <Card title="FAQ" icon="question" href="/faq">
    Find answers to commonly asked questions.
  </Card>
</CardGroup>


# Reward Mechanism
Source: https://node-guide.dria.co/rewards

Learn how to earn $DRIA Points by contributing to the network

## Dashboard

You can now view your Node's real-time status, monitor earned \$DRIA Points, and explore detailed analytics through your own Personalized Dashboard.

<Frame>
  <img alt="Dria Dashboard" />
</Frame>

Log in with the wallet you used for your Node at [dria.co/edge-ai](https://dria.co/edge-ai) to see your personalized dashboard.

## Earn by Running a Node

By running a node, you contribute computing power to serve AI models to the Dria network. Your node earns \$DRIA points as it successfully completes inference tasks assigned to it.

Tasks are sent to the network by Dria users, and these users specify which AI model should be used for their task. For example, if many tasks are submitted requesting model 'X', the network distributes these tasks among the available nodes that are currently configured to run model 'X'.

<Info>
  Your node earns points **per completed task**, not continuously. It's completely normal for earnings to fluctuate. If your node status is online on the dashboard and you see occasional point increases, it's working correctly.
</Info>

### Factors Affecting Earnings

<CardGroup>
  <Card title="Task Availability" icon="tasks">
    The number of tasks submitted to the network for the specific model(s) your node is running.
  </Card>

  <Card title="Model Selection" icon="microchip">
    Running models that are in high demand by users will likely result in more tasks being assigned to your node.
  </Card>

  <Card title="Node Performance" icon="gauge-high">
    Your node needs to be online, reachable, and (for local models) performant enough to complete tasks efficiently.
  </Card>

  <Card title="Number of Nodes" icon="network-wired">
    The total number of other nodes also running the same model(s) affects how tasks are distributed.
  </Card>
</CardGroup>

## Earn by Referring Dria

Invite your friends and community to run Dria nodes and earn additional \$DRIA Points through our Referral Program. Plus, stay active—there will be special airdrops rewarding our most engaged community members.

<Steps>
  <Step title="Get a Referral Code">
    Run `dkn-compute-launcher referrals` command to get your referral code.
  </Step>

  <Step title="Share Your Code">
    Share your referral code with friends and community.
  </Step>

  <Step title="Earn Points">
    Once someone registers using your referral code, you'll earn additional points based on their activity:

    * 0.3 rate for their first 10,000 \$DRIA Points
    * 0.2 rate up to 100,000 \$DRIA Points
    * 0.1 rate for all \$DRIA Points beyond 100,000
  </Step>
</Steps>

<Warning>
  Each referral code only has 10 uses! Once you have referred 10 users, your code will no longer work.
</Warning>

## Earn by Engaging with Community

In addition to running a node and referring others, there are multiple ways to earn by actively engaging in the Dria ecosystem:

### Discord & X Engagement

Those who actively participate in discussions, share insights, and help onboard new members on Discord & X (Twitter) will be given additional roles to recognize their contributions.

<Check>
  Sharing Dria-related tweets, memes, and threads.
</Check>

<Check>
  Engaging with the community, answering questions, and fostering discussions.
</Check>

## Value of \$DRIA Points

Dria has been creating real value in the AI world (creating the [first agentic LLM for pythonic function calling](https://x.com/driaforall/status/1878840572737421766), building a launcher for DKN that has 100k+ downloads, got thousands of downloads from AI devs on [huggingface](https://huggingface.co/driaforall) etc.) thanks to thousands of contributors across the world.

\$DRIA Points are designed to **incentivize contribution and participation, while allowing contributors to have an exposure to the value Dria is creating in the AI space.**

## Upcoming Reward Structure Update

<Note>
  With the new Dria architecture, we are planning to update the reward structure. The reward pool will grow as it becomes directly funded by revenue from paid [Dria CLI](/cli) services usage. This means more inference traffic on the network translates to a larger reward pool for node operators — aligning node runner incentives with real network demand.
</Note>

Stay tuned for more details on the updated reward mechanics. Existing \$DRIA Points remain valid and will carry over.

## Special Events & Competitions

We believe that **rewarding contributors should also be an enjoyable experience**. That's why we're going to launch **interactive, gamified events** to engage and incentivize our community.

<Note>
  We **highly value our node runners**, so they'll be our **top priority** when it **comes to rewards**. But those who **actively support us on X and contribute to the community on Discord** **will be just as important!**
</Note>

## Benefits of Early Participation

Early contributors shape the foundation of Dria's decentralized network and will be recognized accordingly in the future.

### Early Contributor Appreciation Program

We're excited to announce our Early Contributor Appreciation Program as a way to thank our dedicated node operators who have actively contributed to Dria's growth and success.

<Info>
  This program is not related to any future token launches or \$DRIA tokens. Dria currently has no token, and this appreciation event is purely to recognize your early support and enthusiasm.
</Info>

<Note>
  **Important:** This Early Contributor Appreciation Program is an **additional reward layer** separate from your DRIA Points. When you claim rewards from this program, **your DRIA Points remain completely intact** and are not consumed or reduced in any way. Your points will continue to be available for all future incentive programs and protocols. This is purely bonus appreciation on top of your existing point balance.
</Note>

<Warning>
  **Timeline:** The program launches with the first payout on **July 10th**. This marks the beginning of our monthly reward distribution cycles for active node contributors.
</Warning>

Your accumulated \$DRIA Points will remain unaffected by this program and will still count toward future incentives once Dria becomes a completely decentralized protocol.

### How It Works

<Steps>
  <Step title="Earn $DRIA Points">
    Your node earns points by successfully completing tasks on the network. All your accumulated points across time contribute to your total score.
  </Step>

  <Step title="Eligibility & Point Calculation">
    Only nodes that have been **active within the last 30 days** are eligible for rewards. However, the calculation uses **all-time points** earned by these active nodes, not just points from the last 30 days.
  </Step>

  <Step title="Reward Pool Creation">
    The **total reward pool** is calculated by multiplying the **combined points of all eligible nodes** by **0.000025 USD**. This creates the USD value of the pool that will be distributed among all participants.

    For example, if eligible nodes have a combined total of 100,000,000 \$DRIA Points, the total reward pool will be 2,500 USD worth of USDC to be shared among all eligible nodes.

    <Warning>
      **Important:** Your individual points are NOT directly multiplied by 0.000025. This formula only determines the size of the shared reward pool in USD value.
    </Warning>
  </Step>

  <Step title="Percentile Distribution">
    Among eligible nodes, participants are ranked by their total points and divided into percentiles. **Only the top 5 percentiles receive rewards:**

    * **Top 10%**: 25% of reward pool
    * **Top 20%**: 22% of reward pool
    * **Top 30%**: 20% of reward pool
    * **Top 40%**: 17% of reward pool
    * **Top 50%**: 16% of reward poolpercentage

    <Info>
      **Note:** Nodes ranking below the top 50% percentile do not receive rewards in this program.
    </Info>
  </Step>

  <Step title="Individual Rewards">
    Within each percentile group, rewards are distributed proportionally based on each node's share of points within that group.

    **Your actual reward calculation:**
    Your reward = (Your points / Total points in your percentile) × (Your percentile's % of total pool) × (Total reward pool in USD)

    <Info>
      **Example:** If you're in the top 10% with 5,000,000 points, your percentile has 50,000,000 total points, and the total pool is 2,500 USD:
      Your reward = (5,000,000 / 50,000,000) × 25% × 2,500 USD = 62.5 USD worth of USDC
    </Info>
  </Step>
</Steps>

<Warning>
  **Important:** These distribution ratios apply specifically to the **first payout starting July 10th**. For subsequent monthly payouts, the reward pool will be calculated using only the last 30 days' points, and distribution ratios will be adjusted based on the active node distribution patterns.
</Warning>

### Distribution Process

<CardGroup>
  <Card title="Claiming Rewards" icon="wallet">
    Rewards are calculated in **USD value** but distributed as **USDC equivalent** and can be claimed by logging into the [dria.co/edge-ai](https://dria.co/edge-ai) dashboard with the wallet address connected to your node.
  </Card>

  <Card title="Verification" icon="magnifying-glass">
    All reward calculations will be shared transparently via our community channels for operators to verify their percentile placement and reward allocation.
  </Card>

  <Card title="Timeline" icon="calendar">
    The first reward cycle begins on **July 10th** with the initial payout. Subsequent cycles will occur monthly with adjusted distribution ratios.
  </Card>

  <Card title="Reporting" icon="chart-bar">
    Monthly reports will detail total points earned, reward pool size (in USD), percentile distributions, and individual reward allocations (USDC equivalent values).
  </Card>
</CardGroup>

### Why?

<Warning>
  Dria's goal is to foster genuine participation through meaningful tasks rather than speculative activity. This program directly links rewards to actual work performed on the network.
</Warning>

By rewarding node operators based on their contributions proportional to network revenue, we're building a sustainable incentive model that benefits both the network and our dedicated community of node runners.

For complete program details, eligibility requirements, and support, visit our [Discord community](https://discord.gg/dria).


# Selecting Models
Source: https://node-guide.dria.co/selecting-models

Choose the right model for your hardware and maximize your earnings

## Supported Models

`dria-node` includes a built-in registry of 12 models. All models are served locally using llama.cpp — no Ollama required. Each model is downloaded as a GGUF file from HuggingFace during setup.

| Model               | Type         | Default Quant | GGUF Size | Min RAM  |
| :------------------ | :----------- | :------------ | :-------- | :------- |
| `qwen3.5:0.8b`      | Vision       | Q4\_K\_M      | 0.5 GB    | \~1 GB   |
| `lfm2.5:1.2b`       | Text         | Q4\_K\_M      | 0.8 GB    | \~1 GB   |
| `lfm2.5-audio:1.5b` | Audio        | Q4\_0         | 1.0 GB    | \~1.5 GB |
| `lfm2.5-vl:1.6b`    | Vision       | Q4\_0         | 1.2 GB    | \~1.5 GB |
| `qwen3.5:2b`        | Vision       | Q4\_K\_M      | 1.2 GB    | \~2 GB   |
| `nanbeige:3b`       | Text         | Q4\_K\_M      | 2.0 GB    | \~2.5 GB |
| `locooperator:4b`   | Text         | Q4\_K\_M      | 2.5 GB    | \~3 GB   |
| `qwen3.5:9b`        | Vision       | Q4\_K\_M      | 6.0 GB    | \~7 GB   |
| `lfm2:24b-a2b`      | Text (MoE)   | Q4\_K\_M      | 14 GB     | \~16 GB  |
| `qwen3.5:27b`       | Vision       | Q4\_K\_M      | 16 GB     | \~18 GB  |
| `qwen3.5:35b-a3b`   | Vision (MoE) | Q4\_K\_M      | 20 GB     | \~22 GB  |
| `nemotron:30b-a3b`  | Text (MoE)   | Q4\_K\_M      | 24.5 GB   | \~27 GB  |

### Model Types

* **Text** — Standard text generation and instruction following.
* **Vision** — Multimodal models that can process both text and images.
* **Audio** — Multimodal models that can process text and audio inputs.
* **MoE** — Mixture-of-Experts models that activate only a subset of parameters per token, enabling larger models to run efficiently.

## How to Choose a Model

<Steps>
  <Step title="Check Your RAM">
    Run `dria-node setup` — it will automatically detect your available RAM and filter models that fit your system.
  </Step>

  <Step title="Consider Demand">
    Visit [dria.co/edge-ai](https://dria.co/edge-ai) to see which models are getting the most tasks. Running high-demand models means more task assignments and more earnings.
  </Step>

  <Step title="Match Your Hardware">
    Larger models produce higher-quality output but need more RAM and compute. Pick the largest model your hardware can comfortably run. GPU acceleration significantly improves performance for larger models.
  </Step>

  <Step title="Run the Benchmark">
    During `dria-node setup`, a test inference is run and your TPS (Tokens Per Second) is printed. Higher TPS means faster task completion and better reputation.
  </Step>
</Steps>

## Quantization

All models default to **4-bit quantization** (Q4\_K\_M or Q4\_0) for the best balance of quality and resource usage. If you have extra RAM, you can use 8-bit quantization for better output quality:

```bash theme={null}
dria-node start --wallet <KEY> --model qwen3.5:9b --quant Q8_0
```

<Warning>
  8-bit quantization roughly doubles the GGUF file size and RAM usage. Make sure your system has enough resources before switching.
</Warning>

## Serving Multiple Models

You can serve multiple models from a single node by separating them with commas:

```bash theme={null}
dria-node start --wallet <KEY> --model qwen3.5:9b,lfm2.5:1.2b,lfm2.5-audio:1.5b
```

This lets your node handle text, vision, and audio tasks. Make sure your system has enough RAM for all selected models.

## Dynamic Model Updates

The Dria router can push model registry updates to your node at runtime. When new models are added to the network, your node can download and load them automatically without restarting.