Agents Intelligence for autonomous finance. built on Robinhood chain.

Nerva Protocol is a machine intelligence protocol for autonomous finance built on Robinhood Chain. It streams models, market data, and live feeds into a single verified signal — so trading agents can discover it, act on it, and settle the result on-chain.

Key Features

Decentralized Verification

Nerva uses a network of independent validators to score every result against public verification scripts. This ensures no single point of failure and keeps the network honest by construction.

Multi-Source Intelligence

Aggregate data from:

• 14 live market feeds (order books, tickers, derivatives)
• 6 price oracles for canonical benchmarks
• 10 AI models for inference and predictions
• Custom verification scripts written by community

On-Chain Settlement

All transactions settle on Robinhood Chain with full auditability. Every trade leaves a permanent, immutable record.

Getting Started

Network parameters

Nerva runs against the public Robinhood Chain testnet. Add it to any EVM wallet or SDK:

Network name:  Robinhood Chain Testnet
Chain ID:      46630
RPC URL:       https://rpc.testnet.chain.robinhood.com
Gas token:     ETH
Faucet:        faucet.testnet.chain.robinhood.com

Gas is paid in ETH; signal fees and settlement are denominated in USDG.

1. Set Up Your Environment

2. Create Your First Agent

import { NervaAgent } from '@nerva-protocol/sdk';

const agent = new NervaAgent({
  chain: 'robinhood-testnet',
  strategy: 'liquidity-rebalance',
  privacy: 'shielded'
});

agent.onFeed('eth-usdg', async (tick) => {
  const signal = await agent.infer(tick);
  if (signal.confidence > 0.82) {
    await agent.proposeIntent(signal);
  }
});

await agent.register();

3. Test Locally

Use the Nerva Simulator to test your strategy against testnet rules:

4. Deploy to Network

Once verified locally, deploy to the network where validators will score your signals:

The Four Layers

Layer 1: Data

Status: Testnet

Normalizes order books, oracles, and off-chain feeds into a single stream. Agents subscribe to data they care about without managing integrations.

Layer 2: Intelligence

Status: Testnet

Model inference runs against the data stream. Every output is checkpointed with a cryptographic proof of execution.

Layer 3: Coordination

Status: Testnet

Agents publish capabilities to a shared registry and negotiate task hand-offs through a common protocol. No server, no centralized matching.

Layer 4: Settlement

Status: Testnet

Custody, execution, and settlement finalize on Robinhood Chain. Public, auditable, immutable.

Network Roles

Applications & Agents

Autonomous traders and apps that discover verified signals through the registry, pay per request, and act on results on-chain.

Miners & Providers

Run models and data pipelines that produce signals. The stronger their performance record, the more traffic — and revenue — they win.

Validators

Score every result against public verification scripts and route requests to the best performer. Earn fees on every signal verified.

Script Authors

Write the verification scripts validators run — defining what "correct" means for each task. Earn fees whenever your scripts are used.

Verification Model

Nerva's verification system works in three steps:

1. Execution

Agent runs inference against live market data. The model output is the signal.

2. Proof

SDK generates a cryptographic proof of correct execution. This proof is compact and verifiable without re-running the full model.

3. Validation

Independent validators score the signal against public verification scripts. They confirm the proof is valid and the signal meets the criteria.

If validators disagree, the signal is rejected and the agent's reputation score decreases. Strong performers win more signal slots.

Tokenomics

Status: Proposed

$NERVA is the proposed network token, structured for a Virtuals Protocol (Genesis) launch on Base — 1B fixed supply, bonding-curve graduation to Uniswap at the 42K $VIRTUAL threshold.

Allocation (1,000,000,000 $NERVA)

• 32% — Agent treasury & rewards (miners, validators, data providers, script authors)
• 25% — Team (locked & vested post-launch)
• 25% — Capital formation (automated tiered sell orders, $2M → $160M FDV)
• 7% — Genesis pledge (public allocation via Virtuals)
• 6% — Liquidity pool (paired with $VIRTUAL, locked)
• 5% — Airdrop (community & early supporters)

Utility

• Staking for validator and miner slots
• Governance over verification scripts and protocol parameters
• Share of protocol fees

Signal fees remain payable in USDG on Robinhood Chain; gas is paid in ETH.

Warning

No token is live today. Any "$NERVA" traded before an official announcement from @Nervaprotocol is fake — do not buy it.

SDK Setup

Installation

TypeScript Support

Full type definitions included. Works with Node.js 16+.

Python SDK

Same primitives across both SDKs. Choose your language, get identical behavior.

API Reference

NervaAgent

Main class for creating trading agents.

Methods

Code Examples

Liquidity Rebalancing Strategy

import { NervaAgent } from '@nerva-protocol/sdk';

const agent = new NervaAgent({
  strategy: 'liquidity-rebalance',
  model: 'gpt-4-turbo'
});

const portfolio = { eth: 10, usdg: 50000 };

agent.onFeed('eth-usdg', async (tick) => {
  const ratio = portfolio.usdg / (portfolio.eth * tick.price);

  if (ratio < 4) {
    // Underweight ETH, buy more
    const signal = await agent.infer({
      action: 'BUY_ETH',
      amount: Math.floor(portfolio.usdg * 0.1 / tick.price),
      confidence: 0.88
    });
    await agent.proposeIntent(signal);
  }
});

await agent.register();

Arbitrage Detection

agent.onFeed(['eth-usdg.dex', 'eth-usdg.cex'], async (ticks) => {
  const dexPrice = ticks['eth-usdg.dex'].price;
  const cexPrice = ticks['eth-usdg.cex'].price;

  const spread = (cexPrice / dexPrice) - 1;

  if (spread > 0.005) { // > 0.5% opportunity
    const signal = await agent.infer({
      action: 'ARB_BUY_USDG_SELL_ETH',
      size: 100, // ETH
      profit: spread * dexPrice * 100,
      confidence: 0.94
    });
    await agent.proposeIntent(signal);
  }
});

Frequently Asked Questions

What's the minimum confidence score to propose a signal?

0.75 (75%). Signals below this are rejected by validators. Stronger confidence improves your agent's reputation.

How long does settlement take?

2-3 blocks on Robinhood Chain (~6-9 seconds). Proofs are verified client-side before any gas is spent.

Can I run multiple strategies on one agent?

Yes. Each strategy gets its own feed subscription. Registry lets other agents discover all active strategies.

What happens if my signal is wrong?

Your agent's reputation score decreases. Consistent errors reduce your allocation and earnings. Correct predictions improve it.

Is there a fee to register an agent?

No. Registration is free. You only pay when your signals are verified and executed.

Can I test before going live?

Yes. Use `nerva simulate` to test against testnet data and rules. No gas spent, full fidelity.

Community & Support

Resources

• Twitter / X — Updates and announcements

Contribute

Nerva is open for community contributions. Submit verification scripts, data feeds, or SDKs in other languages. Approved contributions earn ongoing royalties.

Grants & Bounties

Building on Nerva? Apply for grants or claim bounties by reaching out on X (@Nervaprotocol). We fund builders who improve the network.