# Introduction

**Seamlessly Transforming Idle AI & Robotics Infrastructure into On-Chain Yield**

In the new connected world of AI, robotics and advanced automation, there is no reason why any networked device should be sitting idle and not producing value at any given point in time. Yet the global economy is struggling to adapt to this reality, with unplanned downtime costs currently estimated at $1.4T annually. 

Idle Network is building the solution to the trillion dollar problem by providing the infrastructure to bring idle devices on-chain and transform them into collateral for AI-optimized on-chain yield. We’re building a platform where anyone from the largest global blue chip enterprises down to solo individuals can earn from their idle devices without needing Web3 knowledge, complex wallet management, or any technical expertise.

As robotics and physical AI come online, Idle Network turns downtime into yield. Meanwhile we also allow supporting infrastructure for AI operations like MCUs, IOT devices, compute, storage, and bandwidth to be routed into Omni-Platform MetaVaults on Base.

This is achieved via a 3 part solution:\
\
**Idle Enterprise Asset Solution**: Connect idle devices that could be put to use by other businesses or individuals to the Idle Network. Earn yield from device categories including warehouse drones, idle factory robots, microcontroller units (MCUs) and IOT devices, and unused compute, storage and bandwidth.

**Idle Consumer Asset Solution**: Convert your smart and connected devices including smart cameras, smart speakers, any device with an IOT sensor and idle compute, storage and bandwidth from laptops and phones into yield in a wide range of on-chain networks.

**MetaVaults**: Our smart contract system that connects devices to end users and on-chain networks and then compounds rewards using AI-optimized, automated DeFi strategies. This MetaVaults solution consists of 2 parts:

* **Omni-Platform MetaVaults**: Puts devices to work on existing device reward networks (e.g. Golem for compute (CPU & GPU), Helium for hotspots, Render for GPU etc.), harvests rewards and then automatically deploys them into high-yield, on-chain strategies, such as ReStaking or Lending Pools. Think of it as a personal auto-compounding bank for idle infrastructure.
* **Native MetaVaults**: Idle Network will then launch its own native device reward networks for exotic assets such as robotics, drones and any high value, high demand connected device category currently uncatered to by existing networks. The networks will serve as a discovery marketplace for idle assets, connecting asset owners to those seeking discounted asset capacity, and allowing asset owners to compound their revenues via the same automated AI-optimized on-chain yield strategies deployed in the Omni-Platform MetaVaults.

In combination, these solutions will ultimately allow any idle infrastructure from any enterprise or consumer category to be monetized into constantly compounding on-chain yields that puts trillions of dollars of otherwise under-exploited assets to use.

<br>


# Why Idle Assets Need to Be Monetized

The world has entered an age where connected machines, AI, and robotics now power the backbone of the global economy. But despite their sophistication, these assets remain deeply underutilized.

* **Trillions of dollars in downtime**: Enterprises lose over $1.4 trillion annually to unplanned downtime in robotics and automated infrastructure. Idle drones, robots, and connected devices represent wasted capital and lost revenue opportunities.
* **Fragmented utilization networks**: Existing device reward systems are limited in scope, leaving entire categories of high-value infrastructure, from factory robots to warehouse drones without a monetization pathway or customer discovery portal.
* **Barrier to entry for individuals**: Consumers who want to monetize idle capacity from laptops, phones, or hotspots face complex wallet setups, opaque DeFi strategies, and high technical friction. Most simply opt out.
* **Disconnection between connected devices & DeFi yield**: Even in cases where devices can earn on-chain yields, these yields are disconnected from the world of DeFi, with no easy way to easily auto-compound them into high-yield on-chain strategies.

This combination of inefficiency, fragmentation, and disconnect creates a massive global paradox: at the same time that businesses and individuals are investing heavily in AI and robotics, the majority of these assets spend large portions of their lifecycle sitting idle and unproductive.

<br>


# Core Product Summary & Staged Roll-Out Strategy

The Idle Network Consumer & Enterprise Asset Solutions are underpinned by 4 key products:

1. **Idle Smart Device & Compute, Storage & Bandwidth POC**

Focuses on the most readily available and easily deployable assets, namely idle compute, storage, and bandwidth. These categories provide the lowest barrier to entry for both enterprises and consumers, allowing Idle Network to demonstrate proof of concept and generate immediate yields through Omni-Platform MetaVaults that plug into existing device reward networks.

2. **Idle Robotics & Drones Marketplace**

Robots and drones run Idle’s lightweight node as a sidecar agent, submitting proofs of useful work through sensor attestations, ZKPs, and secure enclaves without interfering with flight or control systems. Verified rewards are routed into MetaVaults, where compounding strategies convert downtime into yield.

3. **Idle MCU & IoT Marketplace**

Idle’s Edge Compiler compresses ML models into <10 KB binaries, enabling even 256 KB MCUs and IoT devices to run inference and connect via the lightweight node. Contributions of compute, storage, or bandwidth are verified on-device and auto-deployed into Idle Vaults for compounding yield.

4. **OEM Licensing Stack**

Idle’s OEM integration bundles the Edge Compiler, lightweight node, and optional accelerator IP directly into device firmware, making devices “Idle-ready” at shipment. OEM devices can securely sign, submit, and verify tasks on Ethereum L2s, Solana, or Cosmos, with rewards funneled to MetaVaults under per-unit or revenue-share licensing.\
\
The Idle Network product suite will be rolled out in 4 stages as follows:\
\
**STEP 1: Idle Smart Device & Compute, Storage & Bandwidth PoC**\
Launch with abundant compute, storage, and bandwidth to prove yield flow via existing reward networks.

**STEP 2. Idle Robotics & Drones Marketplace**\
Expand to robots and drones, monetizing predictable downtime with secure proof layers.

**STEP 3. Idle MCU & IoT Marketplace**\
Scale to billions of IoT and MCU devices using the Idle Edge Compiler for ultra-light integration.

**STEP 4. OEM Licensing Stack**\
Embed Idle directly in device firmware via OEM licensing for default, factory-level adoption.


# User Personas

**Once the full 4-stage product roll-out process outlined is complete, Idle** Network **is aimed to service the following examples of user personas:**\
\
**1. Enterprise Operations Manager**

* **Profile**: Oversees robotics, drones, or automated systems within large-scale industrial, logistics, or manufacturing settings.
* **Pain Point**: Downtime in equipment leads to high costs, inefficiencies, and lost output.
* **Value from Idle** Network: Converts downtime into continuous yield by plugging idle assets into Idle Network's Enterprise Asset Solution and MetaVaults.

**2. IT Infrastructure Lead**

* **Profile**: Manages underutilized servers, compute clusters, or networking infrastructure in enterprises or data centers.
* **Pain Point**: Idle or over-provisioned resources lead to sunk costs and wasted capacity.
* **Value from Idle** Network: Redirects unused compute, storage, and bandwidth into Omni-Platform MetaVaults, seamlessly compounding rewards across existing device reward networks.

**3. Robotics Startup Founder**

* **Profile**: Early-stage entrepreneur deploying robotics fleets or autonomous systems.
* **Pain Point**: Lacks liquidity to scale hardware deployment quickly.
* **Value from Idle** Network: Lists devices in Native MetaVaults marketplaces to source temporary users and generate immediate yield and reinvest revenues into growth.

