NOS Token

The utility token powering NitroGraph's infrastructure

NOS is NitroGraph's native utility token, serving as the fuel for all network operations and governance.

Token Type: Utility token with governance rights Current Phase: Testnet (using NOS tokens) TGE: 2026 with mainnet launch

Token Utility

Primary Functions

const NOSUtility = {
    // 1. Gas for all transactions
    gas: {
        usage: "Every transaction burns NOS",
        cost: "Extremely low but not free (anti-spam)",
        estimation: "~0.0001 NOS per operation *",
        batching: "Reduces gas by up to 99% *"
    },
    
    // 2. Network capacity staking
    capacityStaking: {
        purpose: "Provide network capacity and anti-spam protection",
        minimum: "Varies by agent transaction volume *",
        rewards: "Share of protocol transaction fees",
        slashing: "For misbehavior"
    },
    
    // 3. Validator staking
    validatorStaking: {
        minimum: 100_000, // NOS required *
        rewards: "Transaction fees + emissions",
        slashing: "For misbehavior"
    },
    
    // 4. Fee voting through consensus
    feeConsensus: {
        mechanism: "Variance-weighted consensus",
        stakeWeight: "Quantity × √time",
        automatic: "No governance votes needed"
    },
    
    // 5. Revenue sharing
    revenueShare: {
        source: "Protocol fees from NUSDC transactions",
        distribution: "Pro-rata to stakers",
        compounding: "Automatic reinvestment option"
    }
};

*Illustrative purposes, subject to change

Variance-Weighted Fee Consensus

Revolutionary Fee Discovery

Instead of governance votes, NitroGraph uses mathematical consensus for fee setting:

# How it works
def fee_consensus():
    """
    Each staker proposes optimal fee
    System finds consensus mathematically
    """
    # 1. Weight by stake and time
    weight = stake_amount * sqrt(lock_time)
    
    # 2. Calculate weighted average
    average_fee = weighted_mean(all_proposals)
    
    # 3. Penalize extreme proposals
    variance_penalty = exp((proposal - average)² / average² - 1)
    
    # 4. Converge to optimal fee
    optimal_fee = minimize_variance(all_proposals)
    
    return optimal_fee

Benefits

• No voting fatigue: Automatic fee adjustment

• Market-driven: Responds to actual network conditions

• Sybil resistant: Time-lock prevents gaming

• Always optimal: Mathematics finds equilibrium

Time-Lock Innovation

Perpetual Bonds Model

const perpetualBonds = {
    // Lock tokens for continuous rewards
    mechanism: "Time × Stake = Weight",
    
    // Longer locks = higher rewards
    rewards: {
        "30 days": "1x multiplier *",
        "90 days": "1.5x multiplier *",
        "180 days": "2x multiplier *",
        "365 days": "3x multiplier *"
    },
    
    // Early exit penalties
    penalties: {
        "< 30 days": "50% penalty *",
        "< 90 days": "25% penalty *",
        "< 180 days": "10% penalty *"
    }
};

*Illustrative purposes, subject to change

Token Distribution

Initial Allocation

Category	Allocation	Vesting
Team & Advisors	20% *	4-year linear
Investors	15% *	2-year linear
Ecosystem Fund	30% *	10-year release
Validators	10% *	Immediate
Community	25% *	Various programs

*Illustrative purposes, subject to change

Emission Schedule

# Dynamic issuance model (S-curve)
def emission_rate(network_usage):
    """
    Emissions increase with usage, then plateau
    """
    base_rate = 2_000_000  # Annual *
    
    # Logistic growth function
    growth = 1 / (1 + exp(-network_usage))
    
    # Scale emissions
    emissions = base_rate * growth
    
    # Cap at maximum
    return min(emissions, 10_000_000)  # Annual cap *

*Illustrative purposes, subject to change

Fee Distribution Waterfall

graph TD
    A[Transaction Fees] --> B{Distribution}
    B -->|40%| C[Validators *]
    B -->|30%| D[NOS Stakers *]
    B -->|20%| E[Protocol Treasury *]
    B -->|10%| F[NUSDC Bonders *]
    
    E --> G[Development]
    E --> H[Grants]
    E --> I[Insurance]

*Illustrative purposes, subject to change

Governance Rights

Current Implementation

• Parameter adjustment: Fee ranges, staking requirements

• Protocol upgrades: Via timelock contracts

• Treasury management: Allocation of protocol funds

Future Vision (Research Phase)

These features are experimental and may not be implemented:

• 100% Algorithmic Governance: Fully autonomous protocol decisions

• Oracle-free parameters: Self-adjusting system variables

• AI-driven optimization: Machine learning for protocol parameters

Staking Rewards

APY Calculation

function calculateAPY(
    stakeAmount: number,
    lockDuration: number,
    networkFees: number
): number {
    // Base APY from emissions
    const baseAPY = 8; // 8% *
    
    // Time multiplier
    const timeBonus = Math.sqrt(lockDuration / 365);
    
    // Fee share
    const feeShare = (stakeAmount / totalStaked) * networkFees;
    
    // Total APY
    return baseAPY * timeBonus + feeShare;
}

// Example returns
// 30-day lock: 8-12% APY *
// 90-day lock: 12-18% APY *
// 365-day lock: 18-30% APY *

*Illustrative purposes, subject to change

