# Entering Chasm

Introduction to Chasm

Chasm is driving innovation in artificial intelligence by offering a comprehensive ecosystem for creating, deploying, and monetizing AI agents. Our key innovation, Weave, is a powerful AI agent builder IDE that enables users to seamlessly craft and deploy AI agents using a wide array of decentralized compute resources. Our next major advancement is the Chasm Protocol, a network of decentralized experts poised to evolve into a pseudo-AGI intent network. The Protocol will enhance our platform's capability to manage payments for compute resources and facilitate sophisticated exchanges of intents among AI agents, transforming operational dynamics and connectivity within the AI landscape.

In this Gitbook, we outline the fundamental operations and features of the Chasm ecosystem. This information is provided for informational purposes only, without any representation or warranty regarding its accuracy. For further details, please refer to the Terms of Use and other applicable legal agreements, including the Privacy Policy, Scout Terms, and the relevant Software License Agreement. Links to these policies can be found in the footer of our websites.


# Chasm Network

Chasm Network Introduction

Chasm is a distributed competitive AI inferencing network that delivers the best performing, highest quality, and most cost-efficient inferences to its users. Chasm pushes the AI industry forward by realizing decentralized Mixture-of-Experts through our network, effectively utilizing different specialized intelligence models to work together to provide the best possible results.