**4. Everyday Consumer**

* **Profile**: Owns devices such as laptops, phones, mobile hotspots, or home nodes.
* **Pain Point**: Wants to monetize unused capacity without complex technical setup.
* **Value from Idle** Network: Contributes idle resources through the Consumer Asset Solution and benefits from AI-optimized compounding yield, without Web3 knowledge.<br>

**5. DeFi Yield Seeker**

* **Profile**: Crypto-native investor looking for new high-yield opportunities backed by real-world assets.
* **Pain Point**: Existing DeFi yields are saturated and often purely speculative.
* **Value from Idle** Network: Gains exposure to device-backed collateral through MetaVault strategies, accessing real, productive asset yields.


# Marketplace Overview

The PoC described later in this documentation demonstrates a product architecture for monetizing idle assets. It will start by testing out the architecture using regular compute, storage and bandwith idle resources before plugging in its Robotics & Drones Marketplace to allow more exotic asset categories to be transformed into yield bearing assets.

We are prioritizing these asset categories due to:

* **Industrial downtime costs**: Robots and drones in logistics, factories, agriculture, and surveillance spend significant time idle. A warehouse AGV (Automated Guided Vehicle) may run 16 hours/day and sit unused for 8 hours. A delivery drone may complete a handful of routes daily but remain parked most of the time. Globally, this idle time maps to trillions of dollars in underutilized capital assets.
* **Market scale**: The global robotics market exceeded $40B in 2023, projected to hit $160B by 2030 (CAGR >20%). Drone market expected to surpass $55B by 2030 (MarketsandMarkets).
* **AI-native hardware**: Modern drones/robots already run embedded AI models (vision, SLAM, obstacle avoidance). With Idle’s compiler + accelerator stack, these models can be optimized and validated on-device, then linked to blockchain reward systems.

Idle Network’s robotics and drones marketplace will allow owners of robots/drones to “lend out” idle time with security guarantees, automatic yield, and integration into DeFi vaults.\
\
The architecture of the Robotics/Drones Marketplace has four main layers that we outline in more detail in the following pages::

1. **On-device node** (lightweight blockchain + AI runtime).
2. **Marketplace layer** (smart contracts, scheduling, pricing).
3. **Verification & Proof layer** (ensuring robots actually perform useful work).
4. **Vault compounding layer** (converting earned rewards into yield).

<br>


# On-Device Nodes

Robots and drones typically run on embedded SoCs (System-on-Chip) or edge computers like NVIDIA Jetson, Qualcomm Snapdragon, or ARM Cortex-A53 SBCs.

This creates several challenges including:

* Limited power budgets (battery constraints).
* Real-time workloads (flight control, sensor fusion).
* Safety-critical OS (ROS2, PX4 autopilot).

Idle’s lightweight efficient node is therefore designed to:

* Run as a sidecar agent alongside the robot’s primary control software.
* Handle blockchain signing, proof submission, and task verification without interfering with flight/navigation safety.
* Support hardware acceleration (via Idle Edge-AI Compiler or custom NPUs) for fast inference on proof tasks.

Example:

* A delivery drone parks after a route. Idle Agent activates.
* The drone runs PoC (Proof-of-Compute) workloads (image recognition, crypto math) during idle time.
* Rewards harvested → sent to Idle Vault contract.


# Marketplace Layer

At the blockchain level, the marketplace manages task requests, robot supply, and pricing.

* **Task Registry**: Customers post tasks → “scan area with drone,” “inspect pipeline with robot camera,” “run anomaly detection on warehouse footage.”
* **Matching Engine**: Idle Network marketplace matches task requirements to available idle drones/robots.
* **Escrow Contracts**: Customers deposit payment tokens into escrow. Robot completes proof-of-work/task → escrow releases payment.
* **Dynamic Pricing**: Prices adjust by demand, similar to Uber surge pricing.

Key smart contracts:

* Registry Contract (stores available robots/drones with capabilities).
* Job Contract (escrow, milestones, proof submission).
* Vault Contract (auto-compounds earnings).


# Verification & Proof Layer

The hardest problem: How do we know a robot actually did the job?

Idle Network deploys the following technique:

1. **Sensor Proofs**: Robot signs sensor outputs (e.g., GPS logs, video hashes).
2. **Zero-Knowledge Proofs (ZKPs)**: Instead of uploading raw video (huge bandwidth/privacy risk), robot generates ZK proof that it processed footage correctly.
3. **Example**: “I detected 15 objects in this video stream” → proof verifies computation was correct without exposing video.
4. **Remote Auditing**: Third-party verifiers randomly challenge robots to perform micro-tasks (e.g., move camera, return sensor data).
5. **Hardware Attestation**: Use ARM TrustZone/TPM to ensure Idle Agent is running in secure enclave.

This verification layer is critical to prevent fake participation (e.g., a malicious actor pretending to run drones).


# Vault Compounding

Once a robot or drone earns tokens:

* Rewards (AKT, HNT, FIL, RNDR, or custom marketplace tokens) are sent to Idle Vault.
* Vault swaps them into stablecoins or ETH.
* Auto-compounding strategies applied:
* LST (Liquid Staked ETH).
* Stablecoin lending (Aave, Compound).
* Restaking via EigenLayer.

This guarantees owners don’t just earn tokens—they earn compounded yield.


# Example Use Cases & Strategic Pilots

Examples of how the marketplace will work in action include:

#### a. Drone Surveillance Marketplace

* Security company posts job: “Surveil warehouse perimeter from 12–2 AM.”
* Idle Vault matches with drones parked nearby.
* Drones activate, run task, upload proofs.
* Payment auto-released from escrow.
* Drone owner earns $10 worth of tokens → compounded into ETH yield.

#### b. Agricultural Robot Marketplace

* Farmer has weeding robots idle at night.
* Marketplace posts “process crop health data from satellite images.”
* Robots run AI model locally, submit proof.
* Farmer earns yield from idle time.

To validate the marketplace initially, Idle Network will focus on 3 pilot programs:

* **Pilot 1:** Drones in agriculture (crop health analysis).
* **Pilot 2:** Warehouse AGVs for off-shift anomaly detection.
* **Pilot 3:** Security drones for nighttime patrols.

All feed into Idle MetaVaults for yield compounding.

<br>


# Marketplace Overview

The Idle Robotics & Drones Marketplace will be complemented by the **Idle MCU & IOT Marketplace** to extract yield from another high value idle asset category.\
\
Embedded microcontrollers (MCUs) are inside many everyday appliances, whilst billions of IoT sensors and devices are being rolled out in both industrial and consumer contexts. Consider the following:<br>

* A smart speaker like Amazon Echo may use its compute resources for only a few seconds per day when it responds to voice commands. The rest of the time, its digital signal processor (DSP) and MCU sit in idle or low-power standby.
* An industrial robot arm in a car factory may be scheduled for active tasks during production cycles but could remain idle for 40–60% of the day during reconfiguration, shift changes, or maintenance cycles.
* Billions of sensors and IoT devices (Internet of Things devices) are designed to report data intermittently (temperature every 5 minutes, motion detection every hour, etc.). Their compute capacity remains underutilized between reporting cycles.