Security Features

Slashing Conditions

Violation	Penalty
Double signing	5% stake *
Downtime > 24h	1% stake *
Invalid blocks	10% stake *
Malicious behavior	100% stake *

*Illustrative purposes, subject to change

Volume Discounts

Earning-Based Fee Reduction

The more NUSDC transactions your agent earns/triggers on the network, the lower your transaction fees:

def calculate_volume_discount(agent_earnings):
    """
    Volume discounts based on agent transaction volume
    Thresholds and percentages set during testnet
    Published for decentralized governance by mainnet
    """
    # Example tier structure (subject to change during testnet)
    discount_tiers = {
        "tier_1": {
            "min_volume": 0,           # NUSDC earned/triggered *
            "max_volume": 10_000,      # NUSDC *
            "discount": 0              # No discount *
        },
        "tier_2": {
            "min_volume": 10_000,      # NUSDC *
            "max_volume": 100_000,     # NUSDC *
            "discount": 0.10           # 10% discount *
        },
        "tier_3": {
            "min_volume": 100_000,     # NUSDC *
            "max_volume": 1_000_000,   # NUSDC *
            "discount": 0.25           # 25% discount *
        },
        "tier_4": {
            "min_volume": 1_000_000,   # NUSDC *
            "max_volume": 10_000_000,  # NUSDC *
            "discount": 0.40           # 40% discount *
        },
        "tier_5": {
            "min_volume": 10_000_000,  # NUSDC *
            "max_volume": float('inf'),
            "discount": 0.60           # 60% discount *
        }
    }
    
    # Find applicable tier
    for tier in discount_tiers.values():
        if tier["min_volume"] <= agent_earnings < tier["max_volume"]:
            return tier["discount"]
    
    return 0

*Illustrative purposes - exact thresholds and percentages will be determined during testnet

How Volume Discounts Work

const volumeDiscountMechanism = {
    // Tracking
    measurement: "Total NUSDC value earned/triggered by agent",
    period: "Rolling 30-day window",
    
    // Application
    applies_to: "Transaction fees on NUSDC transfers",
    automatic: "Discount applied automatically based on volume",
    
    // Benefits
    benefits: {
        highVolume: "Large operators get fair volume pricing",
        growth: "Incentivizes agent activity and network usage",
        retention: "Rewards loyal, active agents"
    },
    
    // Governance
    parameters: {
        testnet: "Network determines optimal thresholds",
        mainnet: "Published protocol for deterministic governance"
    }
};

Volume Discount Examples

// Small agent example
const smallAgent = {
    monthlyVolume: 5_000,        // NUSDC earned *
    baseFee: 0.025,              // 2.5% transaction fee *
    discount: 0,                 // No discount yet
    effectiveFee: 0.025          // 2.5% *
};

// Medium agent example
const mediumAgent = {
    monthlyVolume: 250_000,      // NUSDC earned *
    baseFee: 0.025,              // 2.5% *
    discount: 0.25,              // 25% discount *
    effectiveFee: 0.01875        // 1.875% *
};

// Large agent example
const largeAgent = {
    monthlyVolume: 5_000_000,    // NUSDC earned *
    baseFee: 0.025,              // 2.5% *
    discount: 0.40,              // 40% discount *
    effectiveFee: 0.015          // 1.5% *
};

// Enterprise agent example
const enterpriseAgent = {
    monthlyVolume: 50_000_000,   // NUSDC earned *
    baseFee: 0.025,              // 2.5% *
    discount: 0.60,              // 60% discount *
    effectiveFee: 0.010          // 1.0% *
};

*Illustrative purposes, subject to change

Token Economics

Value Accrual

# How NOS captures value
value_drivers = {
    "Transaction Volume": "More fees to distribute",
    "Network Growth": "Increased demand for gas and capacity",
    "Staking Ratio": "Supply reduction",
    "Volume Discounts": "Incentivizes high-value agent activity",
    "Fee Distribution": "NOS earns from NUSDC transaction fees"
}

Deflationary Mechanics

• Gas burning: Every transaction burns NOS

• Slashing: Misbehavior removes tokens

• Time locks: Reduces circulating supply

• Capacity staking: Locks tokens for network capacity

Integration with NUSDC

const nusdcSynergy = {
    // NOS earns from NUSDC transaction fees
    feeSharing: "30% of NUSDC transaction fees go to NOS stakers",
    
    // Both can be staked for capacity
    capacityStaking: "Stake NOS or NUSDC for network capacity",
    
    // Volume discounts apply to NUSDC transactions
    volumeDiscounts: "Higher NUSDC volume = lower fees for agents"
};

*Illustrative purposes, subject to change

FAQ

Q: Is NOS only for testnet? A: No, NOS is the permanent token name for both testnet and mainnet. There is no separate mainnet token.

Q: How is this different from other L1 tokens? A: NOS uses variance-weighted consensus for fee discovery instead of governance votes, creating more efficient price discovery.

Q: When will advanced features launch? A: Core features launch with mainnet (2026). Advanced algorithmic features are in research and may launch 2027+ if proven safe.

Q: Is there a maximum supply? A: Yes, 1 billion NOS maximum supply with dynamic emissions based on network usage. *

*Illustrative purposes, subject to change

---

NOS: Fueling the autonomous agent economy.