# Meet Gradient

Towards Open Intelligence

Gradient is an AI R\&D lab dedicated to building **open intelligence** through a fully decentralized infrastructure — **OIS (Open Intelligence Stack)**, encompassing **distributed training, serving,** agentic systems, and more.

We are solving the hardest and most ambitious problem in the intersection of Blockchain x AI: How do we train/serve good LLMs over public internet — Is it even possible to build an OpenAI competitor over a permissionless, autonomous network?

Our current OIS includes **Parallax** for distributed serving, **Echo** for distributed reinforcement learning, and **Gradient Cloud** for enterprise solutions.

Backed by **top investors** and a team of **world-class researchers**, Gradient is committed to releasing more frontier research that will unlock a future where **intelligence can be assembled, scaled, and evolved by anyone, anywhere**.

### Our mission

Gradient is building the world’s first Open Intelligence Stack: a sovereign, peer-powered infrastructure where intelligence is hosted, served, and owned by the people. Our goal is a global foundation that enables the **distribution, evolution, and embodiment** of intelligence.


# The Open Intelligence Stack

Open Full Stack for Distributed AI

<figure><img src="/files/FYHTkTLgk8ypYZBUVXGr" alt=""><figcaption></figcaption></figure>

### Available Research

{% columns %}
{% column width="50%" %}
{% content-ref url="/pages/ohGVXDpaKsrxKmuZaf6d" %}
[Echo](/the-open-intelligence-stack/echo)
{% endcontent-ref %}

{% content-ref url="/pages/jkefTfIDr6JNjagQkV7H" %}
[Lattica](/the-open-intelligence-stack/lattica)
{% endcontent-ref %}
{% endcolumn %}

{% column width="50%" %}
{% content-ref url="/pages/fanLmAM8ScSZkoYozL4c" %}
[Parallax](/the-open-intelligence-stack/parallax)
{% endcontent-ref %}

<br>

\ <br>
{% endcolumn %}
{% endcolumns %}


# Echo

The Distributed Reinforcement Learning Framework