Idle Network MCU & IOT marketplace solves this problem by bringing these devices on-chain and allowing in-need businesses to rent their idle capacity. <br>


# Core Concepts

**Microcontrollers (MCUs)**

An MCU (Microcontroller Unit) is a compact integrated circuit (IC) designed to control specific embedded tasks. Unlike CPUs (Central Processing Units) in laptops/servers, which are designed for general-purpose tasks, MCUs are:

* Low-power (as low as milliwatts).
* Low-cost (a few dollars per chip).
* Single-task focused (control, monitoring, automation).

Examples of MCU families:

* ARM Cortex-M series (widely used in IoT, drones, smart appliances).
* AVR microcontrollers (e.g., Arduino boards).
* ESP32/ESP8266 (Wi-Fi enabled IoT MCUs).

An MCU typically integrates:

* CPU Core: Executes instructions (often ARM Cortex-M, RISC-V, or custom cores).
* SRAM: Small volatile memory for runtime variables.
* Flash Storage: Non-volatile storage for firmware and programs.
* Peripherals: Interfaces like GPIO (General Purpose Input/Output), ADC (Analog to Digital Converters), SPI (Serial Peripheral Interface), and I²C (Inter-Integrated Circuit).

Why MCUs are important:

* They are everywhere. Almost every electronic device, from cars to coffee machines. uses them.
* They are energy-efficient, making them perfect for edge computing tasks.
* They are affordable and thus scalable globally.

In Idle Network’s design, MCUs are not just controlling appliances. With lightweight AI compilers (explained later), they can run tiny AI models (TinyML) and contribute excess cycles to Vault networks.

**IoT Devices**

The Internet of Things (IoT) refers to a network of physical devices embedded with sensors, processors, and connectivity that allows them to collect and exchange data.

Examples:

* Consumer IoT: Smart bulbs, thermostats, door cameras, fitness trackers.
* Industrial IoT (IIoT): Smart meters, predictive maintenance sensors, autonomous guided vehicles (AGVs), logistics trackers.
* Infrastructure IoT: Smart traffic lights, environmental monitoring stations, water level sensors.

IoT Characteristics:

* Connectivity: Typically use Wi-Fi, ZigBee, LoRaWAN, Bluetooth LE, or cellular (4G/5G).
* Data collection: Sensors measure physical parameters (temperature, vibration, location).
* Local compute: Small processors (MCUs or low-power SoCs) filter and preprocess data.
* Intermittent activity: Devices spend 70–95% of their time idle, waiting for events.

IoT Market Size:

* In 2024, \~16.6 billion IoT devices.
* By 2025–2026, expected to exceed 20 billion devices.
* Each represents a potential micro-node in Idle Network’s Vault network.


# Resource Contribution & Yield Pathway

The Idle Network MCU & IOT marketplace will operate via the following flow:<br>

1. **Devices run lightweight nodes to securely connect.**\
   Every connected device spins up an ultra-light node that links it directly into the Idle Network network. These nodes establish secure communication channels, authenticate the device, and verify resource availability without draining performance or compromising security.

2. **Devices contribute compute/storage/bandwidth when idle.**\
   When not in active use, devices automatically allocate surplus resources to decentralized networks. Contributions are designed to be non-disruptive, activating only during downtime.

3. **Vaults harvest rewards from existing rewards networks.**\
   Idle connects devices to the leading decentralized reward ecosystems where their contributions earn native tokens. These tokens flow directly into  MetaVaults, which act as automated collectors, ensuring seamless accumulation of rewards across multiple networks without user intervention.

4. **Rewards are auto-compounded into high-yield DeFi strategies (staking, lending).**\
   Instead of leaving rewards idle, Vaults convert and deploy them into proven DeFi strategies like staking, liquidity provision, or lending markets on protocols such as Aave, Compound, or Lido. This transforms raw network rewards into diversified, compounding income streams—maximizing yield for device owners while reducing exposure to single-asset volatility

This process seamlessly transforms idle assets into passive income for device owners.


# Example Use Cases

**Enterprise MCU Example:**\
Now imagine an automotive manufacturer with tens of thousands of vehicles in storage, each equipped with advanced IoT microcontrollers and connectivity modules. While parked, these vehicles’ MCUs and bandwidth go unused. Idle Network activates that idle potential, connecting them into decentralized IoT reward ecosystems (for example, networks rewarding devices for real-time environmental sensing or secure data transmission). The earned tokens are routed into Idle MetaVaults, where they are diversified into auto-compounding DeFi strategies. At scale, this transforms fleets of inactive vehicles into distributed yield generators, offsetting operational costs and turning downtime into measurable income.\
\
**Consumer IoT Example:**\
Consider a smart thermostat installed in a household. Most of the time, its microcontroller unit (MCU) sits idle, only occasionally adjusting heating or cooling. Through Idle Network, that dormant compute capacity and network connection can be contributed to decentralized IoT reward networks. The thermostat earns tokens for tasks such as lightweight data validation or sensor mesh relaying. Idle’s MetaVaults automatically aggregates these rewards, converts them into a stable or blue-chip crypto asset, and compounds them in DeFi lending protocols. For the homeowner, the thermostat doesn’t just save energy—it generates a passive income stream in the background.


# Background Context

To understand why OEM licensing monetization matters so much, we have to look at how technology ecosystems historically scaled.

* Qualcomm & ARM: Instead of selling chips directly to every consumer, they licensed their chip architectures(Snapdragon, Cortex) to device manufacturers. This OEM model meant every phone, laptop, or IoT device was built with their IP at the core.
* Microsoft Windows: Instead of convincing every consumer to install DOS/Windows, Microsoft signed OEM agreements with PC makers. When you bought a PC, the OS was already pre-loaded.
* Google Android: Instead of selling Android directly, Google licensed it for free to OEMs. They captured the market because Android was the default software environment for most devices.

Idle Network can follow the same path: by making its compiler, light node, and vault hooks part of the default firmware/software stack of devices from the moment they leave the factory.

The OEM channel removes end-user friction and scales Idle Network by the thousand-unit shipment rather than by individual user onboarding.


# The Idle Edge Compiler

The Idle Edge Compiler converts standard ML models (ONNX, TensorFlow Lite, PyTorch exported to ONNX) into lightweight C code or pre-compiled binaries that can run directly on MCUs (Microcontrollers) or IoT devices.

**Why OEM Needs This:**

* Most IoT/MCU devices run on 256 KB – 1 MB SRAM. Traditional ML runtimes (TensorFlow Lite Micro, PyTorch Mobile) are too heavy, adding \~100 KB+ runtime overhead.
* Idle’s compiler reduces overhead to <10 KB, allowing inference at near bare-metal speed.
* Supports quantization (INT8, INT4, even binary neural nets), making models fit into ultra-constrained devices.

**Example Flow:**

* OEM engineer trains a model in PyTorch (e.g., anomaly detection for motor vibration).
* Export model → ONNX format.
* Run Idle Compiler → outputs optimized C library + lightweight Idle Node hooks.
* OEM integrates compiled code into their device firmware image.


# Lightweight Idle Nodes

Idle Network's Lightweight Idle Nodes act as the blockchain agent of the device. Handles signing, submitting proofs, and interacting with Idle MetaVaults.

**Implementation:**