Chasm Network lives on [Mantle Mainnet](https://www.mantle.xyz/).


# CAI Token

CAI Token Introduction

## The Role of $CAI in the Chasm Ecosystem

$CAI is the cornerstone token of the Chasm Ecosystem, designed to support and empower builders, scouts, and all participants within the community. Key aspects of $CAI include:

* **Empowerment and Recycling:** $CAI tokens are recycled to create Expansion Scouts. The required number of $CAI tokens for becoming an Expansion Scout is determined by a bonding curve mechanism.
* **Benefits for Holders:** $CAI holders enjoy various benefits such as discounts, access to exclusive ecosystem services, and potential airdrops from partners and projects.
* **Facilitation of Elections:** $CAI is instrumental in facilitating elections, enabling the onboarding of orchestrators in a Proof of Authority setup.

## Tokenomics

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

#### 1.1 Basic Details

* Token Name: Chasm AI
* Token Ticker: $[CAI](https://www.coingecko.com/en/coins/chasm)
* Total Supply: 1,000,000,000 (1 billion) tokens

#### 1.2 Future and Current Token Utility

* Governance: $CAI holders can participate in network governance decisions
* Access Token: Users can pay $CAI to access different resources available in Chasm Network. (Payment for API/Prompt/Workflow access on Weave Marketplace)
* Reward for Proof of Work (PoW): Miners/validators earn $CAI for bootstrapping the network
* Payment Token: Used to compensate for work done within the ecosystem
* Registration Fee: Scouts must pay a fee in $CAI to register on the network

Note: $CAI will not function as the de-facto currency within the network, but is a possible choice.

### 2. Scout Reward System

#### 2.1 Weekly Reward Pool

* $CAI mining reward pool is 50% of the total supply, or 500,000,000 tokens
* Total $CAI released weekly is scaled based on the amount of nodes present in the system.

### 3. User Payments

#### 3.1 User Payments (future implementation)

* Users can pay inference USD/USDC for consistent billing
* Fiat onboarding solution to exchange USD for USDC

#### 3.2 Payment Calculation

* Scout payment: Based on competitive free market rates
* Orchestrator payment: Cost of Scouts + Routing Cost set by orchestrator

### 4. Potential future implementations

#### 4.1 Network Fees

* Potential fixed-cut tax on network payments
* Additional small fees for various network usages

#### 4.2 Priority Queue System

* VIP system for high-performing scouts
* Entry requires burning, recycling, or staking $CAI
* Provides access to a limited queue for top server status and increased job opportunities

### 5. Summarized Token Release Schedule and Distribution

* Investors Allocation: 15% (6 months cliff, 2 years vesting)
* Team: 20% (1 year cliff, 3 years vesting)
* Treasury: 15% (Unlocked via DAO voting)
* Scouts: 50% (Released via mining emission)

*Note: The tokenomics are subject to potential changes.*


# Chasm FAQ

Ongoing page on FAQ's

### How do I add Mantle to my ETH wallet?

<https://chainlist.org/?search=mantle>

### I'm looking to use Chasm Network to power my applications. How do I get started?

Reach out to us on <https://x.com/ChasmNetwork>, or alternatively get started today on <https://weave.chasm.net/>

### What are the differences between a Prompt and an Intent in the context of Chasm Network?

A prompt, in our context, is a unit that addresses a specific problem. It can be referred to as a Single-Issue Prompt as it focuses on a single question.

> e.g.: Are dogs carnivores or herbivores?

On the other hand, an intent is a complex set of instructions that can be broken down into multiple prompts. It may have several goals and handling methods, which can influence the final output. An intent could also be a very open-ended question.

> e.g.: Generate a game world system based on the Harry Potter novel series.

In its advanced stage, ChasmRouter will be capable of decomposing complex intents and managing them appropriately. In the example above, a sequence of specific intents will be created and linked together in Weave’s style, then evaluated individually.


# Chasm DeAI Jokers

The DeAI Jokers are the genesis drop for Chasm. It was a surprise drop as a part of the decentralized AI movement, and a very limited amount of Jokers was minted.

{% embed url="<https://opensea.io/collection/deaijoker>" %}

The DeAI Jokers genesis NFT drop offers a unique opportunity for early adopters to gain exclusive benefits within the Chasm Foundation, a web3 AI ecosystem. By holding a DeAI Jokers NFT, users can unlock a range of rewards and privileges designed to enhance their experience and engagement with the platform.

**Key Benefits of Holding a DeAI Jokers NFT**

1. **Early Access to Ecosystem Features**: Gain priority access to new features and tools within the Chasm Foundation. Be the first to test and utilize cutting-edge AI solutions, applications, and integrations as they are rolled out.
2. **Enhanced Earning Potential**: Leverage your DeAI Jokers NFT to boost your earning potential within the ecosystem. Participate in staking programs, liquidity pools, and other incentive structures designed to reward active and engaged community members.
3. **Redacted :)**


# Chasm API Documentation

## Chasm API Documentation

Welcome to the Chasm API documentation. This guide provides all the information you need to start using our OpenAI-compatible API endpoint. Whether you're a public user or a Scout member with an API key, this documentation will help you understand how to interact with the Chasm Orchestrator effectively.

### Introduction

The Chasm API allows developers to integrate advanced language processing capabilities into their applications. Our API is designed to be compatible with OpenAI's API, making it easy to switch or integrate alongside existing solutions.

**API Endpoint:**

```
https://orchestrator.chasm.net/v1/chat/completions
```

### Getting Started

#### Public Access

Public users can start using the API immediately without any authentication. However, public access is subject to rate limits to ensure fair usage.

**Public Rate Limits:**

* **10 requests per minute**
* **100 requests per day**

#### API Key Access

For higher usage needs, users can obtain an API key by becoming a Scout member. With an API key, you benefit from increased rate limits.

**API Key Rate Limits:**

* **100 requests per minute**
* **5,000 requests per day**

### Authentication

#### Using an API Key

To authenticate your requests using an API key, include the following header in your HTTP requests:

```
Authorization: Bearer YOUR_API_KEY
```

Replace `YOUR_API_KEY` with the API key generated from your Scout account.

#### Without an API Key

If you're using the API without an API key, no additional headers are required. Simply make your requests to the endpoint, keeping in mind the public rate limits.

### Rate Limits

Rate limits are enforced to maintain the quality of service for all users.

#### Public Users

* **10 requests per minute**
* **100 requests per day**

#### API Key Holders (Scout Members)

* **100 requests per minute**
* **5,000 requests per day**

### Generating and Managing API Keys

#### Generating an API Key

1. Log in to your Scout account at [scout.chasm.net](https://scout.chasm.net).
2. Navigate to the **API Keys** section in your account dashboard.
3. Click on **Generate New API Key**.
4. Copy the generated API key. **Note:** This is the only time the full key will be displayed. Store it securely.

#### Removing an API Key

1. In the **API Keys** section, locate the API key you wish to remove.
2. Click on the **Delete** button next to the key.
3. Confirm the action when prompted.

### Making API Requests

#### Request Structure

Send a `POST` request to the API endpoint with the required headers and JSON body.

**Endpoint:**

```
https://orchestrator.chasm.net/v1/chat/completions
```

**Headers:**

* `Content-Type: application/json`
* `Authorization: Bearer YOUR_API_KEY` (only if using an API key)

#### Request Body Example

```json
{
  "model": "gemma2-9b-it",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Can you tell me a joke?"}
  ]
}
```

#### Response Example

```json
{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1700000000,
  "model": "gemma2-9b-it",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Why did the computer show up at work late? It had a hard drive!"
      },
      "finish_reason": "stop"
    }
  ]
}
```

### Error Handling

#### Rate Limit Exceeded

If you exceed your rate limits, the API will return a `429 Too Many Requests` error.

**Response Example:**

```json
{
  "error": {
    "message": "Rate limit exceeded. Try again later.",
    "type": "rate_limit_exceeded",
    "code": 429
  }
}
```

#### Unauthorized Access

If you provide an invalid API key or access a restricted resource, you'll receive a `401 Unauthorized` error.

**Response Example:**

```json
{
  "error": {
    "message": "Invalid API key.",
    "type": "authentication_error",
    "code": 401
  }
}
```


# Chasm Scout Season 0


# Getting Started

Links to Chasm Scout Leaderboard

* **Scout Portal:** Access the Chasm Scout portal [here](https://scout.chasm.net/).
* **Leaderboard:** View the current scout rankings [here](https://scout.chasm.net/leaderboard).
* **Season 0 NFT Contract:** View the NFT contract on [Mantlescan Explorer](https://mantlescan.xyz/address/0xf9676b36436dd61417994a2fec27194810641a2e).


# Onboarding to Season 0

Season 0 Introduction

### Server Requirements

* Operating System: Linux (linux/amd64, linux/arm64).&#x20;
* Min Requirements: 1 vCPU, 1GB RAM / 20GB Disk, Static IP

### Recommended Server Requirements

* Operating System: Ubuntu (20.04 LTS onwards)&#x20;
* Suggested Requirements: 2 vCPU, 4GB RAM / 50GB SSD, Static IP

## Getting your Scout Invitation

Visit the [Season 0 Scout Launch](https://scout.chasm.net/private-mint) site to get an invitation to Chasm Network.&#x20;

{% embed url="<https://jmp.sh/lyHzIlAx>" %}


# Chasm Inference Scout Setup Guide

Introduction

Welcome to the Inference Scout documentation. This guide will help you set up and run Inference Scout on your server, whether you are a first-time user or a seasoned developer.

Inference Scout is a tool that runs inference tasks given by Chasm's Orchestrator. It allows you to leverage powerful language models and contribute to Chasm Network.

## Prerequisites

#### API Keys

* Obtain a Groq API key from the [Groq Console](https://console.groq.com/keys)
* (Optional) Obtain an Openrouter API key from Openrouter
* Obtain `SCOUT_UID` and `WEBHOOK_API_KEY` from the Chasm Website

#### Server Specifications

Minimum Requirements:

* 1 vCPU
* 1GB RAM
* 20GB Disk
* Static IP

Suggested Requirements:

* 2 vCPU
* 4GB RAM
* 50GB SSD
* Static IP

### Obtaining your SCOUT\_UID and WEBHOOK\_API\_KEY

1. Go to <https://scout.chasm.net/private-mint>

   <figure><img src="/files/1ugHxDsgdJaMxvdZ35Ou" alt=""><figcaption></figcaption></figure>
2. Click `_mint(scout)`
3. Log in to the website and retrieve your webhook API key and UID as the first step.

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

## Software Requirements

1. Install Docker: Follow the [Docker Installation Guide](https://docs.docker.com/engine/install/ubuntu/)
2. Make a new folder and enter the folder: Do a `mkdir chasm-scout`and `cd chasm-scout`
3. Set up the environment file: Use `nano .env` or `vim .env` to create a file with the following content:

```
PORT=3001
LOGGER_LEVEL=debug

# Chasm
ORCHESTRATOR_URL=https://orchestrator.chasm.net
SCOUT_NAME=
SCOUT_UID=
WEBHOOK_API_KEY=
# Scout Webhook Url, update based on your server's IP and Port
# e.g. http://123.123.123.123:3001/
WEBHOOK_URL=

# Chosen Provider (groq, openai)
PROVIDERS=groq
MODEL=gemma2-9b-it
GROQ_API_KEY=

# Optional
OPENROUTER_API_KEY=
OPENAI_API_KEY=
```

{% hint style="info" %}
Do not use single quotes (') or double quotes (") in your .env file, as Docker has issues with them.
{% endhint %}

### Setup Guide

1. Get Required Credentials from Chasm
2. Prepare the `.env` File (as shown above)
3. Pull the Docker Image:

   ```bash
   docker pull chasmtech/chasm-scout:latest
   ```
4. Run the Docker Container:

   ```bash
   docker run -d --restart=always --env-file ./.env -p 3001:3001 --name scout chasmtech/chasm-scout
   ```
5. Verify Server Status:

   ```bash
   docker logs scout
   ```
6. Test Server Response:

   ```bash
   curl localhost:3001
   ```

   Expected response: `OK`
7. Test LLM Functionality:

   ```bash
   source ./.env
   curl -X POST \
        -H "Content-Type: application/json" \
        -H "Authorization: Bearer $WEBHOOK_API_KEY" \
        -d '{"body":"{\"model\":\"gemma2-9b-it\",\"messages\":[{\"role\":\"system\",\"content\":\"You are a helpful assistant.\"}]}"}' \
        $WEBHOOK_URL
   ```
8. Restart Docker Container (if needed):

   ```bash
   docker stop scout
   docker rm scout
   docker run -d --restart=always --env-file ./.env -p 3001:3001 --name scout johnsonchasm/chasm-scout
   ```
9. Verify Scout Ranking:&#x20;

   Check your scout ranking at the [Leaderboard](< https://scout.chasm.net/leaderboard >). Note: The node status may take up to an hour to update.
10. Monitor Scout Performance:

    ```bash
    docker stats scout
    ```

### Troubleshooting

#### Environment Variables

Double-check that all required environment variables are correctly set in the `.env` file.

#### Additional Resources

* **Optimization Guide:** Follow the [optimization guide](/chasm-scout-season-0/competitive-scout-optimization) for performance improvements.
* **Update Guide:** Follow the [update guide](/chasm-scout-season-0/updating-inference-scouts) for updating your scout.

This guide should help you set up and run the Chasm Scout server effectively. For more detailed instructions and troubleshooting, refer to the original repository and additional resources provided.


# Installing Chasm Inference Scout via CLI

## Introduction

For advanced users and those looking to automate their setup process, Chasm Inference Scout can be installed using the Command Line Interface (CLI). This method provides greater flexibility and control over the installation process.

The CLI installation relies on [Homebrew](https://brew.sh/), a popular package manager for macOS and Linux systems. Homebrew simplifies the process of installing, updating, and managing software packages, making it an ideal tool for our Scout setup.

This guide will walk you through the step-by-step process of installing Homebrew (if you haven't already) and then using it to install the Chasm Inference Scout. Whether you're setting up multiple instances or integrating the installation into your automated workflows, this CLI method will prove invaluable.

## Installing Homebrew on Ubuntu

### Prerequisites

* Ubuntu operating system
* Sudo privileges
* Docker installed: Follow the [Docker Installation Guide](https://docs.docker.com/engine/install/ubuntu/)

### Installation Steps

{% hint style="info" %}
If you're using DigitalOcean, you probably will want to follow the [guide below](#common-errors-and-solutions)
{% endhint %}

#### 1. Run the Installation Script

Open a terminal and run the following command to start the Homebrew installation:

```bash
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

#### 2. Configure the Environment

After successful installation, add Homebrew to your PATH by appending the following to your `.bashrc` file:

```bash
(echo; echo 'eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"') >> ~/.bashrc
```

#### 3. Apply the Changes

Run the following command to apply the changes to the current session:

```bash
eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"
```

#### 4. Install Build Essentials

Install the necessary build tools:

```bash
sudo apt-get install build-essential
```

### Common Errors and Solutions

{% hint style="warning" %}

#### Error: Don't run this as root!

{% endhint %}

If you see the following error:

```
==> Checking for `sudo` access (which may request your password)...
Don't run this as root!
```

**Solution**: If you encounter this error, you'll need to create a new user and install Homebrew using that account. Follow these steps:

1. Create a new user:

   ```bash
   sudo adduser brewuser
   sudo usermod -aG sudo brewuser
   ```
2. Switch to the new user and run the installation script:

   ```bash
   sudo -u brewuser 
   bash -c '/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"'
   ```
3. Configure the environment for the new user:

   ```bash
   (echo; echo 'eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"') >> /home/brewuser/.bashrc
   ```
4. Apply the changes:

   ```bash
   eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"
   ```
5. Install build essentials:

   ```bash
   sudo apt-get install build-essential
   ```

## Installing Chasm Inference Scout

Once you have Homebrew set up on your system, you can proceed with the installation of Chasm Inference Scout using the following commands:

#### 1. Add the Chasm Network Tap

First, we need to add the Chasm Network tap to Homebrew. A tap is a third-party repository for Homebrew formulas. Run the following command:

```bash
brew tap ChasmNetwork/tap
```

This command tells Homebrew to track the repository of Chasm Network, allowing you to install their custom packages.

#### 2. Install Chasm CLI

After adding the tap, you can install the Chasm CLI by running:

```bash
brew install chasm-cli
```

This command will download and install the Chasm Inference Scout CLI tool on your system.

## Running Chasm CLI

After successfully installing Chasm CLI, you can start using it by simply running the `chasm` command in your terminal. This command serves as the entry point for all Chasm-related operations.&#x20;

To setup a new scout, select the following in the CLI:

`Choose an option: Setup new scout`

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

You'll be able to select the NFT to set up, and the rest of steps are similar to the [regular setup guide](/chasm-scout-season-0/chasm-inference-scout-setup-guide).&#x20;

{% hint style="info" %}
Note that the 'View My Scout' functionality is still under work progress
{% endhint %}


# Updating Inference Scouts

## How to Update Your Scout

Keeping your Scout node up-to-date ensures optimal performance, security, and access to the latest features. Follow these steps to update your Scout node:

### Step-by-Step Guide

#### 1. Stop the Current Scout Container

First, stop the running Scout container to prepare for the update:

```bash
docker stop scout
```

#### 2. Remove the Existing Scout Container

Remove the old Scout container to avoid conflicts with the new version:

```bash
docker rm scout
```

Optionally, clear your images (use with caution):

```bash
# WARNING: This will delete all your Docker images. 
# Proceed with care if you are on a shared computer.
docker system prune -a
```

#### 3. Pull the Latest Docker Image

Fetch the latest version of the Scout image from Docker Hub:

```bash
docker pull chasmtech/chasm-scout:latest
```

#### 4. Update the .env File (if necessary)

Make sure your `.env` file is up-to-date with any new environment variables required by the latest version. Compare your `.env` file with the latest template provided in the documentation or `.env.sample`.

#### 5. Run the Updated Scout Container

Start the Scout container with the updated image and environment variables:

```bash
docker run -d --restart=always --env-file ./.env -p 3001:3001 --name scout chasmtech/chasm-scout
```

#### 6. Verify the Update

Check that the updated Scout container is running properly:

**a. Check Logs**

View the container logs to ensure there are no errors:

```bash
docker logs scout
```

**b. Access the Application**

Open your browser and navigate to `http://<your-server-ip>:<port>` to verify the setup.

**c. Test Server Response**

Ensure the server is live by running:

```bash
curl localhost:3001
```

Expected response:

```
OK
```

**d. Check the Leaderboard**

Visit the leaderboard and confirm that the version has been updated.

This revised version improves the formatting and structure for GitBook, using proper Markdown syntax for headers, code blocks, and lists. It also separates the verification steps into sub-steps for better clarity and readability.


# Competitive Scout Optimization

Scout nodes are pivotal elements within Chasm's CoDEX, responsible for delivering LLM results with precision and speed. Effective optimization of these nodes is crucial for maintaining peak system functionality. The Scout nodes in the competitive ranking will have access to a pool of emissions, similar to the system used in Bittensor's ecosystem.

### How to Optimize Your Scout

The primary goal is to enhance the consistency, uptime, and response time of the Scout nodes to ensure they operate at peak efficiency. Here are a few strategies for optimizing your scouts:

#### Infrastructure Management

Ensure Scout nodes are hosted on robust servers equipped to handle anticipated loads, optimizing for performance and stability:

* [**Docker**](https://www.docker.com/)**:** Utilize Docker for scalable and efficient management of containerized applications. This allows for agile adjustments to resources based on demand.
* [**PM2**](https://pm2.keymetrics.io/)**:** Implement PM2 for improved security and uptime. This tool automates process management, helping to streamline deployments and maintain operations through continuous monitoring and automatic restarts.

#### Redundancy and Reliability

To minimize downtime and maintain continuous service availability:

* **Failover Mechanisms:** Implement robust failover systems that automatically switch to backup operations if the primary systems fail.
* **External Resources:** Integrate third-party cloud services or deploy self-hosted GPU clusters to augment computing power and provide additional redundancy.

#### Update the Latest Code

Scout node code is updated periodically. Ensure you are running the latest version of the Scout nodes to achieve the best performance.

## Running a Dispute Scout

Advanced users can also run a [Dispute Scout instance](/chasm-scout-season-0/dispute-scout-setup-guide) in order to possibly get even higher scores.&#x20;


# Scout Ranking Methodology

## Introduction

Optimistic Rollup currently faces centralization issues, with most sequencers being centralized. Despite plans for their decentralization, it's still insufficient for production use. Optimistic Machine Learning (opML) faces a similar problem, with most inference tasks conducted in a centralized fashion. Even with decentralized sequencers, the setup and entry costs would remain high.

To address this issue in our implementation of Optimistic Machine Learning, we encountered a similar challenge. Our solution involves implementing a non-token rating system using Glicko V2. We've created a new mechanism that includes a reputation system, in addition to token rewards, to simulate real-world reputation systems. This approach is inspired by various games that use rankings to foster competitiveness.

## Chasm LLM Pool Phase

Hybrid Method of Random Distribution and Multi-Armed Bandit (MAB) will be used for launching a new LLM pool.

### Onboarding Phase

When the Chasm Orchestrator creates a new pool of LLMs, it will have a 14-day Initial Ranking Period. During this phase, scouts can pledge to join the network. The network requires at least 20 scouts in order to start the network.&#x20;

### Initial Ranking Period

At the initial ranking period, each scout starts with an initial reputation score (e.g., 1000 points), and the orchestrator will pick random scouts through a random distribution method to perform inference work.

### Adaptive Ranking Period

Once the network stabilizes with the leaderboard, it will switch to the **Multi-Armed Bandit (MAB)** algorithm. This algorithm uses the explore or exploit method to assign inference tasks to the top-performing scouts, as well as newcomers to the network.&#x20;

Drawing inspiration from LOL (League of Legends), we can incorporate a "placement" mechanism for new players. For instance, if a new player begins at rank 1000, they cannot be demoted below 1100 until they complete their initial placement matches.

### Season Reset

Following how most games work, we will have a seasonal soft reset every month to promote competition. Top rankings from the last season could provide a slight boost in terms of rank, promoting seasonal competitiveness. Good actors should quickly reclaim top positions without penalties.

## Rank Change

How ranking changes work: We are going to use the Glicko Algorithm to replace ELO, which takes into consideration rating uncertainty and also tweaks a bit on top of Glicko.

### Key Tunable Parameters

#### Initial Rating (BASE\_RATING)

* Sets the baseline for scouts' initial ratings.
* Affects how quickly scouts' ratings evolve from the starting point.

#### Initial Deviation (BASE\_DEVIATION)

* Controls the initial uncertainty in ratings.
* Higher deviation means more significant adjustments after each update.

#### Initial Volatility (BASE\_VOLATILITY)

* This parameter reflects how consistently a scout's performance is expected to be over time.
* Higher volatility suggests that a scout's performance is more variable, leading to larger rating changes. Lower volatility indicates more consistent performance, resulting in smaller changes.

```
initial_rating: 1000,
initial_deviation: 200,
initial_volatility: 0.06
```

### How It Works

The traditional chess game is a one-on-one match. However, in our case, since there isn't an opponent, we use several tasks to determine the outcomes. Traditional chess outcomes are primarily binary (1 for a win, 0.5 for a draw, and 0 for a loss). Therefore, we need to incorporate penalties that have a more significant negative impact for certain situations, such as disputes.

Here's how the algorithm works: it uses various tasks to generate outcome scores.

#### Task 1: Inference Response

```
If T(response) < T(average) = 1
If T(average) < T(response) < T(threshold) = 0.5
If T(threshold) < T(response) or T(response) failed = 0
```

#### Task 2: Health Check QC

The Health Check jobs and Actual Jobs will be mixed and indistinguishable from the scouts’ perspective. Health Checks will affect the ranking, as well as ensure the foundational scouts are up.

```
If Q(response) >= Q(benchmark) = 1
Else = 0
```


# Inference Scout Elo Ranking System

### **Introduction**

The Elo rating system, originally designed for chess, has been adapted to evaluate the performance of Scout nodes in delivering LLM results within Chasm's CoDEX. This document explains how the [Elo rating system](https://en.wikipedia.org/wiki/Elo_rating_system) is applied to assess the efficiency and reliability of Scout nodes.

We use the Elo ranking system because it is more fair and aligns with the game theory of Nash Equilibrium. In this system, scouts with higher Elo rankings are incentivized to maintain their performance and avoid malicious behavior, as doing so would result in a loss of rank. Conversely, scouts with lower Elo rankings can quickly move up the ranks by outperforming higher-ranked scouts, promoting a dynamic and competitive environment that rewards genuine performance improvements.

### **Metrics for Elo Calculation**

#### **Performance Metrics**

Scout nodes are evaluated based on three key performance metrics for each response:

1. **End-to-End Latency (EEL)**:
   * Measures the time taken for a request to be processed and a response to be delivered.
   * Scored on a scale from 0 to 1.
2. **Output Tokens per Second (OTS)**:
   * Evaluates the number of tokens generated by the LLM per second.
   * Scored on a scale from 0 to 1.
3. **Server Uptime (SU)**:
   * Tracks the availability and reliability of the server.
   * Scored on a scale from 0 to 1.

The overall performance score is calculated using the following formula:

```
Performance = k_1 * EEL + k_2 * SU + k_3 * OTS
```

where **`k_1`**, **`k_2`**, and **`k_3`** are weighting factors that balance the contribution of each metric to the overall performance score.

#### **Evaluating Performance**

Performance is assessed between miners and validators because validators can also function as miners. This dual role necessitates a comprehensive evaluation mechanism to ensure consistency and reliability across the network.

### **Quality Check Using Health Checks**

In addition to performance metrics, the Elo rating system also incorporates quality checks to evaluate the effectiveness of LLM responses. This is achieved through the LLM-as-a-judge method, which compares the quality of the LLM response to that of an average LLM.

#### **Health Check Process**

* **Quality Assessment**:
  * The server performs a quality check on the LLM response.
  * This involves using an *LLM-as-a-judge* to evaluate the accuracy, relevance, and coherence of the response.
* **Comparison to Average LLM**:
  * The response is compared against the benchmark set by an average LLM.
  * The comparison helps determine the relative quality and effectiveness of the response.

#### **Incorporating Health Checks into Elo Rating**

The results of the health checks are integrated into the Elo rating system to provide a holistic evaluation of each Scout node. By combining performance metrics and quality assessments, the Elo rating system ensures a balanced and comprehensive assessment of scout efficiency and reliability.


# Dispute Scout Setup Guide

Disputes are used for fault detection in the opML mechanism. Scout Disputers are required to have a higher technical level of understanding how an opML dispute works, as well as understanding on how to set the dispute scouts up manually.&#x20;

Scouts running the dispute module monitor the inference results produced by other Scouts in the network. They raise a Dispute whenever they suspect discrepancies between the reported results and the actual results.

### Note on Resource Intensity and Cost Management

Running a Dispute Scout instance is computationally intensive, particularly in terms of inference requirements. To manage costs effectively, users should consider the following:

1. Local Hardware Option: Ideally, users should use [Ollama](https://github.com/ollama/ollama) to run the Dispute Scout on their own hardware. This approach helps prevent inference costs from accumulating rapidly.
2. Cost Monitoring: If using cloud-based solutions such as Openrouter or Groq, regularly monitor your usage and associated costs to avoid unexpected expenses.

A [simple guide](/chasm-scout-season-0/dispute-scout-setup-guide/ollama-setup-guide) is provided on how to run Ollama locally.

## Obtaining your WEBHOOK\_API\_KEY

Please refer to the Inference Scout Setup Guide in order to obtain your `WEBHOOK_API_KEY`. Note that `WEBHOOK_URL` is replaced with `LLM_BASE_URL` for dispute scouts.

{% content-ref url="/pages/z32aPRGA4iOUIG4bxEOW" %}
[Chasm Inference Scout Setup Guide](/chasm-scout-season-0/chasm-inference-scout-setup-guide)
{% endcontent-ref %}

## Setup Guide and Software Requirements

1. Install Docker: Follow the [Docker Installation Guide](https://docs.docker.com/engine/install/ubuntu/)
2. Install Docker Compose: Follow the [Docker Compose Installation Guide](https://docs.docker.com/compose/install/linux/)
3. Git clone the repository, and enter the repository: \
   `git clone`[`https://github.com/ChasmNetwork/chasm-scout`](https://github.com/ChasmNetwork/chasm-scout)and `cd chasm-scout/dispute`
4. Set up the environment file: Use `nano .env` or `vim .env` to create a file with the following content, depending on your chosen model and supplier. Choose ONE of the following supplier options:&#x20;

   1. Ollama (local GPU):

      <pre class="language-bash"><code class="lang-bash"><strong>## Ollama (local GPU)
      </strong>## note that ollama doesn't need an api key as it's local,
      ## but it's required to set the key as ollama so 
      ## the system knows it's ollama

      LLM_API_KEY=ollama
      LLM_BASE_URL=http://localhost:11434/v1
      MODELS=stablelm2:zephyr,llama3:8b,qwen:4b,gemma2,gemma2:2b,mistral:7b,phi3:3.8b
      SIMULATION_MODEL=llama3:8b
      ORCHESTRATOR_URL=https://orchestrator.chasm.net
      WEBHOOK_API_KEY=
      </code></pre>
   2. Groq:

      <pre class="language-bash"><code class="lang-bash"><strong>## Groq
      </strong><strong>LLM_API_KEY=
      </strong>LLM_BASE_URL=https://api.groq.com/openai/v1
      MODELS=llama3-8b-8192,mixtral-8x7b-32768,gemma-7b-it
      SIMULATION_MODEL=llama3-8b-8192
      ORCHESTRATOR_URL=https://orchestrator.chasm.net
      WEBHOOK_API_KEY=
      </code></pre>
   3. OpenRouter:

      <pre class="language-bash"><code class="lang-bash"><strong>## Openrouter
      </strong>
      LLM_API_KEY=
      LLM_BASE_URL=https://openrouter.ai/api/v1
      MODELS=google/gemma-7b-it,meta-llama/llama-3-8b-instruct,microsoft/wizardlm-2-7b,mistralai/mistral-7b-instruct-v0.3
      SIMULATION_MODEL=meta-llama/llama-3-8b-instruct
      ORCHESTRATOR_URL=https://orchestrator.chasm.net
      WEBHOOK_API_KEY=
      </code></pre>

{% hint style="info" %}
The SIMULATION\_MODEL is set to `meta-llama/llama-3-8b-instruct` as an example, but users are free to test other models in the list above.
{% endhint %}

{% hint style="info" %}
Do not put all three entries above - pick the supplier you want to go with, and simply copy that to put into your `.env` file.
{% endhint %}

## Create and run the Docker Image

1. Make sure you're in `chasm-scout/dispute`, otherwise change your directory into `chasm-scout/dispute` by doing a `cd dispute` from the root folder.
2. Build the Docker Image for the dispute scout by running `docker compose build.`If you get any errors, make sure you've installed Docker and Docker Compose as per the instructions above.&#x20;
3. Run the Docker image you've just built by running `docker compose up -d`
4. Check if everything is going well by running `docker compose logs`.

{% hint style="info" %}
If you get an error saying `Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?`, start your docker instance by running `sudo systemctl start docker`
{% endhint %}

## Optimizations for Advanced Users

Additional `.env` variables: You can add the following variable to your `.env` file:

```
## default value is 0.5, feel free to change the threshold to something else
MIN_CONFIDENCE_SCORE=0.5
```

This variable sets the minimum confidence score required to prevent inaccurate dispute reports due to potential model inaccuracies, especially when using smaller models. The default value is `0.5`. Run the `benchmark.py` script via `python benchmark.py`to see if the values work for you.

The `dispute/strategies/` folder contains strategies for determining disputes:

* StaticTextAnalysisStrategy
* SemanticSimilarityAnalysis
* LLMQualityStrategy
* ResponseSimilarityAnalysis

A detailed publication on these strategies is forthcoming.

### Advanced Scripts Setup

To use the additional scripts provided like `benchmark.py`, you have to install the dependencies as well as `Python`. A rough guide is provided below, but users venturing here are expected to know more than  average.

1. Install Python and dependencies:

   ```bash
   sudo apt-get -y update && sudo apt-get install -y python3 python3-pip python3-venv
   ```
2. Create and activate a virtual environment:

   ```bash
   python3 -m venv dispute-scout
   source dispute-scout/bin/activate
   ```
3. Install requirements:

   ```bash
   pip install -r requirements.txt
   ```
4. Run the benchmark:

   ```bash
   python benchmark.py
   ```

The output will help you evaluate if a dispute will be filed with your current settings.


# Ollama Setup Guide

## Ollama Installation Guide

Ollama is a tool for running large language models (LLMs) locally. Follow these steps to install and run Ollama on your system.

### Installation

1. Use the [official Ollama installation script](https://ollama.com/download):

   ```bash
   curl -fsSL https://ollama.com/install.sh | sh
   ```
2. Pull the models you want to run by using the following command:

   `ollama pull llama3:8b`

{% hint style="info" %}
Different models can be found in the [Ollama Library](https://ollama.com/library)
{% endhint %}

### Running an LLM

2. To run an instance of `llama3:8b`, use the following command:

   ```bash
   ollama run llama3:8b
   ```

### Notes

* These instructions can be modified to run other LLMs listed in the MODELS environment variable.
* The speed and performance of the model depend on your hardware's capabilities.
* You can run different models by replacing `llama3:8b` with the name of another model from the MODELS list.

### Customizing Your Model Selection

To run a different model, use the format:

```bash
ollama run [model_name]
```

Replace `[model_name]` with your chosen model from the MODELS list in your `.env` file.

## Rough Hardware Guidelines

1. General Requirements:
   * CPU: Modern multi-core processor (6+ cores recommended)
   * RAM: Minimum 16GB, 32GB or more recommended
   * Storage: SSD with at least 20GB free space
   * Operating System: Linux, macOS, or Windows with WSL2
2. Model-Specific Guidelines:

   a) StableLM-2-Zephyr-1.6B:

   * Minimum: 8GB RAM, 4-core CPU
   * Recommended: 16GB RAM, 6-core CPU
   * GPU: Not strictly necessary, but a mid-range GPU can improve performance

   b) Llama-3-8B:

   * Minimum: 16GB RAM, 6-core CPU
   * Recommended: 32GB RAM, 8-core CPU
   * GPU: Mid-range GPU (e.g., NVIDIA GTX 1660 or better) recommended

   c) Qwen-4B:

   * Minimum: 12GB RAM, 4-core CPU
   * Recommended: 24GB RAM, 6-core CPU
   * GPU: Entry-level GPU can help, but not essential

   d) Gemma2-9B:

   * Minimum: 32GB RAM, 6-core CPU
   * Recommended: 64GB RAM, 8-core CPU
   * GPU: Mid-range GPU recommended (e.g., NVIDIA RTX 3060 or better)

   e) Mistral-7B:

   * Minimum: 16GB RAM, 6-core CPU
   * Recommended: 32GB RAM, 8-core CPU
   * GPU: Mid-range to high-end GPU recommended (e.g., NVIDIA RTX 3070 or better)

   f) Phi-3-3.8B:

   * Minimum: 12GB RAM, 4-core CPU
   * Recommended: 24GB RAM, 6-core CPU
   * GPU: Entry-level to mid-range GPU can improve performance

Notes:

1. These are rough estimates and actual performance may vary.
2. GPU acceleration can significantly improve inference speed for all models.
3. For optimal performance, especially with larger models like 7B and 8B, a dedicated GPU with at least 8GB VRAM is recommended.
4. Users can run these models on CPUs, but inference times will be slower compared to GPU-accelerated setups.
5. SSD storage is strongly recommended for faster model loading times.

Always check the [official Ollama documentation](https://github.com/ollama/ollama/tree/main/docs) and specific model requirements for the most up-to-date information. Performance can be optimized by adjusting model parameters and quantization levels.


# Dispute Scout Calculations

{% hint style="info" %}
This is an article with work in progress, and is subject to updates at any given time.
{% endhint %}

The rating changes for Scouts depend on their `RatingDeviation` (RD). Here's a general overview of how the reward ratio works:

**For the scout who filed the dispute:**

```
+1x if successful, maximum +20 rating points
-1x if failed, maximum -20 rating points
```

**For the scout who was disputed:**

```
CopyNo change if they won the dispute
-2x if they lost, maximum -40 rating points
```

The exact amount of rating change is difficult to determine due to variations in `RD`. However, the system aims to set back the rating of a Scout who lost a dispute by a certain amount below their current `RD`. This ensures that it will take significantly more wins for them to return to their previous rating. The rationale is that if a Scout is found to have cheated or made a significant error, they need to demonstrate consistent good performance to regain trust.

Note: The 'x' in the formulas represents a variable factor that is influenced by the Scout's current `RD` and other potential factors in the rating system.


# VLLM Setup Guide

### Adding VLLM as a Dispute Scout Provider

With the latest update, the Dispute Scout now supports VLLM as a provider. This allows you to utilize VLLM models for advanced logprob-based dispute detection.

#### Prerequisites for VLLM Dispute Scout

To set up the VLLM Dispute Scout, ensure you have:

* **VLLM Deployment**: A running instance of VLLM, either locally or accessible via a remote endpoint.
* **VLLM API Endpoint URL (`VLLM_URL`)**: The base URL where your VLLM API is accessible.
* **VLLM API Key (`VLLM_API_KEY`)**: If your VLLM deployment requires authentication.

#### Setting Up VLLM

**Option 1: Local VLLM Deployment**

1. **Install VLLM**: Follow the official installation guide in the [VLLM GitHub Repository](https://github.com/vllm-project/vllm) to set up VLLM on your machine.
2. **Start the VLLM Server**: Run the VLLM server with your desired model. For example:

`HF_TOKEN=<your-huggingface-token> python -m vllm.entrypoints.openai.api_server --model repo_id --max-logprobs 120`

By default, the server runs at `http://localhost:8000`.

**Option 2: Remote VLLM Deployment**

If you have access to a remote VLLM API endpoint:

* Ensure you have the base URL and API key (if required).
* Verify that the endpoint is accessible from your network.

#### Configuring the `.env` File for VLLM

In the `chasm-scout/dispute` directory, create or modify your `.env` file to include the VLLM configuration. Replace placeholders with your actual values.

```bash
## VLLM Configuration

# API key for VLLM (leave blank if not required)
LLM_API_KEY=your_vllm_api_key_or_leave_blank

# Base URL for VLLM API
LLM_BASE_URL=http://localhost:8000/v1

# VLLM-specific configurations
VLLM_URL=http://localhost:8000/v1
VLLM_API_KEY=your_vllm_api_key_or_leave_blank

# Models to use (comma-separated if multiple)
MODELS=llama-2-7b-chat

# Model used for simulation
SIMULATION_MODEL=llama-2-7b-chat

# Orchestrator URL
ORCHESTRATOR_URL=https://orchestrator.chasm.net

# Your webhook API key
WEBHOOK_API_KEY=your_webhook_api_key
```

**Explanation of Variables:**

* `LLM_API_KEY`: API key for your VLLM instance (if required).
* `LLM_BASE_URL`: Base URL of your VLLM API endpoint.
* `VLLM_URL`: Same as `LLM_BASE_URL`; used specifically for VLLM configurations.
* `VLLM_API_KEY`: Same as `LLM_API_KEY`; used specifically for VLLM configurations.
* `MODELS`: The model(s) available in your VLLM deployment.
* `SIMULATION_MODEL`: The model used for simulation purposes.
* `ORCHESTRATOR_URL`: The orchestrator's URL (usually `https://orchestrator.chasm.net`).
* `WEBHOOK_API_KEY`: Your webhook API key obtained during registration.

**Note**: Do not include multiple supplier configurations in your `.env` file. Only include the settings relevant to VLLM.

#### Running the VLLM Dispute Scout

After configuring the `.env` file, follow these steps:

1. **Ensure VLLM is Running**: Verify that your VLLM server is operational and accessible at the URL specified in `LLM_BASE_URL`.
2. **Build the Docker Image**:

   ```bash
   docker compose build
   ```
3. **Run the Docker Container**:

   ```bash
   docker compose up -d
   ```
4. **Monitor the Logs**:

   ```bash
   docker compose logs -f
   ```

   Check for any errors and ensure that the Dispute Scout is running correctly.

#### Notes on VLLM Configuration

* **Model Availability**: Ensure that the models specified in `MODELS` and `SIMULATION_MODEL` are available in your VLLM deployment.
* **API Keys**: If your VLLM deployment does not require an API key, you can leave `LLM_API_KEY` and `VLLM_API_KEY` blank.
* **Endpoint Accessibility**: If the VLLM server is running locally, ensure there are no firewall or network restrictions preventing access from the Docker container.

#### Monitoring and Troubleshooting

* **Connection Issues**: If the Dispute Scout cannot connect to the VLLM API, verify that the `LLM_BASE_URL` is correct and accessible.
* **Authentication Errors**: If authentication fails, double-check your `LLM_API_KEY` and `VLLM_API_KEY`.
* **Model Errors**: If you encounter model-related errors, ensure the model names in your `.env` file match those in your VLLM deployment.
* **Logprob Support**: The VLLM Dispute Scout relies on logprob data. Ensure your VLLM deployment supports returning logprobs.

#### Advanced Configuration

**Setting the Minimum Confidence Score**

You can adjust the minimum confidence score required for filing a dispute to prevent false positives:

```bash
## Adjust the threshold as needed (default is 0.5)
MIN_CONFIDENCE_SCORE=0.7
```

Add this line to your `.env` file and adjust the value based on your requirements.

**Running Benchmarks**

To evaluate if a dispute will be filed with your current settings:

1. **Install Python and Dependencies**:

   ```bash
   sudo apt-get update && sudo apt-get install -y python3 python3-pip python3-venv
   ```
2. **Create a Virtual Environment**:

   ```bash
   python3 -m venv dispute-scout
   source dispute-scout/bin/activate
   ```
3. **Install Requirements**:

   ```bash
   pip install -r requirements.txt
   ```
4. **Run the Benchmark Script**:

   ```bash
   python benchmark.py
   ```

   This script will help you assess the impact of your settings on dispute filings.

#### Additional Resources

* **About VLLM** : [VLLM Official Documentation](https://vllm.ai/docs)
* **VLLM GitHub Repository**: [github.com/vllm-project/vllm](https://github.com/vllm-project/vllm)

#### Troubleshooting Tips

* **Docker Daemon Not Running**: If you encounter an error stating that Docker cannot connect to the daemon, start Docker with:

  ```bash
  sudo systemctl start docker
  ```
* **Check Container Status**: Use `docker ps` to list running containers and ensure the Dispute Scout is active.
* **Log Analysis**: Regularly check the logs using `docker compose logs -f` to monitor the Dispute Scout's activity and catch any issues early.


# Terms of Use (Node)

Please read this Node Software Agreement (this “Agreement”) carefully before using the Chasm network (the “Network”) and its Scout node (the “Node”), which comprises of the distributed software needed to help run the Network (“Node Software”) and the node key (“Key”), as further defined below. By accessing, operating, or otherwise using (collectively, “use” or “using”) the Node Software or purchasing, accessing or using the Node or the Key, you agree that you have read, understood and accepted all of the terms and conditions contained in this Agreement by and between you and  Hooga Gaming Inc., a Panama private interest foundation (the “Company” or “we”). If you do not agree with all or any part of the terms and conditions of this Agreement, please do not use the Node Software.

THE NODE SOFTWARE IS NOT AVAILABLE FOR ACCESS OR USE, AND THE KEY AND NODE SOFTWARE ARE NOT AVAILABLE FOR PURCHASE, ACCESS OR USE, BY ANY RESIDENT OF OR ANY PERSON LOCATED OR DOMICILED IN THE UNITED STATES, NORTH KOREA, IRAN, VENEZUELA, OR ANY OTHER JURISDICTIONS SANCTIONED BY THE U.S. DEPARTMENT OF THE TREASURY’S OFFICE OF FOREIGN ASSETS CONTROL (“OFAC”).&#x20;

PLEASE BE AWARE THAT SECTION 8 (DISPUTE RESOLUTION; AGREEMENT TO ARBITRATE) GOVERNS THE RESOLUTION OF DISPUTES BETWEEN YOU AND THE COMPANY. SECTION 8 INCLUDES AN AGREEMENT TO ARBITRATE WHICH REQUIRES, WITH LIMITED EXCEPTIONS, THAT ALL DISPUTES BETWEEN YOU AND US SHALL BE RESOLVED BY BINDING AND FINAL ARBITRATION. SECTION 8 ALSO CONTAINS A CLASS ACTION AND JURY TRIAL WAIVER. PLEASE READ SECTION 8 CAREFULLY.&#x20;

THIS AGREEMENT MAY BE AMENDED FROM TIME TO TIME IN ACCORDANCE WITH SECTION 10.3 AND IF AT ANY TIME YOU DO NOT AGREE WITH ALL OR ANY PART OF THE THEN EFFECTIVE TERMS AND CONDITIONS, YOUR SOLE RECOURSE IS TO STOP USING THE NODE.&#x20;

1. Eligibility Requirements.&#x20;

1.1 General. To be eligible to access or use the Node Software or purchase, access or use a Node, you must satisfy each of the following eligibility requirements:&#x20;

1.1.1 You are at least eighteen (18) years of age, or are the legal age for entering legally binding agreements under applicable law;&#x20;

1.1.2 You are not, nor are you an entity that is, or an entity owned or controlled by any person or entity that is, or conducting any activities itself or on behalf of any person or entity that is: (i) a natural person resident in the United States; (ii) a partnership or corporation organised or incorporated under the laws of the United States; or (iii) otherwise a “U.S. person” as defined in Rule 902(k)(2) of Regulation S under the Securities Act of 1933 (each, a “U.S. Person”);&#x20;

1.1.3 You are not, nor are you an entity that is, or an entity owned or controlled by any person or entity that is, or conducting any activities itself or on behalf of any person or entity that is: (x) the subject of any sanctions administered or enforced by OFAC (including, for the avoidance of doubt, any individual or entity included on OFAC’s Specially Designated Nationals and Blocked Persons List), the U.S. Department of State or any other governmental authority with jurisdiction over the party; (y) identified on the Denied Persons, Entity or Unverified Lists of the U.S. Department of Commerce’s Bureau of Industry and Security; or located, organized or (z) resident in a country or territory that is, or whose government is, the subject of economic sanctions, including, without limitation, Russia, Cuba, Iran, North Korea Syria or the Crimea, Donetsk People’s Republic, and Luhansk People’s Republic regions of Ukraine (each, a “Restricted Person”); and&#x20;

1.1.4 You are not purchasing, obtaining, accessing or using the Node Software on behalf of a U.S. Person or Restricted Person.&#x20;

1.2 Identity Verification. You will be required to provide information to us for the purposes of identity verification before you will be able to claim and take possession of any Network cryptographic tokens, i.e., “CAI tokens” (“Tokens”) earned as “Network Rewards” (defined below) in connection with your use of the Node. If we are unable to verify your identity and confirm that you are eligible to use the Node Software, you will not be permitted to use the Node Software, including to earn any Network Rewards. You agree to provide us with the information we request for purposes of identity verification and permit us to keep a record of such information. You further represent and agree that all such information is complete and accurate and that you will immediately notify the Company in the event that any information provided to the Company during this process is no longer complete or accurate. <br>

2. Node Software.&#x20;

2.1 Use of Node. Subject to the terms and conditions of this Agreement, you may use the Node Software to operate a Network Node on one or more machines that you own or control. The Network is a network that operates on top of a blockchain network. As a “Scout Node Operator,” you shall contribute to the Network by providing expert insights and selecting the best performant Large Language Model (LLM), enhancing the Network’s ability to process and execute tasks given by the “Orchestrator” in the Network. An “Orchestrator” is a virtual point in the Network who receives and verifies tasks before passing it on to a Scout Node Operator. You hereby acknowledge and agree that:

* the Company has no control over your activities and all validation activities are done solely in your own discretion as a Scout Node Operator for the benefit of the Network and its users and participants;
* Any transactions that are confirmed via validation activities are completed exclusively under the Network’s decentralized consensus mechanism, and that there are no guarantees or protections with regards to the likelihood of any transaction being verified or confirmed on the Network;
* The Network is decentralized and neither you nor any other party has unilateral control over the Network and the transactions conducted thereon;
* You shall be solely responsible for comply with all applicable laws in connection with your role as a Network Scout Node operator.&#x20;

2.2 Node Key Requirement. You must acquire a Node Key from the Company In order to run a Scout Node and earn Network Rewards (defined below). The Node is by default a non-transferable non-fungible token. You will be required to provide information to the Company for purposes of verifying your identity and confirming that you are eligible to earn Network Rewards in order to claim and take possession of any Tokens earned as Network Rewards.&#x20;

2.3 Connecting a Digital Wallet. In order to operate a Node using the Node Software, you will need to connect a compatible third-party digital wallet (“Wallet”) compatible with the Ethereum Virtual Machine (“EVM”). You are solely responsible for maintaining the security of your Wallet, including any associated credentials, private key and seed phrase. The Company does not offer Wallet software or custody Tokens (or any other crypto assets) on behalf of Node Software users. Your use of a third-party Wallet is subject to separate terms and conditions established by the relevant Wallet provider. the Company shall not be liable for any acts or omissions by you in connection with your Wallet or as a result of any data breach, cyber incident, or security vulnerability that impacts your Wallet or your hardware and software used to access the same.

2.4 Network Rewards. You may receive units of Tokens for running the Nodes to contribute to the performance of the Network  (“Network Rewards”). All such Network Rewards, including their rate of accrual and any award of bonus rewards, are programmatically set and distributed to Nodes by the Network and its smart contracts. The Company is not responsible or liable for any Network Rewards (if applicable) that result from your use of the Node Software.&#x20;

2.5 Expiration of Network Rewards. Subject to the terms set forth herein, Network Rewards can be claimed at any time. You will be required to provide information to the Company for purposes of verifying your identity and confirming your eligibility to earn Network Rewards before you will be permitted to claim and take possession of any CAI Tokens earned as Network Rewards. Chasm may impose an expiration to the tokens whereby you will have a certain number of days from the date that you earn a Network Reward to claim the CHASM tokens earned as part of the Network Reward before the Network Reward expires, and any such expiration may be communicated to you via electronic transmission, by posting on the Website or through an amendment or modification of these Terms. You should check these Terms from time to time for any changes to these terms.

2.6 Node Software Updates. The Node Software may automatically download or prompt you to download and install updates onto your machine from time to time. By accessing or using the Node Software, you agree that the Company may download and install automatic Node Software updates onto your machine. You may opt out of automatic updates by adjusting your Node Software settings.&#x20;

3. License Uses and Restrictions.&#x20;

3.1 Node Software License. Subject to the terms and conditions of this Agreement, the Company hereby grants to you a non-exclusive, revocable, non-transferable, non-sublicensable, royalty-free, limited license to install, use and run the Node Software on one or more machines that you own or control. Except for the license expressly granted to you hereunder, no other license is granted and no other use is permitted.&#x20;

3.2 Third-Party Licenses. Notwithstanding anything to the contrary in this Agreement, the Node Software may contain software components released under separate open-source or business-source license terms, in which case those license terms will govern such software components.&#x20;

3.3 Feedback. With respect to any feedback you provide to the Company (whether orally or in writing) concerning the Node, including any features or functionalities thereof, and including identifying potential errors and improvements (“Feedback”), you hereby grant to the Company an exclusive, worldwide, perpetual, fully paid-up, royalty free, fully-sublicensable (through multiple tiers of sublicensees) and freely assignable and transferable license to use any Feedback for any purpose without payment or restriction. It is further understood that the Company' s use of Feedback, if any, may be made by the Company in its sole discretion, and that the Company shall in no way be obliged to make any payment to you for or make use of any kind of the Feedback or part thereof.&#x20;

3.4 Use of Trademarks and Other Marks or Rights. You may not use any of our trademarks, trade names, service marks, copyrights, or logos, or our partners’, affiliated entities’, licensors’, or their licensors’ trademarks, trade names, service marks, copyrights, or logos, including but not limited to “Chasm”, in any manner which creates the impression that such items (i) belong to or are associated with you or indicate the sponsorship or approval of us, our licensors, any partners, affiliates, or their licensors; or (ii) except as otherwise provided herein, are used with our licensors’, partners’, affiliates’, or their licensors’ consent, and you acknowledge that you have no ownership rights in or to any such items.&#x20;

4. Prohibited Activities.&#x20;

4.1 You shall not engage in any activities that negatively affect the technical performance of the Node Software and/or Network, bypass or circumvent security features of the Node Software and/or Network, or otherwise disrupt or interfere with the functioning of the Node Software and/or Network. You shall not violate or attempt to violate the security of the Node Software and/or Network or otherwise misuse the foregoing, including by, (i) accessing data not intended for you or logging onto a server or an account which you are not authorized to access; (ii) disabling, removing, defeating or avoiding any security device or system; (iii) attempting to probe, scan or test the vulnerability of the Node Software and/or Network or to breach security or authentication measures without proper authorization; (iv) attempting to interfere with service to any Scout Node Operator, host or network, including, but not limited to, via means of submitting any malware or computer programming routines that may damage, disrupt or interfere with, intercept or expropriate any system or data, overloading, “flooding,” “spamming,” “mailbombing” or “crashing” the Node Software and/or Network; (v) forging any transmission control protocol/Internet protocol packet header or any part of the header information in any email or posting; (vi) using the Node Software and/or Network in a manner that exceeds reasonable request volume or constitutes excessive or abusive usage; or (vii) providing false, misleading or inaccurate information to the Network.&#x20;

4.2 You shall not, directly or indirectly: (i) use the Node Software or any portion thereof to create any service, software, product, platform, documentation or data that is similar to, in whole or in part, any aspect of the services or products offered by the Company, including without limitation, the Node Software or Network; (ii) disassemble, decompile, reverse engineer or use any other means to attempt to discover any source code of the Node Software, or the underlying ideas, file formats, algorithms or trade secrets therein; (iii) encumber, sublicense, transfer, rent, lease, time-share or use the Node Software in any service bureau arrangement or otherwise for the benefit of any third party; (iv) copy, distribute, manufacture, adapt, create derivative works of, translate, localize, port or otherwise modify any software code or documentation for the Node Software; (v) use or allow the transmission, transfer, export, re-export or other transfer of any product, technology or information it obtains or learns pursuant to this Agreement (or any direct product thereof) in violation of any export control or other laws and regulations of any relevant jurisdiction; (vi) knowingly introduce into the Node Software and/or Network any malicious code, computer virus, spyware, scareware, Trojan horses, worms, malware or any other similar harmful, malicious or hidden programs or data; (vii) remove or modify any proprietary markings or restrictive legends placed on the Node Software; (viii) use the Node Software to infringe upon, violate or misappropriate any third party' s intellectual property rights, violating any law or regulation or being defamatory, trade libelous, threatening or harassing; or(ix) authorize or permit any third party to engage in any of the foregoing proscribed acts.For the avoidance of doubt, the restrictions set forth in this Section are in addition to, and in no way limit, any other restrictions or obligations applicable to you set forth in this Agreement.&#x20;

4.3 You shall not use the Node Software and/or Network to engage in illegal activity of any kind, including, without limitation, any activity that would violate, or assist in violation of, any law, statute, ordinance, regulation or sanctions programs administered under any applicable law, including but not limited to the U.S. Department of Treasury' s Office of Foreign Assets Control or which would involve proceeds of any unlawful activity.&#x20;

5. Risks. You acknowledge that the Node Software and Network incorporate experimental and novel technology and that the use of such technology involves a high degree of risk. For example, there are numerous reasons the Node Software or Network could fail in an unexpected way, resulting in the total and absolute loss of your Tokens. You hereby agree that you assume all risks in connection with your use of the Node Software and Network and expressly waive and release the Company from any and all liability, claims, causes of action or damages arising out of or in any way relating to you obtaining or using Node Software and Network.  \
   \
   You understand and accept the risk of operational challenges related to the Node Software and Network. For example, the Network may experience cyber-attacks, unexpected surges in transaction volume or activity or other operational or technical difficulties or vulnerabilities that may cause interruptions related to your use of the Node Software or Network. You agree to accept the risk of Node Software or Network failure resulting from unanticipated or heightened technical difficulties or vulnerabilities, including those resulting from cyber-attacks. \
   \
   You agree not to hold the Company accountable for any claims, damages, liabilities, costs, and expenses you may incur, directly or indirectly, in connection with or related to your use of the Node. You agree that the Company is not responsible for any Tokens or other crypto assets that you receive, transfer, hold, stake, lose or otherwise use or misuse in connection with the Node Software or the Network. \
   \
   Legal and regulatory requirements applicable to use of the Node Software may vary from jurisdiction to jurisdiction. You acknowledge and agree that you are solely responsible for evaluating the legality of using the Node Software in your jurisdiction. the Company is not responsible for determining whether or which laws and regulations may apply to you or your use of the Node Software.&#x20;

6. Disclaimer of Warranties; Limitation of Liability. EXCEPT AS EXPRESSLY SET FORTH HEREIN, THE NODE SOFTWARE AND NETWORK ARE ISSUED ON AN “AS-IS” AND “AS AVAILABLE” BASIS AND the Company DOES NOT MAKE ANY WARRANTIES WITH RESPECT TO SUCH “AS-IS” AND “AS AVAILABLE” BASIS OR OTHERWISE IN CONNECTION WITH THIS AGREEMENT (EXCEPT AS EXPRESSLY PROVIDED HEREIN) AND the Company HEREBY DISCLAIMS ANY AND ALL EXPRESS, IMPLIED OR STATUTORY WARRANTIES AND CONDITIONS, INCLUDING ANY WARRANTIES OR CONDITIONS OF NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AVAILABILITY, ERROR-FREE OR UNINTERRUPTED OPERATION, AND ANY WARRANTIES ARISING FROM A COURSE OF DEALING, COURSE OF PERFORMANCE OR USAGE OF TRADE. TO THE EXTENT THAT THE COMPANY MAY NOT, AS A MATTER OF APPLICABLE LAW, DISCLAIM ANY IMPLIED WARRANTY OR CONDITION, THE SCOPE AND DURATION OF SUCH WARRANTY OR CONDITION SHALL BE APPLIED TO THE MINIMUM EXTENT PERMITTED UNDER SUCH APPLICABLE LAW. IN NO EVENT SHALL THE COMPANY BE LIABLE TO YOU FOR ANY CONSEQUENTIAL, INDIRECT, INCIDENTAL OR SPECIAL DAMAGES OF ANY TYPE OR NATURE HOWEVER ARISING, INCLUDING, WITHOUT LIMITATION, EXEMPLARY OR PUNITIVE DAMAGES, LOST PROFITS OR REVENUES OR DIMINUTION IN VALUE, ARISING OUT OF OR RELATING TO THE NODE SOFTWARE OR THE NETWORK, WHETHER OR NOT THE POSSIBILITY OF SUCH DAMAGES HAS BEEN DISCLOSED TO OR COULD HAVE BEEN REASONABLY FORESEEN BY YOU, REGARDLESS OF THE LEGAL OR EQUITABLE THEORY (CONTRACT, TORT OR OTHERWISE) UPON WHICH THE CLAIM IS BASED. IN ADDITION, UNDER NO CIRCUMSTANCES SHALL THE COMPANY'S AGGREGATE LIABILITY UNDER THE AGREEMENT EXCEED ONE-HUNDRED U.S. DOLLARS ($100.00). SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF CERTAIN WARRANTIES OR THE LIMITATION OR EXCLUSION OF LIABILITY FOR INCIDENTAL OR CONSEQUENTIAL DAMAGES.ACCORDINGLY, SOME OF THE LIMITATIONS SET FORTH ABOVE MAY NOT APPLY TO YOU.IF YOU ARE DISSATISFIED WITH THE NODE SOFTWARE, YOUR SOLE AND EXCLUSIVE REMEDY IS TO DISCONTINUE USING THE NODE SOFTWARE.&#x20;

7. Indemnification. You agree, at your own expense, to indemnify, defend and hold harmless the Company and its partners and affiliates and their respective owners, members, agents, directors, officers, employees, representatives, affiliates, successors and assigns against any claim, suit, action, or other proceeding from and against any and all claims, damages, liabilities, costs, and expenses, including reasonable attorneys’ and experts’ fees, arising out of or in connection with your breach of the Agreement, your violation of any law or regulation or your use of the Node Software. You agree to pay any and all costs, damages and expenses, including but not limited to reasonable attorneys’ fees and costs awarded against or otherwise incurred by or in connection with or arising from any such claim, suit, action, or proceeding attributable to any such claim. the Company reserves the right, at its own expense, to assume the exclusive defense and control of any matter otherwise subject to indemnification by you, in which event you will fully cooperate with the Company in asserting any available defense. \
   \
   If you have a dispute with one or more users of the Node Software or other third parties, you release the Company (and its affiliates and service providers, and each of their officers, directors, agents, joint ventures, employees and representatives) from all claims, demands and damages (actual and consequential) of every kind and nature arising out of or in any way connected with such disputes.&#x20;

8. Dispute Resolution; Agreement to Arbitrate.&#x20;

8.1 All disputes, claims and controversies, whether based on past, present or future events, arising out of or relating to statutory or common law claims, the breach, termination, enforcement, interpretation or validity of any provision of the Agreement, and the determination of the scope or applicability of your agreement to arbitrate any dispute, claim or controversy originating from the Agreement, will be determined by binding arbitration in Tortola, the British Virgin Islands (“BVI”) pursuant to the BVI IAC Arbitration Rules, before a single arbitrator.&#x20;

8.2 The arbitrator will apply the substantive law of the BVI, excluding its conflict or choice of law rules.&#x20;

8.3 Nothing in the Agreement will preclude the parties from seeking provisional remedies in aid of arbitration from a court of appropriate jurisdiction.&#x20;

8.4 A party must notify the other party of its intent to commence arbitration prior to commencing arbitration. The notice must specify the date on which the arbitration demand is intended to be filed, which must be at least thirty (30) days after the date of the notice. During this time period, the parties will meet for the purpose of resolving the dispute prior to commencing arbitration.&#x20;

8.5 Subject to Section 8.4, each party may commence arbitration by providing to the BVI International Arbitration Centre and the other party to the dispute a written demand for arbitration, stating the subject of the dispute and the relief requested.&#x20;

8.6 Subject to the disclaimers and limitations of liability stated in the Agreement, the appointed arbitrators may award monetary damages and any other remedies allowed by the laws of the BVI (including the BVI IAC Arbitration Rules). In making a determination, the arbitrator will not have the authority to modify any term of the Agreement. The arbitrator will deliver a reasoned, written decision with respect to the dispute to each party, who will promptly act in accordance with the arbitrator’s decision. Any award (including interim or final remedies) may be confirmed in or enforced by a state or federal court located in the BVI. The decision of the arbitrator will be final and binding on the parties, and will not be subject to appeal or review.&#x20;

8.7 The party initiating the arbitration is responsible for paying the applicable filing fee. Each party will advance one-half of the fees and expenses of the arbitrator, the costs of the attendance of the arbitration reporter at the arbitration hearing and the costs of the arbitration facility. In any arbitration arising out of or relating to the Agreement, the arbitrator will award to the prevailing party, if any, the costs and attorneys’ fees reasonably incurred by the prevailing party in connection with those aspects of its claims or defenses on which it prevails, and any opposing awards of costs and legal fees awards will be offset.&#x20;

8.8 The parties will keep confidential the existence of the arbitration, the arbitration proceeding, the hearing and the arbitrator’s decision, except (a) as necessary to prepare for and conduct the arbitration hearing on the merits; (b) in connection with a court application for a preliminary remedy, or confirmation of an arbitrator’s decision or its enforcement; (c) the Company may disclose the arbitrator’s decision in confidential settlement negotiations; (d) each party may disclose as necessary to professional advisors that are subject to a strict duty of confidentiality; and (e) as applicable law otherwise requires. The parties, witnesses and arbitrator will treat as confidential and will not disclose to any third person (other than witnesses or experts) any documentary or other evidence produced in any arbitration, except as applicable so requires or if the evidence was obtained from the public domain or was otherwise obtained independently from the arbitration.&#x20;

8.9 In the case of a conflict between the provisions of this Section 8 and the BVI IAC Arbitration Rules, the provisions of this Section 8 shall prevail.&#x20;

8.10 To the extent permitted by applicable law, any dispute arising out of or relating to the Agreement, whether in arbitration or in court, shall be conducted only on an individual basis and not in a class, consolidated or representative action. Notwithstanding any other provision of the Agreement or the BVI IAC Arbitration Rules, disputes regarding the interpretation, applicability or enforceability of this className waiver may be resolved only by a court and not by an arbitrator. If this waiver of className or consolidated actions is deemed invalid or unenforceable, neither party is entitled to arbitration.&#x20;

8.11 If for any reason a claim or dispute proceeds in court rather than through arbitration, each party knowingly and irrevocably waives any right to trial by jury in any action, proceeding or counterclaim arising out of or relating to the Agreement.&#x20;

9. Term; Termination.&#x20;

9.1. The Agreement is effective beginning when you accept the Agreement or first access or use the Node Software and ending when terminated as set forth in Section 9.2.&#x20;

9.2. We reserve the right to restrict, ban, or blacklist your use or your ability to claim Network Rewards (any such event, a “Termination”) for any reason, including, but not limited to, in the case of your dishonest or fraudulent submission of your information for the purposes of identity verification or engage in prohibited activities or otherwise violate the good faith use of the Node and Network. Your right to use and access the Node Software will automatically terminate upon any Termination. Termination will be effective without notice.&#x20;

9.3. Upon termination of the Agreement, you must immediately cease all use of the Node Software and destroy all copies, full or partial, of the Node Software. Sections 4, 5, 6, 7, 8, 9 and 10 of this Agreement shall survive any such termination. <br>

10. General Provisions.&#x20;

10.1 Electronic Communications. By purchasing, obtaining, accessing or using the Node Software, you consent to receive electronic communications.&#x20;

10.2 Notices. the Company may provide you with notice and other communications via electronic communications as permitted by Section 10.1. You may provide us with notice by sending an email address to <support@chasm.net>. All notices will be deemed effective upon dispatch.&#x20;

10.3 Amendments. The Agreement may be modified or revised at any time, with or without prior notice to you. The most current version of the Agreement will be posted on a website to be determined by the Company (the “Website”) with the “Last Revised” date at the top. Any modifications or revisions will be effective immediately upon posting the modifications or revisions to the Website. You shall be responsible for reviewing and becoming familiar with any modifications or revisions. You waive any right you may have to receive specific notice of such modifications or revisions. Purchasing, obtaining, accessing or using the Node Software constitutes your acceptance of the Agreement as modified or revised. If you do not agree to the Agreement then in effect, you must immediately discontinue access to, and use of, the Node Software.&#x20;

10.4 Waivers. For a waiver to be deemed effective, a waiver must be in a writing signed by the waiving party. The failure of either party to enforce any provision of the Agreement will not constitute a waiver of that party’s rights to subsequently enforce the provision.&#x20;

10.5 Cumulative Rights; Injunctions. The rights and remedies of the parties under the Agreement are cumulative, and each party may exercise any of its rights and enforce any of its remedies under the Agreement, along with all other rights and remedies available to it at law, in equity or otherwise. Any material breach by a party of the Agreement could cause the non-breaching party irreparable harm for which the non-breaching party has no adequate remedies at law. Accordingly, the non-breaching party is entitled to seek specific performance or injunctive relief for any such breach.&#x20;

10.6 Severability. If any provision of these the Agreement is declared to be invalid, illegal or unenforceable by a court of competent jurisdiction, then the validity, legality and enforceability of the remaining provisions contained herein shall not be affected thereby and the remainder of the provisions of the Agreement shall remain valid, legal and enforceable to the fullest extent permitted by law.&#x20;

10.7 Force Majeure. the Company shall have no liability for any failure or delay resulting from any condition beyond our reasonable control, including but not limited to governmental action or acts of terrorism, earthquake, fire, flood, or other acts of God, labor conditions, power failures, equipment failures and Internet or blockchain network disturbances.&#x20;

10.8 Successors and Assigns. You may not transfer or assign the Agreement or any rights or obligations hereunder, by operation of law or otherwise and any such attempted assignment shall be void. the Company reserves the right to freely transfer or assign the Agreement and the rights and obligations hereunder to any third party at any time without your consent and prior notice to you. If you object to any such transfer or assignment, you may stop using the Node Software.

10.9 Relationship of the Parties. Nothing contained in the Agreement shall constitute you and the Company as members of any partnership, joint venture, association, syndicate, unincorporated business or similar assignment as a result of or by virtue of the relationship established by the Agreement.&#x20;

10.10 Governing Law. The Agreement shall be solely and exclusively governed, construed and enforced in accordance with the laws of the BVI without giving effect to conflict of law rules or principles that would cause the application of the laws of any other jurisdiction.&#x20;

10.11 Entire Agreement. The Agreement constitutes the entire agreement and understanding between you and the Company, and supersedes all previous communications, representations or agreements, whether written or oral, with respect to the subject matter hereof.&#x20;

10.12 No Third-Party Beneficiaries. The Agreement is not intended and shall not be construed to create any rights or remedies in any parties other than you and the Company and other Company affiliates, which each shall be a third-party beneficiary of the Agreement, and no other person shall assert any rights as a third-party beneficiary hereunder.

10.13 Subject to Change. You understand that these Terms of Use are subject to change without notice and you are required to check these Terms from time to time for any such changes.

<br>


