NodeFlow Documentation

Complete guide to the NodeFlow Protocol — autonomous agent infrastructure that connects idle AI agents, compute, and wallets into a self-sustaining decentralized network.

Key Principles

• Autonomous — Agents and compute tasks run 24/7 without manual intervention
• Non-Custodial — Your funds never leave your wallet; agents operate with scoped permissions
• Deflationary — 10% of all protocol revenue is used to buy back and burn $NFLOW
• Permissionless — Anyone can participate as a node operator, agent creator, or yield earner
• Composable — Build on top of NodeFlow with our open SDK and API

Quick Start

Get up and running with NodeFlow in under 5 minutes.

Step 1 — Connect Your Wallet

NodeFlow supports MetaMask, WalletConnect, Phantom, and Coinbase Wallet. Click "Launch App" on the homepage and select your preferred wallet provider.

Step 2 — Choose Your Role

Step 3 — Activate

Once connected, the NodeFlow protocol automatically assigns optimal tasks to your resources. Monitor your earnings in real-time through the dashboard.

# Install the NodeFlow CLI
npm install -g @nodeflow/cli

# Authenticate with your wallet
nodeflow auth connect

# Start contributing compute
nodeflow node start --gpu auto

# Check your earnings
nodeflow rewards balanceTerminal

Architecture Overview

NodeFlow is composed of four interconnected layers that work together to create a self-sustaining agent economy.

Agent Layer

Manages the lifecycle of AI agents — deployment, task routing, execution monitoring, and reward distribution. Agents are sandboxed and operate with scoped session keys.

Compute Layer

The decentralized compute mesh that powers agent workloads. Node operators contribute idle CPU/GPU resources and are compensated per task. Workloads are routed to the nearest low-latency node via the NodeFlow Scheduler.

Yield Layer

Automated DeFi yield optimization engine. Continuously monitors lending rates, liquidity pools, and vault strategies across 20+ protocols to maximize risk-adjusted returns.

Settlement Layer

All transactions, rewards, and token burns settle on L2 infrastructure for sub-second finality and negligible gas costs. The protocol currently operates on Base and Arbitrum.

Agent Orchestration

NodeFlow's agent system allows you to deploy, manage, and monetize autonomous AI agents that execute tasks across DeFi, data processing, and compute markets.

Agent Types

Agent Lifecycle

// Create a DeFi yield agent
import { NodeFlow, Agent } from '@nodeflow/sdk';

const nf = new NodeFlow({ wallet: myWallet });

const agent = await nf.createAgent({
  name: 'yield-optimizer-v1',
  type: 'defi',
  strategy: 'best-yield',
  config: {
    protocols: ['aave', 'compound', 'morpho'],
    assets: ['USDC', 'ETH', 'DAI'],
    maxSlippage: 0.5,       // 0.5%
    rebalanceInterval: 3600, // 1 hour
    riskTier: 'moderate',
  },
});

// Deploy to the network
await agent.deploy();
console.log('Agent running:', agent.id);JavaScript

Compute Mining

Turn your idle CPU and GPU resources into passive income. NodeFlow's compute mesh allocates AI workloads to your machine and pays you in $NFLOW for each task completed.

System Requirements

Setup

# Install node software
curl -sSL https://get.nodeflow.io | bash

# Configure your node
nodeflow node init --wallet 0xYourWalletAddress

# Auto-detect hardware & start
nodeflow node start --auto

# Check status
nodeflow node statusTerminal

Reward Calculation

Compute rewards are calculated based on three factors:

• Task Complexity — measured in Compute Units (CU). More complex tasks earn more.
• Uptime Score — nodes with 99%+ uptime receive a 1.5x multiplier.
• Stake Boost — staking $NFLOW increases your reward multiplier up to 3x.

Reward = BaseCU × TaskComplexity × UptimeMultiplier × StakeBoost

Example:
BaseCU           = 1.0 NFLOW
TaskComplexity   = 2.5  (GPU inference task)
UptimeMultiplier = 1.5  (99.5% uptime)
StakeBoost       = 2.0  (10,000 NFLOW staked)

Reward = 1.0 × 2.5 × 1.5 × 2.0 = 7.5 NFLOW per taskFormula

Wallet Yield Engine

The Yield Engine is NodeFlow's automated DeFi optimizer. Connect your wallet and let agents continuously seek the best risk-adjusted returns across multiple protocols.

Available Strategies

Risk Tiers

• 🟢 Conservative — Only audited, blue-chip protocols (Aave, Compound, Lido). Max drawdown <2%.
• 🟡 Moderate — Includes DEX LP positions and newer vetted protocols. Max drawdown <10%.
• 🔴 Aggressive — Leveraged strategies and emerging protocols. Higher return potential, higher risk.

// Configure yield engine via SDK
const vault = await nf.yield.configure({
  assets: ['USDC', 'ETH'],
  strategy: 'blue-chip',
  riskTier: 'conservative',
  autoCompound: true,
  rebalanceThreshold: 0.02, // 2% drift triggers rebalance
});

// Monitor performance
const stats = await vault.getPerformance();
console.log('Current APY:', stats.apy);
console.log('Total earned:', stats.totalEarned);JavaScript

$NFLOW Token

$NFLOW is the native utility and governance token of the NodeFlow protocol. It powers the entire ecosystem — from staking and rewards to governance and fee settlement.