* Written in C/C++ for portability across ARM Cortex-M, RISC-V MCUs, and Linux-based IoT boards.
* Uses ECC (Elliptic Curve Cryptography, e.g., secp256k1) for wallet signing.
* Runs in low-duty cycles (e.g., 1% CPU usage, waking only for blockchain submissions).
* Can use ARM TrustZone or RISC-V PMP (Physical Memory Protection) to sandbox itself from OEM firmware functions.

**Blockchain Compatibility:**

* Ethereum L2s (Base, Optimism, Arbitrum) via lightweight RPC clients.
* Solana or Cosmos ecosystems via GRPC light clients.
* Pluggable backend for MetaVault integration (abstracts away multi-chain complexity).


# Hardware Accelerator

For higher-end devices like drones, service robots, industrial cobots, the Idle Network stack can include the Edge-AI Accelerator IP:

* IP Core licensed to OEMs → integrated alongside their main SoC.
* Provides 140 FPS inference throughput @ 50 W, nearly 2× faster than equivalent GPU at 60% less power.
* Optimized for matrix multiplications (GEMM ops) common in CNNs (Convolutional Neural Nets).
* Interfaces with the Idle Compiler to accept quantized model binaries.

This gives OEM devices a dual purpose: they perform their primary function and generate financial yield through Idle tasks when idle.

<br>


# OEM Licensing Business Models

Idle Network aims to offer flexible licensing business models to account for different use cases. These options include&#x20;

1. Per-Unit License
2. OEM pays $0.10–$5 per device shipped with Idle integration.
3. Similar to how ARM licenses CPU cores or Qualcomm licenses modems.
4. Revenue Share
5. Devices connected to Idle Vaults share yield.
6. Example: A drone earns $20/month → Idle takes 10%, OEM takes 10%, user keeps 80%.
7. Hybrid (Most Realistic)
8. Small licensing fee + ongoing rev share.
9. Incentivizes OEMs to deploy widely but still gives Idle recurring upside.


# Pilot Roll-Out Plan

####

The Idle Network OEM Licensing Stack will be rolled-out in the following stages:

#### Stage 1: IoT Devices

* Target: Smart cameras, gateways, routers.
* Why: High shipment volumes (millions per year), low per-unit integration cost.
* Proof Point: Show that even low-end IoT devices can run Idle Node with <10 KB overhead.
* Example: A home security camera earns $1–2/month in Idle rewards.

**Stage 2: Drones**

* Target: Agriculture drones, inspection drones.
* Why: Drones have predictable downtime (charging docks).
* Proof Point: Drones can earn during idle time without draining flight battery.
* Example: Agriculture drone runs Idle compute jobs overnight → yields $10/month.

**Stage 3: Industrial Robotics**

* Target: Warehouse AGVs (Automated Guided Vehicles), cobots (collaborative robots).
* Why: Huge $1.4T downtime market (Siemens report).
* Proof Point: Robots idle \~20–40% of shift can generate yield while still mission-ready.
* Example: A warehouse AGV contributes spare CPU cycles when docked, earning $50/month.


# MetaVaults

### **What is a Meta Vault?**

A Meta Vault is Idle Network’s smart contract system that collects, converts, and reinvests rewards across multiple rewards networks and DeFi strategies.\
Think of it as your personal compounding bank for digital infrastructure rewards.\
When your machine earns tokens from different rewards networks (like GLM from Golem, HNT from Helium or RENDER from Render Network), those tokens are routed into the Meta Vault. The vault automatically swaps them into a base asset (like ETH or USDC), then reinvests them into high-yield, on-chain strategies, such as restaking or lending pools.\
The result? You earn more, automatically, without needing to manage anything.

Idle Network will have to categories of MetaVault:<br>

1. **Omni-Platform MetaVaults:** Initial MetaVaults targeting existing rewards networks that cater to PoC device categories
2. **Native MetaVaults:** New rewards networks to be launched by Idle Network to cater to currently uncatered to exotic asset categories

### **Reward Collection Process**

The reward flow into the Meta Vault works in a few clean steps:<br>

* **Earn:** Your desktop node contributes capacity to rewards networks and earns native rewards.
* **Bridge:** Idle’s Reward Bridge listens for incoming rewards on supported chains.
* **Claim & Route:** Rewards are automatically claimed from each protocol and routed into the Meta Vault.
* **Swap:** Native rewards tokens are swapped into ETH or another base asset.
* **Reinvest:** The base asset is deposited into selected yield strategies (e.g. stETH restaking, LP vaults).
* **Yield:** You receive a receipt token (like stIDLE or yvETH) that represents your position and grows in value over time.

This entire process is non-custodial, gas efficient, and optimized by Idle’s AI layer behind the scenes.

### **Cross Ecosystem Swap Mechanism**

Idle supports many rewards ecosystems, but each one pays in its own token. That makes rewards messy and fragmented for users.\
To fix this, the Meta Vault uses a Cross Ecosystem Swap Layer powered by KyberSwap, Uniswap (v2 or v4) and custom DEX routers.

**How it works:**

* Detects incoming rewards in tokens like GLM, HNT, RENDER, etc.
* Swaps them into ETH or USDC using optimal paths on Base chain.
* Routes the converted tokens into yield-bearing protocols.

All this happens within a single contract flow—no user input needed. You just see your vault balance growing in real time without managing dozens of small token holdings.

### **How Restaking Works**

Idle uses restaking to amplify yield once base assets are collected. This means:

* After rewards are swapped into ETH...
* ETH is deposited into protocols like EigenLayer or Liquid Restaking platforms (e.g. EtherFi, Kelp DAO).
* Users receive a restaked token (e.g. rstETH) that earns double rewards:
  * From ETH staking
  * From restaking incentives

This helps Idle users capture multiple layers of yield without any manual setup. Idle automates the entire flow, maximizing your return on idle infrastructure.

**Example:** You run a Render node and earn RENDER tokens → those are swapped into ETH → ETH is restaked via EigenLayer → You receive yield from both staking and restaking.

***

### **IdleFi Strategies (LP, Lending, Restaking)**

\
Beyond restaking, Idle’s Meta Vault supports a growing list of yield strategies:

| Strategy Type | Description                                                                 |
| ------------- | --------------------------------------------------------------------------- |
| Restaking     | ETH is restaked in protocols like EigenLayer for double yield               |
| Lending       | Base assets are deposited into lending markets (e.g. Aave, Compound)        |
| LP Farming    | ETH or USDC paired with IDLE in DEX pools to earn trading + farming rewards |
| Auto-Compound | All rewards auto-compounded into highest-performing strategy                |

Each vault is AI optimized based on network conditions, gas fees, and reward APRs.\
You can choose which strategy you prefer—or let Idle pick for you.

***

### **Gas Efficiency via Base**

Idle Network is deployed on Base, a fast and low-cost Ethereum Layer 2 chain developed by Coinbase.

**Here’s why Base matters:**

* Cheaper transactions: Vault operations cost a fraction of mainnet gas.
* Faster compounding: Idle can reinvest rewards more often, improving APY.
* High DeFi activity: Base has a growing DeFi ecosystem, perfect for swapping and lending.
* Secure bridging: Native Base-ETH bridges make reward routing seamless.

By running vaults on Base, Idle ensures your earnings aren’t eaten by gas fees, making micro-rewards from nodes still profitable even in low-volume settings.