{% hint style="success" %}
Research paper: [published](https://arxiv.org/pdf/2508.05387)
{% endhint %}

{% hint style="success" %}
Models: [open-sourced](https://huggingface.co/GradientResearch/models)
{% endhint %}

As AI systems grow in scale and generality, RL has become a critical layer for alignment. However, most co-located RL frameworks face a deadlock: inference interrupts training, training delays inference.

Echo is Gradient’s distributed RL framework, running on everyday consumer devices.

## Dual Swarm Architecture

Echo breaks the cycle by decoupling them into two independent swarms:

* Inference on distributed devices (via [Parallax](/the-open-intelligence-stack/parallax))
* Training on high-performance clusters

<div align="left"><figure><img src="/files/5b9069V93VS25DC6ZEOb" alt="" width="563"><figcaption></figcaption></figure></div>

## Echo Modes

We have open-sourced several early explorations with Echo, including:&#x20;

* A 7B math model beating Qwen2.5–32B
* A 30B Sokoban model outperforming DeepSeek-R1 & GPT-OSS-120B
* A 32B LoRA logic model ≥99% accuracy&#x20;

See all models in our [Hugging Face Collection](https://huggingface.co/GradientResearch/models).

## Learn More

Read the [blog](https://gradient.network/blog/echo-distributed-reinforcement-learning).\
Read the full [research paper](https://arxiv.org/pdf/2508.05387).


# Parallax

The World Inference Engine

{% hint style="success" %}
Experience distributed inference with the [Gradient Chatbot](https://chat.gradient.network),  powered by Parallax.

Models available:

`qwen3-235b-a22b`&#x20;

`gpt-oss-120b`
{% endhint %}

{% hint style="success" %}
Research Paper: [published](https://gradient.network/parallax.pdf)
{% endhint %}

LLMs are reshaping how we think, build, and create, but their demand for tokens is outpacing what centralized infra can deliver. Chips saturated; Power grids strained; Intelligence remains locked behind high-cost silos.

Parallax reimagines model inference as a global, collaborative process, one where models are no longer chained to centralized infrastructure, but are instead recomposed, executed, and verified across a global mesh of compute.

The engine introduces 3 foundational shifts:

1. Intelligence sovereignty: serve models from the hardware you trust
2. Composable inference: GPUs, Apple Silicon, and desktops working in harmony
3. Latent compute: activate into the world’s untapped compute

## The Architecture

Parallax is a system specifically engineered for high-performance structured generation on decentralized machine networks. The system consists of three main layers: Runtime, Communication, and Worker.

<figure><img src="/files/4DpKYOuKv7F3A13PwvKr" alt=""><figcaption></figcaption></figure>

### Runtime Layer

The Parallax Runtime Layer is the core orchestration engine for high-throughput, server-side LLM serving on distributed, heterogeneous networks. It's composed of an Executor (control loop), Model Shard Holder, Request Manager, Scheduler, and Paged KV Cache Manager.\
\
As the first framework of its kind for the MLX ecosystem, the Parallax runtime pioneers professional-grade serving on Apple Silicon.&#x20;

### Communication Layer

Manages gRPC and tensor streaming between peers, ensuring forward and backward passes succeed even if some nodes fail. Built on top of Hivemind’s Distributed Hash Table (DHT), a decentralized system that ensures fast, reliable information sharing without a central coordinator, to distribute values across peers.&#x20;

### Worker Layer

Executes inference tasks across heterogeneous hardware platforms, ensuring optimal performance and scalability via a dual-platform approach:

* GPU Workers: Use a modified version of SGLang (a fast serving framework for LLMs, which utilizes PyTorch with CUDA kernels to harness the full computational power of NVIDIA GPUs) with asynchronous batching for heterogeneous compute adaptations.
* Apple Workers: We have engineered a state-of-the-art serving engine built upon our pioneering MLX-compatible runtime, with the integration of a highly optimized Metals kernel, including a Paged Flash Attention kernel, unlocking unprecedented inference efficiency and throughput on Apple Silicon.

## The Swarm

<figure><img src="/files/AWnWhQ5qV551VV7hBPaq" alt=""><figcaption></figcaption></figure>

Parallax runs on a distributed architecture called the Swarm: a fully distributed machine mesh where your prompt is tokenized, segmented, and routed across nodes holding model shards.&#x20;

Each node executes its assigned layers of the LLM, passing hidden states forward until the full inference is complete.&#x20;

Optimal nodes are selected based on availability, compute, and latency. Coordination happens peer-to-peer via a DHT, enabling efficient routing, self-healing, and fault tolerance.&#x20;

## Learn More

Read the [blog](https://gradient.network/blog/parallax-world-inference-engine) for more details.\
\
Learn more about Parallax's architecture and benchmark results in the [research paper](https://gradient.network/parallax.pdf).[<br>](https://x.com/Gradient_HQ/status/1943581029953892628/photo/1)


# Lattica

The Universal Data Motion Engine

{% hint style="success" %}
Peer-to-peer video [streaming](https://explorer.gradient.network/) powered by Lattica.
{% endhint %}

## From Sentry Nodes to Lattica

During Sentry Node Open Beta, our community helped run one of the world’s largest decentralized connectivity experiments with over 2 billion peer-to-peer connections made across 190+ regions.

That network has evolved into Lattica — a universal data communication protocol.

Built on Gradient’s global peer-to-peer infrastructure, it tackles one of the core challenges in distributed AI: moving data across a heterogeneous, permissionless mesh without centralized intermediaries.

## Why Lattica Matters

As AI becomes more distributed and multi-agent, coordination is just as critical as compute.

Lattica is built to move model weights, inference tokens, and file shards across a global machine mesh. At its core, Lattica powers everything needed to build the future of intelligence—open, agentic, and alive at the edge.

As the universal data motion engine, it ensures data flows fast, securely, and reliably—powering multiple layers of our distributed AI stack: from routing model parameters to coordinating distributed inference and enabling agent communication.

## See Lattica in Motion

Lattica usually runs invisibly, so we put it in motion within the [Gradient Explorer](https://explorer.gradient.network).

<figure><img src="/files/hw6DWRkLXu4VX6hdLiyT" alt=""><figcaption></figcaption></figure>

We built a decentralized video streaming experience in one of the most constrained and unpredictable environments: your browser.\
\
Read the [blog](https://gradient.network/blog/lattica-universal-data-motion-engine) to learn more.


# Parallax

Parallax is the operating system for sovereign AI. Under the hood, it is a distributed runtime and service fabric that turns heterogeneous machines into one traceable service you can build on. When a model is too big for one host, it is sharded into contiguous layer slices and distributed across your laptop, a lab GPU, and a teammate’s workstation, all orchestrated as one service. Each request takes the fastest path on a single host, across a LAN, or over the public internet, without a public IP or matching hardware.

Parallax opens up a wide range of ways to host and run your own AI apps and agents that are completely your own, including coding copilots, personal assistants, vision and speech pipelines, and multi-agent simulations.

At launch, Parallax supports **40+ open models** from **0.6B** to **trillion-class MoE** on **GPUs** and **Apple Silicon**, across **Windows, Linux, and macOS**.<br>

* Host your own AI cluster: [github.com/GradientHQ/parallax](http://github.com/GradientHQ/parallax)


# Gradient Cloud

Fast, affordable AI on a distributed stack

[Gradient Cloud ](https://cloud.gradient.network/)is the all-in-one station for building with AI, powered by the Gradient distributed AI stack.

Powered by Lattica, Parallax, and Echo, workloads are deployed and routed across a global network of hardware instead of centralized clusters.

That’s how we unlock high throughput + low latency intelligence at low cost.

{% hint style="success" %}
Phase 1  is live with:

• **Inference Endpoints** for leading open-source models

• **Interactive Playground** with tunable params + one-click deploy
{% endhint %}

All new accounts will be credited with a few million free tokens to jumpstart your AI ideas.\
\
You can find API details below:

{% content-ref url="/pages/ouaMK4e9AYWUKz0faHNm" %}
[API Reference Documentation](/enterprise-solutions/gradient-cloud/api-reference-documentation)
{% endcontent-ref %}


# API Reference Documentation

This document describes the OpenAI-compatible AI service interfaces, including model management, chat completion, and text completion functionality.

## Overview

Our AI API implements OpenAI-compatible interfaces that support:

* Model listing and querying
* Chat completion (streaming and non-streaming)
* Text completion (streaming and non-streaming)
* Administrator model management

## Basic Information

* **Base URL**: `https://apis.gradient.network/api/v1`
* **Authentication**: Access Key
* **Content Type**: `application/json`
* **API Version**: v1

## Authentication

### Access Key Authentication

```bash
Authorization: Bearer your-access-key-here
```

## API Endpoints

### 1. Model Management APIs

#### **1.1 List All Models**

**Endpoint**: `GET /ai/models`

**Description**: List of all available AI models (no authentication required)

**Request Parameters**: None

**Response Example**:

```json
{
  "object": "list",
  "data": [
    {
      "id": "qwen/qwen3-coder-480b-instruct-fp8",
      "object": "model",
      "created": 1640995200,
      "owned_by": "qwen",
      "permission": [],
      "root": "qwen/qwen3-coder-480b-instruct-fp8",
      "parent": null
    }
  ]
}
```

**Error Codes**:

* `200`: Success
* `500`: Internal Server Error

### 2. Chat Completion API

#### **2.1 Chat Completion**

**Endpoint**: `POST /ai/chat/completions`

**Description**: Create a chat completion request, supporting both streaming and non-streaming responses

**Authentication**: Access Key

**Request Parameters**:

| Parameter           | Type         | Required | Description                                      |
| ------------------- | ------------ | -------- | ------------------------------------------------ |
| `model`             | string       | Yes      | The ID of the model to use                       |
| `messages`          | array        | Yes      | Array of conversation messages                   |
| `stream`            | boolean      | No       | Whether to use streaming response, default false |
| `max_tokens`        | integer      | No       | Maximum number of tokens to generate             |
| `temperature`       | number       | No       | Sampling temperature, 0-2, default 1             |
| `top_p`             | number       | No       | Nucleus sampling parameter, 0-1, default 1       |
| `n`                 | integer      | No       | Number of responses to generate, default 1       |
| `stop`              | string/array | No       | Stop generation tokens                           |
| `presence_penalty`  | number       | No       | Presence penalty, -2.0 to 2.0, default 0         |
| `frequency_penalty` | number       | No       | Frequency penalty, -2.0 to 2.0, default 0        |
| `logit_bias`        | object       | No       | Modify sampling probability for specified tokens |
| `user`              | string       | No       | User identifier                                  |

**Request Example**:

```json
{
  "model": "qwen/qwen3-coder-480b-instruct-fp8",
  "messages": [
    {
      "role": "user",
      "content": "Hello, how are you?"
    }
  ],
  "temperature": 0.7,
  "max_tokens": 100
}
```

**Non-streaming Response Example**:

```json
{
  "id": "chatcmpl-123",
  "object": "chat.completion",
  "created": 1677652288,
  "model": "qwen/qwen3-coder-480b-instruct-fp8",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! I'm doing well, thank you for asking. How can I help you today?"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 9,
    "completion_tokens": 12,
    "total_tokens": 21
  }
}
```

**Streaming Response Example**:

```
data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"qwen/qwen3-coder-480b-instruct-fp8","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}

data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"qwen/qwen3-coder-480b-instruct-fp8","choices":[{"index":0,"delta":{"content":"Hello"},"finish_reason":null}]}

data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"qwen/qwen3-coder-480b-instruct-fp8","choices":[{"index":0,"delta":{"content":"!"},"finish_reason":null}]}

data: [DONE]
```

**Error Codes**:

* `200`: Success
* `400`: Bad Request
* `401`: Unauthorized
* `402`: Billing Check Failed
* `404`: Model Not Found
* `429`: Rate Limit Exceeded
* `500`: Internal Server Error

### 3. Text Completion API

#### **3.1 Text Completion**

**Endpoint**: `POST /ai/completions`

**Description**: Create a text completion request, supporting both streaming and non-streaming responses

**Authentication**: Access Key

**Request Parameters**:

| Parameter           | Type         | Required | Description                                      |
| ------------------- | ------------ | -------- | ------------------------------------------------ |
| `model`             | string       | Yes      | The ID of the model to use                       |
| `prompt`            | string/array | Yes      | Prompt text                                      |
| `suffix`            | string       | No       | Suffix to append after inserted text             |
| `max_tokens`        | integer      | No       | Maximum number of tokens to generate             |
| `temperature`       | number       | No       | Sampling temperature, 0-2, default 1             |
| `top_p`             | number       | No       | Nucleus sampling parameter, 0-1, default 1       |
| `n`                 | integer      | No       | Number of responses to generate, default 1       |
| `stream`            | boolean      | No       | Whether to use streaming response, default false |
| `logprobs`          | integer      | No       | Return log probabilities for most likely tokens  |
| `echo`              | boolean      | No       | Whether to echo the prompt, default false        |
| `stop`              | string/array | No       | Stop generation tokens                           |
| `presence_penalty`  | number       | No       | Presence penalty, -2.0 to 2.0, default 0         |
| `frequency_penalty` | number       | No       | Frequency penalty, -2.0 to 2.0, default 0        |
| `best_of`           | integer      | No       | Select from best candidates, default 1           |
| `logit_bias`        | object       | No       | Modify sampling probability for specified tokens |
| `user`              | string       | No       | User identifier                                  |

**Request Example**:

```json
{
  "model": "qwen/qwen3-coder-480b-instruct-fp8",
  "prompt": "Complete this sentence: The quick brown fox",
  "max_tokens": 20,
  "temperature": 0.5
}
```

**Response Example**:

```json
{
  "id": "cmpl-123",
  "object": "text_completion",
  "created": 1677652288,
  "model": "qwen/qwen3-coder-480b-instruct-fp8",
  "choices": [
    {
      "text": " jumps over the lazy dog",
      "index": 0,
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 5,
    "completion_tokens": 7,
    "total_tokens": 12
  }
}
```

**Error Codes**:

* `200`: Success
* `400`: Bad Request
* `401`: Unauthorized
* `402`: Billing Check Failed
* `404`: Model Not Found
* `429`: Rate Limit Exceeded
* `500`: Internal Server Error

## Error Code Details

### Common Error Codes

| Error Code | HTTP Status | Description           | Solution                                           |
| ---------- | ----------- | --------------------- | -------------------------------------------------- |
| `400`      | 400         | Bad Request           | Check request parameter format and required fields |
| `401`      | 401         | Unauthorized          | Provide valid Access Key or JWT Token              |
| `402`      | 402         | Billing Check Failed  | Check account balance and billing status           |
| `403`      | 403         | Forbidden             | Confirm user permissions and roles                 |
| `404`      | 404         | Resource Not Found    | Check if resource ID is correct                    |
| `429`      | 429         | Rate Limit Exceeded   | Reduce request frequency or contact administrator  |
| `500`      | 500         | Internal Server Error | Contact technical support                          |

### AI-Specific Error Codes

| Error Code                | Description                                    | Solution                                                    |
| ------------------------- | ---------------------------------------------- | ----------------------------------------------------------- |
| `model_not_found`         | Specified model does not exist                 | Check model ID or use `/ai/models` to get available models  |
| `model_not_supported`     | Model does not support requested functionality | Check model capabilities or use other models                |
| `context_length_exceeded` | Input exceeds model context length limit       | Reduce input length or use models supporting longer context |
| `invalid_parameters`      | Parameter values are invalid                   | Check parameter ranges and formats                          |
| `billing_check_failed`    | Billing check failed                           | Check account balance and billing configuration             |

## Usage Examples

### Python Examples

```python
import requests
import json

# Configuration
API_BASE = "https://apis.gradient.network/api/v1"
API_KEY = "your-access-key-here"

# Chat completion request
def chat_completion(prompt, model="qwen/qwen3-coder-480b-instruct-fp8"):
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    data = {
        "model": model,
        "messages": [{"role": "user", "content": prompt}],
        "temperature": 0.7,
        "max_tokens": 100
    }
    
    response = requests.post(
        f"{API_BASE}/ai/chat/completions",
        headers=headers,
        json=data
    )
    
    return response.json()

# Usage example
result = chat_completion("Hello, how are you?")
print(result)
```

### JavaScript Examples

```javascript
// Configuration
const API_BASE = "https://apis.gradient.network/api/v1";
const API_KEY = "your-access-key-here";

// Chat completion request
async function chatCompletion(prompt, model = "qwen/qwen3-coder-480b-instruct-fp8") {
    const response = await fetch(`${API_BASE}/ai/chat/completions`, {
        method: 'POST',
        headers: {
            'Authorization': `Bearer ${API_KEY}`,
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            model: model,
            messages: [{ role: 'user', content: prompt }],
            temperature: 0.7,
            max_tokens: 100
        })
    });
    
    return await response.json();
}

// Usage example
chatCompletion("Hello, how are you?")
    .then(result => console.log(result))
    .catch(error => console.error(error));
```

### cURL Examples

```bash
# Chat completion
curl -X POST "https://apis.gradient.network/api/v1/ai/chat/completions" \
  -H "Authorization: Bearer your-access-key-here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen/qwen3-coder-480b-instruct-fp8",
    "messages": [{"role": "user", "content": "Hello, how are you?"}],
    "temperature": 0.7,
    "max_tokens": 100
  }'

# Get model list
curl "https://apis.gradient.network/api/v1/ai/models"
```

## Rate Limits and Quotas

### Rate Limits

* **Free Users**: 60 requests per minute
* **Paid Users**: Based on plan, typically 1000-10000 requests per minute

### Token Limits

* **Input Tokens**: Based on model context length limits
* **Output Tokens**: Based on model capabilities and billing limits

### Concurrency Limits

* **Free Users**: Maximum 3 concurrent requests
* **Paid Users**: Based on plan, typically 10-100 concurrent requests

## Best Practices

### 1. Error Handling

```python
try:
    response = chat_completion(prompt)
    if response.get('error'):
        print(f"Error: {response['error']['message']}")
    else:
        print(response['choices'][0]['message']['content'])
except requests.exceptions.RequestException as e:
    print(f"Request failed: {e}")
```

### 2. Streaming Processing

```python
def stream_chat_completion(prompt, model):
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    data = {
        "model": model,
        "messages": [{"role": "user", "content": prompt}],
        "stream": True
    }
    
    response = requests.post(
        f"{API_BASE}/ai/chat/completions",
        headers=headers,
        json=data,
        stream=True
    )
    
    for line in response.iter_lines():
        if line:
            line = line.decode('utf-8')
            if line.startswith('data: '):
                data = line[6:]  # Remove 'data: ' prefix
                if data == '[DONE]':
                    break
                try:
                    json_data = json.loads(data)
                    content = json_data['choices'][0]['delta'].get('content', '')
                    if content:
                        print(content, end='', flush=True)
                except json.JSONDecodeError:
                    continue
```

### 3. Retry Mechanism

```python
import time
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

def create_session_with_retry():
    session = requests.Session()
    retry_strategy = Retry(
        total=3,
        backoff_factor=1,
        status_forcelist=[429, 500, 502, 503, 504]
    )
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    return session

# Use retry session
session = create_session_with_retry()
response = session.post(url, headers=headers, json=data)
```

## Support

If you encounter issues during usage, please:

1. Review the error code descriptions in this document
2. Check request parameters and authentication information
3. Contact the technical support team
4. Check the system status page


# User Experiences

There are many ways to experience Gradient technology with the following products, tailor-made for general users.

<table data-view="cards"><thead><tr><th></th><th></th><th data-hidden data-card-cover data-type="image">Cover image</th></tr></thead><tbody><tr><td><a href="https://chat.gradient.network"><strong>Gradient Chatbot</strong></a></td><td>Distributed inference with top LLMs, powered by Parallax.</td><td><a href="/files/f2WlT3eP0n2WjVQiafPi">/files/f2WlT3eP0n2WjVQiafPi</a></td></tr><tr><td><a href="https://explorer.gradient.network"><strong>Gradient Explorer</strong></a></td><td>Glance through network stats and experience Lattica with distributed video streaming</td><td><a href="/files/hw6DWRkLXu4VX6hdLiyT">/files/hw6DWRkLXu4VX6hdLiyT</a></td></tr><tr><td></td><td></td><td></td></tr></tbody></table>


# Edge Host Pilot Program

{% hint style="info" %}
Status: invite-only.\
\
The team will contact eligible applicants regarding onboarding.
{% endhint %}

To scale distributed compute for AI, we recently launched the Edge Host Pilot Program, inviting enterprises and individuals with powerful, high-availability compute resources to collaborate in shaping the future of distributed intelligence.&#x20;

If you are:

* A data center with idle or underutilized bandwidth or GPU resources, or
* An individual contributor with powerful, high-availability compute resources,

We have already started contacting qualified participants for the next steps. Apply to be an Edge Host on Gradient Network [here](https://t.co/1Yr1BBNiFY).&#x20;


# Sentry Node Open Beta (Concluded)

{% hint style="danger" %}
Status: Concluded
{% endhint %}

The Gradient journey began with the **Sentry Node Open Beta**. The Gradient community’s incredible energy around the Sentry Node Open Beta has brought the network to life. What began as an exploratory initiative has grown into a living foundation powered by thousands of people worldwide.

With millions of participants and billions of Taps, we have established a strong peer-to-peer connectivity foundation. Together, these Sentry Nodes form Lattica, our distributed data communication protocol.\
\
Season 1 has concluded on 28 August 2025, 12:00 UTC, marking the graduation of the Sentry Node Open Beta. Sentry Nodes will no longer accumulate new Uptime or Taps after that.<br>

For our community, this is not the end of participation—it is the beginning of the main act.

#### Where to contribute now

* **Run a Host:** Join the [Edge Host Pilot Program](/user-products/edge-host-pilot-program) to provide compute capacity.
* **Experiment with APIs:** Start building on [Gradient Cloud](/enterprise-solutions/gradient-cloud).
* **Follow Research:** Read our published papers on Parallax and Echo, and try open-sourced models on our [Hugging Face Collection](https://huggingface.co/Gradientresearch).
* Join the conversation and help us grow the [Discord](https://discord.gg/gradientnetwork) community.
* Follow our [X page](https://x.com/Gradient_HQ) and stay tuned for more exciting ways to participate coming soon.&#x20;


# Sentry Nodes User Guide (Legacy)

{% hint style="danger" %}
The Sentry Node Open Beta has graduated. Season 0 and Season 1 are concluded.

Sentry Nodes do not receive rewards at the current moment.\
\
This section is for reference only.
{% endhint %}

Sentry Nodes are privacy-preserving, lightweight (<1MB data usage per month), and efficient Chrome Extensions with intermittent liveliness. They map global connectivity and play an important role Lattica — the data communication protocol.&#x20;

## Get a Sentry Node

{% stepper %}
{% step %}
Sign up on [gradient.network](https://gradient.network).
{% endstep %}

{% step %}
Connect your X account and follow our official X account [@Gradient\_HQ](https://twitter.com/Gradient_HQ).
{% endstep %}

{% step %}
Follow the instructions to download Sentry Node from the Chrome Web Store.
{% endstep %}
{% endstepper %}

## Know your Sentry Node

### Taps

Peer-to-Peer connections are established periodically between two random, arbitrary Sentry Nodes to verify their connectivity. These ephemeral connections are called "Taps".  A Tap is successful when a Peer-to-Peer connection is successfully established.

The success rate of Taps depends on a range of network factors, such as your NAT type.

### **Rewards**

There are multiple ways to get rewards while contributing to Gradient’s pervasive global networking infrastructure.

In Season 1, Sentry Nodes will get:

* **Uptime Rewards** **(will be phased out later in the season)**
* **Tap Rewards (with a daily cap)**
* [**Referral Bonuses**](/user-products/sentry-node-open-beta-concluded/sentry-nodes-user-guide-legacy/rewards-concluded/referral-bonus)
* [**Account Boosts**](/user-products/sentry-node-open-beta-concluded/sentry-nodes-user-guide-legacy/rewards-concluded/account-boosts)

### **Node Status**

* **Good:** The node is successfully connected to the server.
* **Disconnected:** The node is offline. Please check your internet connection.
* **Unsupported:** Your location may be unsupported, or your IP address is unsupported (Proxies, Data Center IPs, IPv6 addresses, IPs with fraudulent risk, etc.)
* **Suspended:** The node is temporarily suspended due to unusual activities. Please refer to our [Community Guidelines](/user-products/sentry-node-open-beta-concluded/sentry-nodes-user-guide-legacy/rewards-concluded/community-guidelines) for more details.

## Manage your Sentry Node

The [Gradient Dashboard](https://app.gradient.network) is your all-in-one terminal for tracking, managing, and optimizing nodes and rewards on the Gradient Network.&#x20;

It offers intuitive visualizations of key account stats, including node status, different types of rewards,  and referral activity. In addition, you can also update your profile to make the Gradient experience a truly personal one.

You can track real-time node activity with key metrics like uptime and taps received, and data transmitted and use these insights to fine-tune your nodes for optimal performance. Rewards are organized into categories—Network, Boosts, and Referrals—so you can easily see how each activity impacts your earnings.

As you advance through account tiers, you'll unlock additional boosts, increasing your reward potential. The referral system allows you to generate and share personal referral codes, and follow up on your referrals.

## Dos and Don'ts

Gradient Network is dedicated to building a network where users can benefit from its **long-term, sustainable growth**. To protect the interests of genuine users, we are committed to implementing the **strictest measures** against harmful actions and fostering a transparent, equitable ecosystem.

### How Sentry Nodes are designed to work:

• Run on personal devices with minimal resource impact\
• No 24/7 attention needed\
• Generate valuable insights into our global network infrastructure.

### What not to do:

Batch account creation, running multiple Sentry Nodes on the same device, using scripts or third-party tools, or other actions that violate our [Community Guidelines](/user-products/sentry-node-open-beta-concluded/sentry-nodes-user-guide-legacy/rewards-concluded/community-guidelines) will result in account restrictions. Please check relevant guidelines regularly and use your Sentry Node in intended ways.


# Rewards (Concluded)

{% hint style="danger" %}
The Sentry Node Open Beta has graduated. Season 0 and Season 1 are concluded.

Sentry Nodes do not receive rewards at the current moment.\
\
This section is for reference only.
{% endhint %}

## Sentry Node Rewards

There are multiple ways to get rewards while contributing to Gradient’s decentralized compute infrastructure.&#x20;

You can:

* **Get Uptime Rewards by staying online. (to be phased out soon)**
* **Get Tap Rewards for making successful "Taps".**
  * Taps are peer-to-peer connections established periodically between two random, arbitrary Sentry Nodes to verify their connectivity.
  * The success rate of Taps depends on a range of network factors, such as your NAT type.
* **Get** [**Referral Bonuses**](/user-products/sentry-node-open-beta-concluded/sentry-nodes-user-guide-legacy/rewards-concluded/referral-bonus) **with your referrals;**
* [**Boost** ](/user-products/sentry-node-open-beta-concluded/sentry-nodes-user-guide-legacy/rewards-concluded/account-boosts)**your rewards by completing achievements.**

## Seasons

Seasons represent distinct periods of reward distribution. New seasons will be introduced alongside future milestones.

Reward schedules may vary between seasons, and points are non-fungible across seasons.

The current Season is [**Season 1**](/user-products/sentry-node-open-beta-concluded/sentry-nodes-user-guide-legacy/rewards-concluded/seasons/season-1).

## Community Guidelines

Gradient Network encourages genuine participation that supports the platform's growth in the long term. We are actively taking actions against Sybil and other harmful behaviors.

Please refer to our [**Community Guidelines**](#community-guidelines) or the updated DOs and DON'Ts on Sentry Nodes.


# Seasons

{% hint style="success" %}
**Live: Season 1**
{% endhint %}

Seasons represent distinct periods of reward distribution. New seasons will be introduced alongside future milestones.\
\
Reward schedules may vary, and points are non-fungible across seasons.

| Seasons  | Start Date              | End Date            |
| -------- | ----------------------- | ------------------- |
| Season 1 | **15th April 2025**     |                     |
| Season 0 | **12th September 2024** | **14th April 2025** |


# Season 1

{% hint style="success" %}
Season 1 is now live.<br>

Season 1 marks the beginning of Homogenized Computation with a rebalanced incentive structure.
{% endhint %}

Evolving from Season 0, Season 1 introduces reward structure upgrades that stay true to how Sentry Nodes were designed to work:

• Run on personal devices with minimal resource impact\
• No 24/7 attention needed\
• Generate valuable insights into our global network infrastructure.

## Tap Rewards

* You’ll now earn 10 points for every successful Tap.
* A daily cap on Tap rewards is now in place:

  * 120 points per day per Sentry Node
  * 120 points per day per unique IP address

  Both limits apply concurrently, and your rewards will be capped once any of the limits is reached first.

## Uptime Rewards

At the beginning of Season 1, Sentry Node users will earn 0.15 points for every 10 minutes of Uptime. Later in the Season, we plan to gradually phase out Uptime rewards, shifting incentives toward the generation of valuable network insights.

### <br>

### <br>


# Season 0

{% hint style="info" %}
Season 0 has ended.<br>

Season 0 marks the beginning of Sentry Node Open Beta, the first step towards Pervasive Connectivity.
{% endhint %}

## POA Rewards

A Sentry Node receives **0.25 Points for every 10 minutes of Network Uptime**.

## POC Rewards

{% hint style="info" %}
Peer-to-Peer connections are established periodically between two random, arbitrary Sentry Nodes to verify their connectivity. These ephemeral connections are called "Taps".  A Tap is successful when a Peer-to-Peer connection is successfully established.
{% endhint %}

A Tap will happen from time to time, and the success rate of Taps depends on a range of network factors such as your NAT type.

Both Sentry Nodes receive **0.75 Points for establishing a successful Tap.**


# Account Boosts

Completing achievements allows users to gain experience (EXP), which helps elevate their account statuses. As users gain more EXP and unlock higher status levels, they will receive a higher reward boost that benefits all nodes associated with the account.

<table><thead><tr><th width="363">Account Status</th><th>Reward Boost</th></tr></thead><tbody><tr><td>Iron</td><td>0%</td></tr><tr><td>Bronze</td><td>2%</td></tr><tr><td>Silver</td><td>4%</td></tr><tr><td>Gold</td><td>6%</td></tr><tr><td>Platinum</td><td>8%</td></tr><tr><td>Diamond</td><td>10%</td></tr></tbody></table>

{% hint style="info" %}
Reward Boost applies to Uptime and Tap rewards.&#x20;

NOT applicable to Referral Bonuses.
{% endhint %}


# Referral Bonus

The referral system allows users to get bonus rewards by expanding their referral network and engaging with it, all while contributing to the growth and success of the platform.

There are 2 ways to get rewards from referrals:

1. One-time bonus: Both parties of a referral will get 20 points when your referee reaches 72 hours of uptime.
2. Perpetual bonus: Referrers will get a perpetual bonus of their primary and secondary referees' rewards：

{% tabs %}
{% tab title="Primary Referral " %}
When you refer a new user to contribute to the network, you will get a **10%** bonus for their Uptime and Tap rewards.&#x20;
{% endtab %}

{% tab title="Secondary Referral" %}
When your primary referees refer other users (secondary referral), you will get an extra **5%** of Uptime and Tap rewards from your secondary referees.
{% endtab %}
{% endtabs %}


# Community Guidelines

v1.0.0 - 5 Nov 2024

Thank you for being part of the #GradientSentry community!

Gradient Network is dedicated to building a network where users can benefit from its **long-term, sustainable growth**. We value fair and honest participation, as this is the only way to achieve that goal. To protect the interests of genuine users, we are committed to implementing the **strictest measures** against harmful actions and fostering a transparent, equitable ecosystem.

{% hint style="warning" %}
Our team is constantly optimizing our methods to identify behaviors that may be harmful to our ecosystem and users. Please be advised that the team reserves the right to **retrospectively slash points** earned through Sybil or fraudulent activities.

These guidelines will be updated periodically, so please check this page regularly for the latest version.&#x20;
{% endhint %}

### 1. Each user should register for only one account.

<figure><img src="/files/VtBlv1oWbTvIhSxR3KEM" alt=""><figcaption></figcaption></figure>

### 2. Install only one Sentry Node on each device.

<figure><img src="/files/5CNt69M5YxWdoPoWztmE" alt=""><figcaption></figcaption></figure>

### 3. Rules on multiple Sentry Nodes.

Users can have multiple Sentry Nodes, as long as other rules are met. However, rewards will be split between Sentry Nodes having the same IP address.

<figure><img src="/files/FvdiPCHktYJtPD3JFI0E" alt=""><figcaption></figcaption></figure>

### 4. Certain IP types are not supported by the network.&#x20;

Sentry Nodes with an “Unsupported” status will stop receiving rewards. Rewards will resume accumulating once the status changes to “Good”.

<figure><img src="/files/pLyOh7ZtGAf3qgYVcrHW" alt=""><figcaption></figcaption></figure>

### 5. Keep your Sentry Node updated.&#x20;

Ensure you are always using the latest version of the Sentry Node. Certain features and rewards may not be available on older versions.

* Check your current version:
  * Click your profile picture on your Sentry Node extension;
  * Click "About";
  * Find your current version number after "Version:".
* Update your Sentry Node:  [Please refer to this section.](https://docs.gradient.network/user-products/sentry-node-open-beta-concluded/sentry-nodes-user-guide-legacy/rewards-concluded/pages/aG2hYXEw6AivWzyeD59d#id-1.-update-your-sentry-node)
* Check the latest version number: [Visit the Chrome Web Store](https://chromewebstore.google.com/detail/gradient-sentry-node/).


# FAQ

## General

#### **What is Gradient building?**

> Gradient is building the world’s first fully distributed AI stack — a peer-powered infrastructure where intelligence is hosted, served, and owned by the people.

#### **What makes Gradient different?**

> Instead of running models in closed datacenters, Gradient is distributing AI workloads across a global mesh of consumer devices and compatible datacenters. This reduces cost, improves resilience, and democratizes access.

***

### Research

#### What has Gradient done in the field of distributed AI?

> We have released research and products on:\
> [Lattica](/the-open-intelligence-stack/lattica) (peer-to-peer data communication)\
> [Parallax](/the-open-intelligence-stack/parallax) (distributed inference) \
> [Echo](/the-open-intelligence-stack/echo) (distributed reinformcement learning)\
> \
> More work on multi-agent collaboration, self-evolving agentic systems are more are in the pipeline.

***

#### Sentry Nodes

**Is the Sentry Node Open Beta still active?**

> No. The Open Beta has concluded and Sentry Nodes are no longer accumulating new Uptime or Taps rewards.\
> \
> The sections on Sentry Nodes within this documentation is for reference purposes only.

***

### **What’s next**

> The team is constantly cooking. Stay tuned for more seamless, tangible experience, where every community member will gain direct access to the full power of distributed intelligence.

{% hint style="warning" %}
**Scam Alert**\
\
We've received multiple reports of phishing emails impersonating Gradient. \
\
These emails may ask for donations or prompt you to interact with third-party URLs. These are **100% scams**. A closer look at the sender's address will easily reveal their true identity.\
\
\- Do NOT interact with any unknown site. Check the URL letter by letter.\
\- Do NOT respond to emails claiming to represent Gradient.\
\- Gradient will NEVER ask for donations or request payments via email or DMs.\
\- Trust only information from our official channels.
{% endhint %}

### **Where can I get real-time updates from Gradient?**

Follow our official channels and never miss a beat:

* [Website](https://gradient.network)
* [X](https://x.com/Gradient_HQ)
* [Discord](https://discord.com/invite/gradientnetwork)


# Official Links

{% hint style="warning" %}
**Scam Alert**\
\
We've received multiple reports of phishing emails impersonating Gradient. \
\
These emails may ask for donations or prompt you to interact with third-party URLs. These are **100% scams**. A closer look at the sender's address will easily reveal their true identity.\
\
\- Do NOT interact with any unknown site. Check the URL letter by letter.\
\- Do NOT respond to emails claiming to represent Gradient.\
\- Gradient will NEVER ask for donations or request payments via email or DMs.\
\- Trust only information from our official channels.
{% endhint %}

* [Website](https://gradient.network)
* [X](https://x.com/Gradient_HQ)
* [Discord](https://discord.com/invite/gradientnetwork)
* [Gradient Explorer](https://explorer.gradient.network)
* [Hugging Face](https://huggingface.co/GradientResearch)
* [Careers](https://careers.gradient.network/)


# Page


# Layers


# Resource Layer

The resource layer mainly consists of two parts:

* **Resource Aggregation/Abstraction Layer:** Digital resources nowadays are ubiquitous and mostly underutilized. From edge servers to consumer-level hardware, abundant computational power/storage capacity/bandwidth is waiting for us to tap into. The resource aggregation layer serves as the platform abstraction layer, onboarding those resources to establish a strong network.
* **Service Scheduling Layer:** Cloud-native architecture supported by Kubernetes enabled smooth deployment/scaling of microservices at the center, supporting most of the modern applications that we enjoy every day. We believe such a revolution is long-due in the edge space. Our service scheduling layer acts as the intelligent housekeeper between services and the physical resources that are most suited to deploy them, bringing efficiency, utilization optimization, and developer friendliness to the whole edge experience.


# Orchestration Layer

Once the resources are successfully virtualized & the services are successfully deployed, the service & task orchestration layer comes into play. It is the ultimate commander of the battlefield, redirecting every task to the optimal node equipped with resources to serve each request. At Gradient, we will make an effort to develop in-house services & task orchestrators, while also leveraging the power of the community & our partners, to build a vibrant service economy.


# Networking Layer

In any distributed system, Peer-to-Peer communication between machines is crucial for executing workloads. The connectivity and latency between nodes are key factors that determine the network's performance and robustness. In Gradient Network, Sentry nodes play a vital role in enabling effective network discovery, forming the backbone of a strong and resilient mesh network.&#x20;

Together, Sentry nodes all around the world create a P2P connection infrastructure that generates valuable insights to optimize the usage of the network.


# Troubleshoot

This page will be updated regularly.

## 1. How to update your Sentry Node

Your Sentry Node extension should automatically update to the latest version.&#x20;

If it doesn't update automatically, please update it manually by following the steps below:

{% stepper %}
{% step %}

#### Open the Extension Page

Open your Chrome browser and go to "**chrome://extensions/"** from your address bar.&#x20;
{% endstep %}

{% step %}

#### Turn on Developer Mode

On the top right corner of the Extensions page, toggle on “**Developer mode**.”  This will enable additional options, including manually updating your extensions.
{% endstep %}

{% step %}

#### Click to Update

If an update is available, click the "**Update"** button on the top left corner.

Chrome will automatically check and install available updates. You’ll see a notification once the update is completed.
{% endstep %}
{% endstepper %}

You can also try restarting your Chrome browser. It’s recommended to keep your browser up to date as well.

## 2. Unsupported Status

To maintain the security and stability of our network while adhering to local regulations, we’ve implemented safeguards that may restrict access in certain cases.

### Why You’re Seeing an “Unsupported” Status?

* Unsupported Region: Your location may be in a region where our services are unavailable due to restrictions and regulations, including Afghanistan, Antigua and Barbuda, Belarus, Central African Republic, China, Crimea and Sevastopol, Cuba, Eritrea, Iran, Iraq, Lebanon, Libya, Myanmar, North Korea, Somalia, Syria, Sudan, and the Donetsk and Luhansk regions of Ukraine.
* Unsupported IP Address: This can occur due to various reasons such as using a VPN, proxies, data center IPs, cloud hosting IPs, or IPs flagged for fraudulent risk.

### Tips to Resolve the Issue:

* Turn Off VPN: If you’re using a VPN,  please disable it. It's against the Community Guidelines to access the platform via VPNs. Please relaunch the browser once the VPN is turned off, and wait for 15 minutes before the node reconnects.
* Try a Different Network: If the issue persists, attempt to connect using a different network or IP.
* Check IP Quality: If none of the above works, your IP quality might be suboptimal.

{% hint style="warning" %}
Sentry Nodes with "Unsupported" status will stop receiving rewards. Rewards will start to accumulate  once your node status changes to "Good".

Deleting and reinstalling your Sentry Node won't change your "Unsupported "status, as long as your IP address stays the same.

It's also against the [Community Guidelines](/user-products/sentry-node-open-beta-concluded/sentry-nodes-user-guide-legacy/rewards-concluded/community-guidelines) to install multiple Sentry Nodes on one device.
{% endhint %}

### How to Check Your IP Quality?

You can verify the status of your IP address using these tools:

* [IPQualityScore](https://www.ipqualityscore.com/)
* [IP2Location](https://www.ip2location.com/)
* [IPinfo](https://ipinfo.io/)

We’re committed to fostering organic community participation. If it shows “Proxy: true” “VPN: true” or “Connection Type: Data Center”. You might need to change your IP address to participate in the network.

## 3. Users with multiple Sentry Nodes

You can have multiple Sentry Nodes under a single user account, as long as they are installed in different devices. You should only install one Sentry Node on each device.

### Sentry Nodes with the same IP

Please note that multiple Sentry Nodes sharing the same IP address will split rewards distributed to that IP address.

### Sentry Node with different IPs

Sentry Nodes with different IP addresses will receive rewards separately, provided other guidelines are met.&#x20;

Please refer to our [Community Guidelines](/user-products/sentry-node-open-beta-concluded/sentry-nodes-user-guide-legacy/rewards-concluded/community-guidelines) for more information.

## 4. The Uptime of my Sentry Nodes isn't increasing

Uptime is calculated and updated every 10 minutes. To reflect the next stats update, your Sentry Node must remain online for more than 10 minutes.

If your node is running in the background but the uptime isn’t increasing, it may be due to intermittent unavailability within the 10-minute window. This is often caused by network instability, a closed browser, or other connectivity issues. We recommend ensuring a stable internet connection to maintain uptime.

## 5. How can I get more "Taps"?

Peer-to-peer connections are established periodically between two random, arbitrary #GradientSentry Nodes to verify their connectivity. These ephemeral connections are called "Taps". &#x20;

A Tap is successful when a Peer-to-Peer connection is successfully established. The successful rate depends on a range of network factors such as your NAT type.

## 6. Sentry Node Extension / The Globe Not Launching

### Possible Causes:

* WebGL Disabled or Unsupported: Your browser may have WebGL turned off or it’s unsupported.
* Device Compatibility: Outdated or incompatible graphics drivers could be the issue.
* Graphic acceleration is disabled in Chrome.

### Solutions:

1. Enable WebGL: For Chrome, type chrome://gpu in the address bar to check WebGL status and enable hardware acceleration if needed.
2. Update Graphics Drivers: Make sure your graphics drivers are up to date, or try using the extension on another device.
3. Make sure you turn on graphic acceleration in Chrome. Go to Settings -> System -> Use graphics acceleration when available.

## 7. Account Access Restricted

This restricton may be the result of unusual account activity, such as batch account creation, use of scripts or third-party tools, or other actions that violate our Community Guidelines.

At Gradient Network, we're committed to fostering a fair and authentic ecosystem that delivers long-term value for all users. To uphold this integrity, we reserve the right to slash points earned through Sybil or other fraudulent behavior.

We genuinely appreciate your interest in participating and aim to be as transparent as possible, so you can avoid spending time or resources on actions that could lead to unexpected restrictions. Please make sure to regularly review our  [Community Guidelines](/user-products/sentry-node-open-beta-concluded/sentry-nodes-user-guide-legacy/rewards-concluded/community-guidelines) and use the Sentry Node as intended.

If you believe this restriction was applied in error, you may submit an appeal at:\
<https://60dg31uzjwh.typeform.com/appeal>

Appeals are reviewed within 7 working days. If your account remains restricted after that period, the appeal was not successful. Please avoid submitting multiple appeals.


# Worker Node Rewards

## Overview

Worker nodes receive rewards based on both Proof of Connectivity (POC) and Proof of Work (POW) activities.

### POC Rewards

$$
R\_(poc\_) = k\_(poc\_)  ⋅ T ⋅ S ⋅ (1+A)
$$

&#x20;POC rewards for worker nodes are determined by 4 factors:

* *T:* The **Total Uptime** the node is connected to the network, adjusted by liveliness checks done by other nodes.
* *S:* [**Node Score**](/hide/worker-node-rewards/node-score) of each connected worker node.
* *𝑘 (POC):* **Reward Coefficient,** determining the base reward received for every unit of validated uptime.
* *A:* [**Account Status**](broken://pages/DGYchPnEesBIt5WqQ2h6) **Boost:** Users can advance to higher levels by unlocking new achievements. Higher account tiers yield greater reward boosts.&#x20;

### POW Rewards

$$
R\_(pow\_)= k\_(pow\_) ⋅ W ⋅ S ⋅ (1+A)
$$

POW rewards for worker nodes are  determined by 4 factors:

* *W:* The **Total Time** the node spent to complete designated tasks on the network, assigned by the resource manager and verified by validators.
* *S:* [**Node Score**](/hide/worker-node-rewards/node-score) of each connected work node.
* *𝑘 (POW):* **Reward Coefficient,** determining the base reward received for every unit of validated working time.
* *A:* [**Account Status**](broken://pages/DGYchPnEesBIt5WqQ2h6) **Boost:** Users can advance to higher levels by unlocking new achievements. Higher account tiers yield greater reward boosts.


# Node Score

{% hint style="warning" %}
算法需要重新调整。
{% endhint %}

$$
S = N⋅H ⋅C
$$

Node Score (S) is determined by 3 factors:

* **Network Score (N)** evaluates the reliability of your current network. Factors such as NAT type, NAT consistency, outbound bandwidth, and average latency will be considered.
* **Hardware Score (H)** considers \*\*\*\*the capabilities of your connected hardware, from CPU, GPU, RAM, disk space, to disk type, etc. High-performing hardware can boost the efficiency and performance of the network and thus will be given a higher score.
* **Consistency Score (C)** assesses the consistency of worker nodes’ availability over a period of time. Consistency in node availability is proof of reliability and trustworthiness.

## Network Score (N)

<details>

<summary>Factors Affecting Network Score</summary>

Network Score is affected by various factors. Initially, we will include the following criteria, but the list will continue to evolve:

* **NAT Type**: NAT (Network Address Translation) Type refers to the strictness of a router in allowing connections from outside networks. The ranking of NAT Types from least restrictive to most restrictive is as follows: Static>DMZ>PAT>Full Cone>IP Restricted Cone>Port Restricted Cone>Symmetric. There are several types of NAT:
  * Static NAT (Network Address Translation) refers to a type of NAT where each private IP address is mapped to a corresponding public IP address. This mapping is consistent and does not change over time. Static NAT is typically used when a device, such as a server, needs to be accessible from the internet.
  * DMZ (De-Militarized Zone) in the context of NAT (Network Address Translation) refers to a network setup where a particular device (like a server) is placed outside the main network's security firewall. This allows unrestricted network access to that device, making it readily accessible over the internet. However, it also exposes the device to potential external threats, hence it's typically used for servers that need to be publicly accessible yet isolated from internal networks for security reasons.
  * PAT, or Port Address Translation, is a type of NAT (Network Address Translation). In PAT, all devices on the local network are mapped to a single public IP address, but each device is assigned a specific port number. This way, the router can determine which device to forward incoming packets to based on the port number. PAT is a common method used in home networks due to its efficient use of limited public IP addresses.
  * Full Cone: All requests from the same internal IP address and port are mapped to the same external IP address and port. Any external host can send packets to the internal host by sending packets to the mapped external IP address and port.
  * Restricted Cone: As with Full Cone, all requests from the same internal IP address and port are mapped to the same external IP address and port. However, an external host can send packets to the internal host only if the internal host has previously sent a packet to the external host.
  * Port-Restricted Cone: This is a more restricted type of NAT. The router keeps track of the port numbers on the external host that the internal host communicates with. The router allows incoming packets to those port numbers only.
  * Symmetric: This is the most restrictive NAT type. Each time the same internal device sends a packet to a destination, a new port is used and mapped for the return packets from that destination. This makes it very difficult for incoming connections to be made to the internal device unless the device has initiated the connection.
* **NAT Consistency**: NAT Consistency refers to the predictability and reliability of a NAT (Network Address Translation) type in maintaining and managing the network connection.
* **Outbound Bandwidth**: Outbound bandwidth refers to the maximum rate of data transfer from a particular system or network to another system or network. It's measured in bits per second (bps). It plays a crucial role in network performance as it affects the speed and quality of data transmission. Higher outbound bandwidth typically indicates better network performance.
* **Average Latency**: Average latency refers to the average amount of time it takes for data to travel from one point to another in OpenEdge network, checked by all the Sentry Nodes periodically. Lower latency signifies a more efficient and high-performing network as data transmission is faster, leading to a better user experience.

</details>

**Network Scores** will be assigned to nodes according to the conditions below:

<table><thead><tr><th width="138">Score</th><th width="117">1</th><th width="140">2</th><th width="121">3</th><th>4</th><th>5</th></tr></thead><tbody><tr><td>NAT Type</td><td>Symmetric</td><td>Port Restricted Cone</td><td>IP Restricted Cone</td><td>Full Cone</td><td>PAT/DMZ/Static</td></tr><tr><td>NAT Consistency</td><td>Not consistent</td><td>Slightly consistent</td><td>Moderately consistent</td><td>Mostly consistent</td><td>Fully consistent</td></tr><tr><td>Outbound Bandwidth</td><td>&#x3C;100Mbps</td><td>[100Mbps, 500Mbps)</td><td>[500Mbps, 1Gbps)</td><td>[1Gbps, 3Gbps)</td><td>>3Gbps</td></tr><tr><td>Average Latency (ms)</td><td>[200,+∞)</td><td>[100,200)</td><td>[50,100)</td><td>[20,50)</td><td>[0,20)</td></tr></tbody></table>

## Hardware Score (H)

<details>

<summary>Factors Affecting Hardware Score</summary>

* **CPU**: The processing power of the CPU (Central Processing Unit) is crucial for performance. The number of cores and clock speed can significantly affect the node's efficiency.
* **GPU**: The GPU (Graphics Processing Unit) is important for tasks that require high computational power, such as machine learning and data processing.
* **RAM**: RAM (Random Access Memory) affects the node's ability to handle multiple tasks simultaneously. More RAM generally leads to better performance.
* **Disk Space**: Sufficient disk space is necessary for storing data and running applications smoothly. It's measured in gigabytes (GB) or terabytes (TB).
* **Disk Type**: The type of hard disk (e.g., HDD vs. SSD) can impact read/write speeds. SSDs (Solid State Drives) are generally faster and more reliable than HDDs (Hard Disk Drives

</details>

**Hardware Scores** will be assigned to nodes according to the conditions below:

<table data-full-width="false"><thead><tr><th>Score</th><th>1</th><th>2</th><th>3</th><th>4</th><th>5</th></tr></thead><tbody><tr><td>CPU (Cores)</td><td>&#x3C;4</td><td>4-8</td><td>8-16</td><td>16-32</td><td>>32</td></tr><tr><td>GPU</td><td>Integrated</td><td>Entry-Level</td><td>Mid-Range</td><td>High-End</td><td>Top-Tier</td></tr><tr><td>RAM (GB)</td><td>&#x3C;8</td><td>8-16</td><td>16-32</td><td>32-64</td><td>>64</td></tr><tr><td>Disk Space (GB)</td><td>&#x3C;256</td><td>256-512</td><td>512-1024</td><td>1TB-2TB</td><td>>2TB</td></tr><tr><td>Disk Type</td><td>HDD</td><td>Hybrid</td><td>SSD</td><td>NVMe SSD</td><td>Top-Tier NVMe SSD</td></tr></tbody></table>

## Consistency Score (C)

<details>

<summary>Factors affecting Consistency Score</summary>

The Consistency Score (C) is evaluated based on 7-day moving average up-time and liveliness over a period of time:

* **Average Up-time**: This refers to the percentage of time that the node is operational and accessible when checked by a centralized server.
* **Average Liveliness**: This refers to the percentage of time that the node is available and responsive when checked by random Sentry Nodes from the entire network.

</details>

**Consistency Scores** will be assigned to nodes according to the conditions below:

<table><thead><tr><th width="121">Score</th><th>1</th><th>2</th><th>3</th><th>4</th><th>5</th></tr></thead><tbody><tr><td>Moving Average Uptime</td><td>&#x3C;25%</td><td>25-50%</td><td>50-75%</td><td>75-90%</td><td>>90%</td></tr><tr><td>Moving Average Liveliness</td><td>&#x3C;25%</td><td>25-50%</td><td>50-75%</td><td>75-90%</td><td>>90%</td></tr></tbody></table>


# Improve My Rewards


# Achievements

The Achievement System is designed to encourage and reward users for their active engagement and contributions to the network. Users accumulate EXP (Experience Points) by completing achievements, which then unlocks new account status levels.

## Recurring Achievements

Users will complete recurring achievements through continuous engagement while earning EXP along the way.

## One-Time Achievements

There's a growing list of one-time accomplishments users can complete for extra EXP.