Token Distribution

Staking

Stake $NFLOW to boost your rewards and participate in governance. Staking tiers provide increasing multipliers:

// Stake NFLOW tokens
const stake = await nf.staking.stake({
  amount: 10000,
  lockPeriod: 180, // days — longer lock = higher boost
});

console.log('Tier:', stake.tier);          // "Gold"
console.log('Boost:', stake.rewardBoost);  // 2.0
console.log('Unlock:', stake.unlockDate);  // 2026-11-17JavaScript

Burn Mechanism

NodeFlow implements a continuous buy-back-and-burn mechanism:

• 10% of all protocol revenue is allocated to the burn contract
• The contract autonomously buys $NFLOW from the open market weekly
• Purchased tokens are sent to a verified burn address (0x000...dead)
• All burns are verifiable on-chain and tracked in the dashboard

Governance

$NFLOW holders govern the protocol through on-chain proposals (NFIPs — NodeFlow Improvement Proposals):

• Propose — Requires minimum 10,000 $NFLOW staked to submit a proposal
• Vote — Any staker can vote. Weight based on staking tier.
• Execute — Proposals with >66% approval and minimum quorum are executed after a 48-hour timelock

Governance scope includes: protocol fee adjustments, new agent marketplace listings, treasury allocations, new chain deployments, and parameter changes.

Security

Security is foundational to NodeFlow. The protocol is designed with a zero-trust architecture and multiple layers of protection.

Non-Custodial Design

NodeFlow never holds user funds. All assets remain in your wallet at all times. Agents interact with DeFi protocols using session keys — temporary, scoped permissions that:

• Expire after a configurable time window (default: 24 hours)
• Are restricted to specific contract interactions
• Cannot transfer assets to external addresses
• Can be revoked instantly by the wallet owner

Audit Status

Bug Bounty

NodeFlow maintains an active bug bounty program. Critical vulnerabilities are eligible for rewards up to $100,000.

API Reference

NodeFlow provides a comprehensive REST API and TypeScript SDK for programmatic access to all protocol features.

SDK Installation

# npm
npm install @nodeflow/sdk

# yarn
yarn add @nodeflow/sdk

# pnpm
pnpm add @nodeflow/sdkTerminal

// Initialize the SDK
import { NodeFlow } from '@nodeflow/sdk';
import { ethers } from 'ethers';

const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();

const nf = new NodeFlow({
  signer,
  network: 'base',      // 'base' | 'arbitrum'
  apiKey: 'nf_live_...', // optional, for higher rate limits
});JavaScript

REST API Endpoints

Base URL: https://api.nodeflow.io/v1

// Example: List agents via REST
const response = await fetch('https://api.nodeflow.io/v1/agents', {
  headers: {
    'Authorization': 'Bearer nf_live_...',
    'Content-Type': 'application/json',
  },
});

const { agents } = await response.json();
// [{ id, name, type, status, earnings, uptime }]JavaScript

Webhooks

Configure webhooks to receive real-time notifications for events:

• agent.started — Agent successfully deployed
• agent.stopped — Agent stopped (manual or error)
• reward.earned — New reward distributed
• yield.rebalanced — Yield strategy rebalanced
• burn.executed — Token burn completed

// Webhook payload example
{
  "event": "reward.earned",
  "timestamp": "2026-05-20T14:30:00Z",
  "data": {
    "nodeId": "node_7x8k2...",
    "amount": "7.5",
    "token": "NFLOW",
    "taskId": "task_9m3p1...",
    "txHash": "0xabc123..."
  }
}JSON

Smart Contracts

NodeFlow's core contracts are deployed on Base and Arbitrum. All contracts are verified and open-source.

Network Stats

Real-time network metrics are available via the API or dashboard.

Roadmap

FAQ

Is NodeFlow free to use?

Yes. NodeFlow is free to join as a node operator, agent deployer, or yield earner. The protocol takes a small performance fee (typically 5–10% of earnings) which partially funds the $NFLOW token burn.

Do I need crypto experience?

Basic wallet knowledge is required (MetaMask, etc.). The dashboard and CLI are designed to be approachable. No coding is needed for basic usage — the SDK and API are available for advanced users.

How are rewards paid?

All rewards are paid in $NFLOW tokens directly to your connected wallet. For yield strategies, you also earn the underlying DeFi yields in their native tokens (e.g., USDC, ETH).

Is my wallet safe?

NodeFlow is fully non-custodial. Your private keys never leave your device. Agents operate through session keys with scoped permissions that you control and can revoke at any time.

What chains are supported?

Currently Base and Arbitrum. Solana support is planned for Q3 2026. Additional L2s will be added based on governance votes.

Can I build my own agents?

Absolutely. The NodeFlow SDK provides a full framework for creating custom agents. Agent creators earn $NFLOW whenever their agents are deployed and used by the network. See the Agent Orchestration section for details.

What happens if my node goes offline?

Tasks are automatically rerouted to other nodes. Your uptime score will decrease, which reduces your reward multiplier. There are no penalties — you simply earn less. Consistent uptime above 99% earns a 1.5x bonus.

How does the burn mechanism work?

10% of all protocol revenue is used to buy $NFLOW from the open market and send it to a verified burn address. This happens automatically every week. Burns are transparent and verifiable on-chain. See Burn Mechanism for details.