# Rewards Bridge Layer

### 🌉 What is the Reward Bridge?&#x20;

The Reward Bridge is the part of Idle Network that connects off-chain infrastructure rewards with on-chain yield strategies.

It handles the automatic transfer of rewards from external platforms (like GLM, HNT, RENDER) and forthcoming native rewards networks into Idle’s MetaVaults on Base. You don’t need to manually bridge or swap anything. Idle does it all behind the scenes using adapters and secure bridge contracts.

Think of it as your invisible yield pipeline: from mining → to bridging → to vault → to compounding.

### 🌐 Supported Chains & Adapters

Each rewards network operates on its own chain or reward system. Idle supports these using custom adapters built for each protocol.

| Protocol | Reward Token | Chain or Layer    | Idle Adapter? |
| -------- | ------------ | ----------------- | ------------- |
| Golem    | GLM          | Ethereum          | ✅ Yes         |
| Helium   | HNT          | Solana            | Soon          |
| Grass    | GRASS        | Ethereum L1       | Soon          |
| Render   | RENDER       | Polygon           | Soon          |
| Flux     | FLUX         | Flux native chain | Soon          |

Each adapter:

* Monitors your node rewards
* Claims tokens when thresholds are met
* Sends them through the Reward Bridge to Base

As new rewards networks are added, Idle will plug in new adapters to expand reward coverage.

### 🚀 How Rewards Are Moved to Base

Once the rewards are claimed, they’re moved to Base using the following flow:

1. Collection: Idle’s adapter contract claims rewards from the protocol or your wallet.
2. Swap (Optional): In some cases, tokens are first swapped into a bridgeable token (e.g. ETH, USDC).
3. Bridge: The tokens are sent through secure bridges (like [KyberSwap](https://kyberswap.com/) and [Mayan Protocol](https://mayan.finance/))
4. Deposit to Meta-Vault: Once on Base, the tokens are routed into the Meta-Vault and reinvested.

Idle’s system keeps track of your rewards through the entire journey. You’ll see all movements reflected in your dashboard with no manual actions required.

### 🛡️ Bridge Security

Bridging is one of the most sensitive parts of any DeFi system. Idle’s Reward Bridge follows strict security standards:

* Audited Bridges: Idle only uses trusted bridge providers with battle-tested contracts and large TVLs.
* Rate Limits: Idle enforces per-user and per-token limits to prevent abuse or draining attacks.
* Dual-Signature Claims: In some protocols, rewards are only claimed after verifying your desktop node’s proof + wallet signature.
* Retry Queues: If a reward claim or transfer fails, the system queues it for retry, not loss.

Additionally, Idle separates the bridging logic from vault logic. That means any bug or attack in the bridge can’t directly drain funds from the Meta-Vaults.

### 🔁 Fallback Mechanisms

What if the bridge is down or a network is slow?

Idle uses fallback tools to make sure rewards still get through:

* Multiple Bridges: If one bridge is congested, Idle routes through an alternate.
* Delayed Processing: If rewards can’t be sent in real-time, they’re stored securely and batched later.
* Manual Reclaim: Advanced users can always trigger a manual claim via the Idle dashboard or desktop app.

No matter what happens your rewards won’t get stuck or lost. Idle is built to reliably move value from physical devices to yield strategies, with built-in recovery paths if anything goes wrong.


# Architecture Summary

As discussed in the above pages, Idle Network will adopt a staged roll-out with the initial PoC proving out the system architecture on readily available, low-hanging fruit idle assets such as compute, storage and bandwidth before integrating more exotic target categories such as MCUs, IOTs, robotics and drones once the network, incentive models, and reliability of on-chain execution have been validated. The goal is to incrementally establish the foundation for scaling into increasingly complex and high-value asset classes.\
\
The PoC is designed as a desktop-first, multi-layered system that turns idle digital resources into yield. The system combines secure local compute environments with intelligent AI, blockchain-based rewards, and user-friendly dashboards.\
\
The diagram below shows how each part of Idle Network connects from the desktop app that runs on the user’s device to the smart contracts on Base.

{% @mermaid/diagram content="flowchart LR
%% Main components
subgraph DesktopApp\["Desktop App"]
end

subgraph BackendAPI\["Backend API"]
end

subgraph Automation\["Automation"]
end

subgraph Reward Network\["e.g. Golem"]
end

subgraph Virtualization\["Virtualization (KVM)"]
end

subgraph RewardTrack\["Reward Tracking"]
end

DesktopApp <--> BackendAPI
BackendAPI <--> Automation

BackendAPI --> Virtualization
DesktopApp --> Depin
Automation --> RewardTrack

%% Data Flow
subgraph DataFlow\["Data Flow"]
step1\["1. User Registration → Wallet Generation"]
step2\["2. System Check → Node Deployment"]
step3\["3. Task Execution → Reward Collection"]
step4\["4. Future: Vault Integration → Yield Generation"]
step1 --> step2 --> step3 --> step4
end

%% Security Layers
subgraph Security\["Security Layers"]
sec1\["Local Encryption"]
sec2\["HTTPS/TLS"]
sec3\["Non-custodial"]
sec4\["Privacy-first"]
sec1 --> sec2 --> sec3 --> sec4
end
" %}

Let’s walk through the key parts of the architecture:

* Desktop App - Cross-platform user interface (Windows, Mac, Linux)
* Backend API - User profiles, node orchestration, reward tracking
* Automation Layer - Golem deployment, KVM setup, monitoring (Linux only for now)
* Reward Network (Golem) - Currently the only supported network (Linux only for now)
* Reward Tracking - GLM earnings track (bridging planned)&#x20;
* Platform Support:
  * Desktop App: Windows, macOS, Linux
  * Golem Nodes: Linux only (requires KVM virtualization)
  * Automation API: Cross-platform (but only deploys to Linux for now)
* Data Flow:
  * User signs up → Profile created → Curated wallet generated
  * System check → Node deployed → Connection established
  * Node runs tasks → Rewards earned → Automatic tracking
  * Future: Rewards bridged → Vault deposited → Yield generated<br>

The process is simple:

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

1. Download the Idle Network desktop app
2. Launch and check if you have an existing profile
3. Sign up with your name and email (if new)
4. Wait for the system check

Your device gets a unique profile tied to its IP address. This keeps things secure while letting you use multiple devices (though they won't sync together).


# System Requirements

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

Before we can start earning, we check your device: What We Need&#x20;

Golem Node Requirements (Linux Only):

1. OS: Linux (Ubuntu 18.04+ works best) - Currently the only supported network
2. CPU: 2+ cores with virtualization support (VMX/SVM)
3. RAM: 4GB minimum, 8GB recommended
4. Storage: 20GB free space
5. Internet: Stable connection
6. Virtualization: KVM support (automatically installed) What Golem Uses:
   1. CPU: 1-4 cores (we adjust based on your system)
   2. RAM: 2-8GB (flexible based on what you have)
   3. Storage: 10-50GB for tasks
   4. Network: Stable internet for work distribution

If your system doesn't meet requirements, we'll tell you exactly what needs upgrading and why the node can't start.

Note: For the PoC, we only support Golem Network on Linux systems. The desktop app works on all platforms, but the nodes only run on Linux.


# First Run

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

Once everything checks out:

1. Wallet created - we generate a secure wallet for you
2. Node deployed - Golem provider starts running
3. Connection established - your device connects to the network
4. Dashboard ready - start monitoring your earnings Everything happens automatically. No technical setup needed.


# Brief Orientation on Navigation

###

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

Main Sections:

1. Dashboard - Real-time monitoring and controls
2. Rewards - Earnings tracking and history
3. Node - Deployment and management
4. $IDLE Token - Coming soon (vault integration)
5. Activity Log - Transaction and event tracking


# Settings - Profile and wallet management

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

Main Sections:

1. Dashboard - Real-time monitoring and controls
2. Rewards - Earnings tracking and history
3. Node - Deployment and management
4. $IDLE Token - Coming soon (vault integration)
5. Activity Log - Transaction and event tracking
6. Settings - Profile and wallet management Key Features:
   1. Connection Status - Animated rings show real-time status
   2. Curated Wallet - Automatically generated, no manual management
   3. One-Click Controls - Start/stop nodes with single clicks
   4. Real-Time Updates - All metrics update automatically


# Visual User Flow

Complete User Journey Flowchart

{% @mermaid/diagram content="flowchart TD
Start\[Start: Download App]
Launch\[Launch: Check Device]
ProfileCheck{Profile Check}
SignUp\[Sign Up: Name + Email]
SysCheck\[System Check]
ReqMet{Requirements Met?}
Upgrade\[Upgrade Guidance]
Deploy\[Deploy Node]
Wallet\[Wallet Created]
Connect\[Connect Golem]
StartE\[Start Earning]
Dashboard\[Dashboard Monitoring]
Track\[Track Earnings]
Future\[Future Features]

Start --> Launch --> ProfileCheck
ProfileCheck -->|Existing User| SysCheck
ProfileCheck -->|New User| SignUp --> SysCheck
SysCheck --> ReqMet
ReqMet -->|Yes| Deploy
ReqMet -->|No| Upgrade --> Deploy
Deploy --> Wallet --> Connect --> StartE --> Dashboard --> Track --> Future
" %}

Key Decision Points:

1. Profile Check - Existing user goes straight to dashboard
2. System Check - Requirements not met shows upgrade guidance
3. Node Deployment - Automatic setup with progress indicators
4. Connection Status - Real-time feedback on network connectivity Error Handling:
5. Hardware Issues - Clear guidance on system upgrades
6. Network Problems - Automatic retry with status updates
7. Node Failures - Automatic recovery and restart
8. Wallet Issues - Secure backup and recovery systems


# Architecture & Tech Stack

This is the PoC tech stack and will be expanded later on

Frontend Layer:

1. Electron Desktop App - Cross-platform desktop application
2. React/TypeScript - Modern UI with real-time updates
3. Zustand - Local state management
4. Tailwind CSS - Styling and responsive design

Backend Layer:

1. NestJS - RESTful API framework
2. SQLite - Local database for user profiles
3. TypeORM - Database management and migrations
4. Swagger - API documentation and testing Automation Layer:
   1. Golem Integration - Automated provider deployment
   2. KVM Virtualization - Resource isolation and management
   3. Cross-Platform Support - Linux, macOS, Windows compatibility
   4. Real-Time Monitoring - Performance tracking and logging Blockchain Layer:
      1. Base Network - Coinbase's L2 for smart contracts
      2. Meta-Vault Contracts - Yield aggregation and management
      3. Ethereum Bridge - Cross-chain reward bridging
      4. Non-Custodial Design - User maintains full control


# Data Flow Architecture

User Registration Flow:

1. Client → Electron app launches
2. Backend → NestJS API receives registration
3. Database → SQLite stores user profile
4. Wallet → Curated wallet generated locally
5. Automation → Golem provider deployed
6. Monitoring → Real-time status tracking Reward Collection Flow:
7. Node → Golem provider runs compute tasks
8. Network → GLM tokens earned on EVM
9. Tracking → Backend monitors earnings
10. Future → Automatic bridging to Base
11. Vault → Smart contracts manage yield


# Security Architecture

1. Encrypted Storage - Wallet data encrypted with device keys
2. Local Processing - Sensitive operations on user device
3. Non-Custodial - Users maintain full control
4. Device-Specific - Profiles tied to specific devices Network Security:
   1. HTTPS/TLS - All communications encrypted
   2. API Authentication - Secure endpoint access
   3. Input Validation - Comprehensive data validation
   4. Error Handling - Secure error responses Privacy Protection:
      1. Minimal Data Collection - Only necessary information
      2. Local Analytics - Performance data stays on device
      3. Anonymous Participation - rewards network participation without identification
      4. GDPR Compliance - European data protection standards


# User Requirements & Journeys

## **Set Up For Local Development**

### **Prerequisites**

System Requirements:

OS: Linux (Ubuntu 18.04+), macOS 10.15+, or Windows 10+ Node.js: Version 18+ with npm

Python: Version 3.8+ for automation scripts Git: Latest version for version control Hardware Requirements:

1. CPU: 4+ cores recommended for development
2. RAM: 8GB+ for running multiple services
3. Storage: 50GB+ free space for dependencies
4. Network: Stable internet connection Development Tools:
   1. VS Code - Recommended IDE with extensions
   2. Postman - API testing and documentation
   3. SQLite Browser - Database management
   4. Chrome DevTools - Frontend debugging

### Installation Steps

1. Clone Repository:

git clone <https://github.com/your-org/idle-finance-v2.git> cd idle-finance-v2

1. Install Dependencies: # Frontend dependencies

cd frontend npm install

\# Backend dependencies cd ../backend

npm install

\# Automation dependencies cd ../automation/golem

pip install -r requirements.txt

1. Environment Setup:

\# Backend environment cd backend

cp .env.example .env

\# Edit .env with your configuration

\# Frontend environment cd ../frontend

cp .env.example .env

\# Edit .env with your configuration

1. Database Setup: cd backend

npm run migration:run npm run seed

### Running Locally

1. Start Backend:

```
// cd backend
```

```
// npm run start:dev
```

\# API available at [http://localhost:3000](http://localhost:3000/)

\# Swagger docs at <http://localhost:3000/api/v1/docs>

1. Start Frontend:

```
cd frontend npm run dev
```

\# App available at [http://localhost:5173](http://localhost:5173/)

1. Start Automation (Optional): cd automation/golem

python -m uvicorn main:app --reload Automation API at [http://localhost:8000](http://localhost:8000/)

1. Build Desktop App: cd frontend

```
npm run build
```

```
npm run electron:dev
```

## How It Works

### The Curated Wallet System

The Idle Network Curated Wallet System allows users to:

1. Generate a secure wallet during signup
2. Encrypt and store keys locally
3. Automatically collect rewards
4. Track everything transparently
5. Keep you in full control
6. Security:
   1. Everything encrypted locally
   2. Device-specific access
   3. Non-transferable profiles
   4. Automatic backups

### Behind the Scenes

Your Desktop App:

1. Cross-platform (Windows, Mac, Linux)
2. Real-time monitoring
3. Local sensitive state management
4. Cloud non-sensitive state management
5. Automatic updates Our Backend:
   1. Manages your profile and wallet
   2. Orchestrates node deployment
   3. Tracks rewards and performance
   4. Handles all the complex Golem Integration:
      1. Automatically deploys provider nodes
      2. Monitors performance in real-time
      3. Optimizes resource usage
      4. Handles all the technical details Local Reward Tracking:
         1. Tracks GLM earnings locally
         2. Real-time performance monitoring
         3. Secure local storage
         4. Future: Will bridge to other networks

### Earning Process

How You Earn:

1. Node runs - Golem provider does compute tasks
2. Rewards earned - GLM tokens on Ethereum network
3. Automatic tracking - we monitor everything locally
4. Real-time updates - see earnings as they happen
5. Future features - bridging and vaults coming soon

## Using Idle Network

### Dashboard

Your main control center shows:

1. Connection status - animated rings show if you're connected
2. Earnings - live GLM token tracking
3. System health - CPU, memory, disk usage
4. Node controls - start/stop your node
5. Performance - uptime and efficiency stats

Everything updates in real-time. No manual refresh needed.

### Rewards

1. Live updates - see GLM tokens as they come in
2. History - earnings over time
3. Collection - rewards automatically tracked
4. Transparency - know exactly what you're earning

### Node Management

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

1. Start/Stop - one-click control
2. Status - see if it's running
3. Resources - CPU, memory, disk usage
4. Performance - uptime and efficiency
5. Settings - we optimize automatically

### Activity Log

See everything that happens:

1. Node events - starts, stops, status changes
2. Rewards - when you earn GLM tokens
3. System alerts - performance issues
4. Performance - uptime and resource usage

### Settings

Manage your account:

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

1. Profile - name, email, device info
2. Wallet - view your curated wallet (show/hide address)
3. Preferences - notifications, optimizations

Security - two-factor auth, account protection

See everything that happens:

1. Node events - starts, stops, status changes
2. Rewards - when you earn GLM tokens
3. System alerts - performance issues
4. Performance - uptime and resource usage


# Tokenomics

The $IDLE token is payments and rewards medium for the Idle Network ecosystem, offering a universal currency for the emerging on-chain AI and robotics industry.

$IDLE is built to anchor three pillars: fee distribution, compounding incentives, value creation and governance as follows:

### 1. Fee Capture & Distribution

Idle Network is designed with real protocol revenue at its core. Every interaction generates fees, and those fees route back to $IDLE holders. For example:

* **Edge Compute Vaults**: When IoT devices or MCUs (microcontrollers) route idle compute into MetaVaults, a small percentage of harvested rewards flows into the protocol treasury. That treasury accumulates in ETH/USDC, and is used to buy and burn $IDLE, creating direct deflationary pressure.
* **Robotics/Drones Marketplace**: Whenever OEM-licensed robots or drones are rented out via our lightweight node marketplace, Idle Network takes a cut of transaction fees. A share of this is auto-converted into $IDLE buybacks or staker rewards.
* **MetaVault Yield**: When yield is auto-compounded across networks (Helium, Render, Akash, Filecoin), Idle Network charges a small aggregator fee. These fees are routed through the same buyback-and-burn pipeline.

This means $IDLE is backed by real cashflows with ETH and stablecoins flowing through the system and every cycle reduces circulating supply.

### 2. Incentives & Access

The $IDLE token is also the ticket into premium yield and ecosystem access.

* **Boosted Yields**: Staking $IDLE unlocks higher reward multipliers in MetaVaults, giving stakers a compounding edge.
* **Access Rights**: Certain enterprise pilots (e.g., OEM robotics integrations) will be gated by $IDLE staking thresholds, ensuring committed token holders get first-mover advantage.
* **Security Layer**: Lightweight nodes running on MCUs, IoTs, or drones will require a bonded amount of $IDLE to register. This creates a bonding-and-slashing system for node integrity, while locking up more supply.
* **KOL/Kinetic Incentives**: $IDLE is the currency through which marketing partners, KOLs, and institutional integrations are rewarded. They must stake to align with the long-term system.

***

### 3. Scarcity & Value Creation

Most importantly, $IDLE is deliberately scarce:

* **Fixed Supply**: No continuous emissions. Distribution is capped.
* **Protocol Buybacks**: All system fees (ETH, USDC, partner tokens) flow into treasury → converted into $IDLE → burned or redistributed.
* **Deflationary Mechanics**: As MetaVault adoption scales, token velocity decreases (more staking, more bonding), while buybacks steadily shrink supply.

This combination means every new device, every rented drone, every IoT vault transaction — shrinks $IDLE’s supply while increasing its utility.

### &#x20;4. Governance & Network Direction

Every vault, marketplace, and integration in Idle Network is governed by $IDLE. Token holders determine:

* MetaVault parameters (e.g., fee ratios, allocation across reward networks, compounding logic).
* Onboarding of new networks (e.g., whether to support a new DePIN partner like Render or Helium).
* Robotics and IoT pilots (which OEMs, drones, or compute pools get licensed first).
* Treasury and partnerships (allocations for KOL incentives, OEM collaborations, R\&D).

This means $IDLE holders directly steer how billions in idle device capacity get monetized. Governance isn’t just “cosmetic”. It shapes the yield pathways and integrations, giving the token functional voting power over revenue streams.<br>

### **Total Supply & Allocation**

{% hint style="info" %}
**The maximum supply of IDLE will be 100,000,000 tokens.**
{% endhint %}

Here’s the proposed allocation:

<table><thead><tr><th width="233.1796875">Category</th><th width="82.61328125">%</th><th>Purpose</th><th data-hidden>Tokens</th></tr></thead><tbody><tr><td><strong>LP (Liquidity Pool)</strong></td><td>70%</td><td>Guarantees deep liquidity from day one, enabling seamless trading, minimal slippage, and strong price stability across major DEXs.</td><td>200,000,000</td></tr><tr><td><strong>Ecosystem Development</strong></td><td>8%</td><td>Powers the continuous evolution of Idle Network, funding cutting-edge product features, new protocol integrations, security upgrades, and developer incentives to keep us ahead of the market.</td><td>47,500,000</td></tr><tr><td><strong>Team</strong></td><td>4%</td><td>Rewards the builders driving Idle Network forward, with a structured vesting schedule that locks the team into the project’s long-term success, ensuring their incentives align with the community.</td><td>50,000,000</td></tr><tr><td><strong>Partnerships</strong></td><td>4%</td><td>Fuels collaborations with top DeFi, AI, and rewards networks to expand reach, unlock new revenue streams, and create cross-ecosystem opportunities for token holders.</td><td>27,500,000</td></tr><tr><td><strong>CEX Listings</strong></td><td>4%</td><td>Dedicated to securing prime centralized exchange listings, boosting token visibility, accessibility, and trading volume, essential for mainstream adoption.</td><td>25,000,000</td></tr><tr><td><strong>ICO</strong></td><td>10%</td><td>Reserved for visionary early backers, providing them with strategic entry into the project. Funds from the ICO accelerate development, global marketing, and ecosystem growth ahead of public launch.</td><td>150,000,000</td></tr></tbody></table>

#### &#x20;Utility Layers of the IDLE Token

The IDLE token works across all layers of the Idle Network protocol.

**1. Intelligence Layer – IAUVI Scoring & AI Optimizer**

* Stake IDLE to boost your IAUVI Score (Idle Asset Utility Value Index)
* Higher IAUVI = better protocol assignments = more yield
* IDLE holders can vote on optimizer upgrades & parameters
* Advanced AI strategies may be token-gated

**2. DeFi Layer – Meta-Vaults & Reward Bridge**

* Consolidates rewards (e.g. GLM, HNT, GRASS, RENDER)
* Auto-swaps rewards into ETH or staked assets (e.g. stETH)
* A portion of yield is converted to IDLE via buybacks
* Stake IDLE for 2.5× reward boosts and fee discounts

**3. Governance & Access Layer**

* 1 IDLE = 1 vote in Idle DAO
* Token-gated features: early access, higher limits, beta testing
* Fee tiers and permissions based on IDLE staking amount

**4. Desktop App Incentives**

* Run Idle Desktop → earn rewards + bonus IDLE
* Loyalty tiers powered by your staked or held IDLE
* Plug-and-play UX for non-crypto users, with IDLE as the core reward token

#### How IDLE Captures Value

* Buybacks from Protocol Revenue:\
  Idle takes a small fee from yield strategies and omniplatform rewards, swaps it to IDLE, and either burns it or redistributes it to stakers.
* Restaking Flow:\
  Omniplatform rewards → ETH/stETH → converted partially into IDLE → used for DAO treasury and user incentives.
* Token-Gated Access:\
  Some features (like institutional vaults or AI tiers) require holding or staking IDLE, increasing long-term demand.
* Boosted Yield Tiers:\
  The more IDLE you stake, the higher your yield multiplier — up to 2.5×.

#### LP Strategy

To ensure smooth trading and sufficient depth on day one:

* 70% of total supply reserved for liquidity
* Primary listing on Uniswap v4 (Base)
* LPs are rewarded in IDLE tokens via gauge voting and staking bonuses
* Early LPs can receive boosts and governance rights
* Auto-liquidity tools will periodically rebalance or expand LPs using treasury assets

We will monitor liquidity dynamics closely and adjust incentives accordingly.

#### Buybacks & Restaking

Idle Network uses multiple value return mechanisms:

* Buybacks: Fees from Meta-Vaults or omniplatform rewards are converted to IDLE on the open market
* Restaking: Omniplatform rewards are auto-restaked into ETH/stETH and partially redirected to IDLE
* Vault Dividends: Future vault models may send native yield (ETH, stETH) directly to stkIDLE holders
* DAO Flexibility: Governance can vote to burn bought-back tokens, send to treasury, or use them for grants/incentives

Together, these mechanisms ensure IDLE captures protocol growth.

### Good Faith Participant Measures

To ensure a stable and secure market during the initial launch phase, **Good Faith Participant Measures (GFPMs)** will be in place for the first **60 minutes**. These measures are designed to prevent any potential disruptive price action and establish a fair foundation for the $IDLE token.

* **First 60 Seconds**: During this brief initial window, the conditions will not be ideal for purchasing. The primary focus will be on securing the launch and preventing interference from large-volume transactions. This period is not intended for buying activity, but rather to ensure a smooth transition into the next phase of the launch. We **highly** recommend waiting for the subsequent period for a more favorable environment to engage.
* **Following 59 Minutes**: As the GFPMs gradually begin to phase out (lowered from the initial 60 seconds - then decreased further over the next 59 minutes), market activity will become more balanced. During this time, the contract address for $IDLE will be officially posted through our X platform. Only after this point should participants proceed with purchasing, as the address will be fully verified and accessible.

**Important Reminder**: Do not attempt to acquire any $IDLE tokens before the official contract address is shared. Any transactions made prior to the announcement will be considered unauthorized, as the contract address will only be verified and confirmed through our official communication channels.

These GFPMs are implemented to maintain the fairness and integrity of the launch, ensuring that all participants can engage in a secure and stable environment once the system is fully operational.

### Vault Integration (Coming Soon)

We're building vaults that will:

1. Accept rewards from multiple rewards networks
2. Automatically optimize yields
3. Enable liquid staking
4. Provide compound growth

### More Networks (Coming Soon)

We're adding support for:

Grass Network - AI training data collection

* Earn Grass tokens for bandwidth
* Needs stable internet
* $20-100/month potential

Helium Network - Wireless infrastructure

* Earn HNT tokens for coverage
* Needs LoRaWAN gateway
* $100-500/month potential Render Network - GPU computing
* Earn RNDR tokens for GPU power
* Needs high-performance GPU
* $200-1000/month potential Flux Network - Cloud computing
* Earn FLUX tokens for compute
* Needs CPU and storage
* $100-400/month potential

### AI Optimization

IAUVI Engine (Idle Assets Utility Value Index):

* AI-powered resource assessment
* Machine learning for maximum earnings
* Intelligent network selection
* Predictive performance analytics

### Traditional Wallets

Future plans include:

1. Import existing Web3 wallets
2. Support both curated and traditional wallets
3. Convert rewards to traditional tokens
4. Mobile wallet integration

### Enterprise Features

For businesses:

1. Multi-device management
2. Advanced analytics and reporting
3. API access for custom integrations
4. Compliance and regulatory tools

### Security & Privacy

### How We Keep You Safe

Local Processing - All sensitive operations happen on your device Encrypted Storage - Wallet data encrypted with device-specific keys Non-Custodial - You maintain full control of your infrastructure Device-Specific - Profiles tied to specific devices

### Privacy First

Minimal Data - We only collect what's necessary Local Analytics - Performance data stays on your device Anonymous Participation - omniplatform participation without personal identification Encrypted Everything - All data encrypted in transit and at rest

### Compliance

* GDPR Ready
* European data protection standards SOC 2 Ready
* Security and availability controls Regular Audits
* Third-party security assessments Transparent
* Clear privacy policies and practices


# Roadmap

Idle Network will adopt a staged roll-out process, proving out the system architecture on existing rewards networks via easily accessible device categories before launching Native MetaVaults and that apply the analogous architecture to monetize increasingly exotic idle asset categories.\
\
The roadmap will develop as follows:\
\
**Q3 2025: Roll-Out of PoC & OmniPlatform MetaVaults V1**

* **Asset Focus:** Idle compute, storage and bandwidth
* **Rewards Focus:** OmniPlatform MetaVaults harnessing rewards from existing ecosystems.
* **Extra Features:** Rewards Bridge Layer rolled out

**Q4 2025: Roll-Out of Idle Robotics & Drones Marketplace**

* **Asset Focus:** Idle robotics devices and drones
* **Rewards Focus:** Native MetaVaults generating rewards for currently uncatered to asset categories
* **Extra Features:** Edge Compute Vaults & OEM Pilots

**Q1 2026: Roll-Out of Idle MCU & IOT Marketplace**

* **Asset Focus:** Idle MCUs and IOT devices
* **Rewards Focus:** Existing rewards to be boosted by new customer streams via Customer Discovery Portal on native Idle Network Robotics & Drones Marketplace&#x20;
* **Extra Features: Native** Customer Discovery Portal connecting idle asset owners to users in demand of idle assets

**Q2 2026: OEM Licensing Stack**

* **Asset Focus:** OEM licensing deals
* **Rewards Focus:** Multi-model OEM license monetization model
* **Extra Features:** Additional high-demand asset categories added to marketplace