Nexxore Documentation

Everything you need to understand, use, and build on Nexxore. From first trade to custom agent deployment.

Architecture

Nexxore is structured as a vertical stack. Data flows in one direction: intelligence → strategy → execution. Every product we build maps to one of these three layers.

The prediction layer ingests on-chain data, social sentiment, order book depth, and funding rates. It produces intent signals — structured predictions about what's likely to happen next.

The strategy layer takes those signals and turns them into trade logic. "If funding rate flips negative and OI spikes, open a short hedge." This can be done visually in the Strategy Builder or programmatically via the API.

The execution layer routes the final trade across DEXs, perp protocols, and chains. It picks the best liquidity, manages slippage, and settles. No human in the loop.

Quick Start

The fastest way to get going is to just use the app. No wallet needed to browse. Connect a wallet when you want to trade.

1. Explore signals

Head to the On-Chain Analyst — it surfaces trade ideas, alpha signals, and flow analysis in real time. No account required.

2. Try prediction markets

The PRED Agent runs 6 autonomous agents on Polymarket. You can watch them work, check their reasoning, or post their picks directly to Telegram.

3. Trade perps

Go to NX-Perps, connect your wallet, and trade ETH/BTC/SOL perpetuals with up to 50x leverage. Fully on-chain.

4. Build a strategy

The Strategy Builder lets you wire up conditions and triggers visually. Set entry rules, stop losses, take profits — then let the agent execute it.

The 3-Layer Stack

Layer 1 — Prediction

This is where the data work happens. Agents ingest multiple data sources — on-chain flows, social feeds, order book snapshots, funding rate history — and produce structured signals.

The key insight: most platforms react to price movement. We try to predict it. That means looking at the things that cause price to move — liquidity shifts, whale flows, sentiment spikes — before the move happens.

Layer 2 — Strategy

Raw signals aren't useful on their own. The strategy layer is where you define what to do with a signal.

The Strategy Builder provides a visual interface for this. You can also use the API to define strategies programmatically. Strategies support:

• Conditional logic — if signal X fires, then open position Y
• Risk parameters — max position size, stop loss, take profit
• Multi-leg trades — e.g., spot + perp hedge for delta-neutral
• Backtesting — run your strategy against historical data before deploying

Layer 3 — Execution

Once a strategy triggers, the execution engine handles routing. It finds the best liquidity across supported DEXs and chains, manages slippage, and settles the trade.

This layer is designed to be chain-agnostic. If the best fill for a position is on Arbitrum but the signal came from Solana data, the engine handles the cross-chain routing.

Agents

Agents are the core primitive in Nexxore. Each agent has a single responsibility. They don't overlap.

Strategies

A strategy is a set of rules that maps signals to trades. You can build them in the visual Strategy Builder or define them as JSON via the API.

{
  "name": "ETH Funding Flip",
  "trigger": {
    "signal": "funding_rate",
    "pair": "ETH-PERP",
    "condition": "crosses_below",
    "threshold": -0.01
  },
  "action": {
    "type": "open_long",
    "size": "5%_portfolio",
    "leverage": 3,
    "stop_loss": "-2%",
    "take_profit": "+5%"
  }
}

Strategies can reference multiple signals and execute multi-leg trades. A delta-neutral strategy, for example, might open a spot long and a perp short simultaneously.

Execution Engine

The execution engine is the "muscle" layer. When a strategy fires, it handles everything from order construction to settlement.

• Smart routing — splits orders across liquidity sources for best price
• Slippage protection — configurable max slippage per trade
• Cross-chain — routes across Ethereum, Arbitrum, Solana (more coming)
• Gas optimization — batches transactions where possible

NX-Perps

Our perpetual exchange. Trade BTC, ETH, SOL, and more with up to 50x leverage, fully on-chain. The order book is decentralized and execution is sub-second.

Supported pairs

Vaults

Vaults are curated yield strategies. You deposit, the vault executes. There are two tiers:

• Safe Yield — conservative, stablecoin-focused, low risk. Think of it as a high-yield savings account.
• Advanced Realloc — actively managed, higher risk/reward. The vault rebalances across protocols based on real-time APY data.

PRED Agent

The PRED Agent is a 6-agent system that works prediction markets on Polymarket. Each agent has a distinct role:

1. Scanner — monitors all active markets for volume and edge
2. Researcher — deep-dives into flagged markets
3. Risk Manager — sizes positions, sets limits
4. Executor — places trades
5. Monitor — watches open positions in real time
6. Reporter — generates performance summaries

You can connect the PRED Agent to Telegram to get alerts when it finds a high-conviction trade. See the Telegram guide below.

Stablecoin Hub

A dedicated dashboard for stablecoin management: peg monitoring, yield deployment, depeg alerts, and stablecoin-specific perps. Supports USDC, USDT, DAI, and more.

Strategy Builder

A visual workspace for building trading strategies. Drag conditions, connect triggers, set risk parameters, and backtest — all without writing code. When you're happy with it, deploy it and the execution engine takes over.

Market Data Agent

The Market Data Agent is a dedicated Dexscreener integration service that provides real-time DEX pair data, volume tracking, and liquidity monitoring across 5 chains. It acts as the data backbone for the Signal Engine and On-Chain Analyst.

Capabilities

• Dexscreener API Client — Async HTTP client with sliding-window rate limiting (60 rpm slow / 300 rpm fast bucket)
• Top Movers Discovery — Boosted + trending tokens aggregated from token profiles, boosts, and pair data
• New Pair Detection — Surfaces newly created pairs with >$100K liquidity within 24h
• Liquidity Monitoring — Tracks significant liquidity changes (>20% in 10 min) across all monitored pairs
• Token Search — Full-text search across Dexscreener's pair database
• Time-Series Storage — SQLite snapshots with 7-day retention and materialized latest view
• Caching Layer — Redis with in-memory LRU fallback, per-category TTLs (10s–300s)

Architecture

Key endpoints

Signal Engine

The Signal Engine is a Market Intelligence Agent that consumes data from the Market Data Agent and produces composite alpha signals. It runs 4 independent detectors and combines them into a 0–100 scoring system.

Signal detectors

Scoring classification

• Score >70 → Strong Trade — high-confidence alpha opportunity
• Score 50–70 → Watchlist — monitor for breakout confirmation
• Score <50 → Ignore

Architecture

Key endpoints

API Overview

The Nexxore API lets you access signals, manage strategies, and trigger execution programmatically. All endpoints return JSON.

https://nexxore.xyz/api

Endpoints

Example: fetch research signals

curl https://nexxore.xyz/api/research

{
  "status": "ok",
  "signals": [
    {
      "type": "alpha",
      "title": "ETH funding rate turning negative",
      "confidence": 0.82,
      "timestamp": "2026-02-27T14:30:00Z"
    }
  ]
}

Authentication

Public endpoints (research, signals, health) don't require authentication. For write operations (telegram alerts, strategy deployment), you'll need an API key.

Rate Limits

To keep things fair:

• Public endpoints: 60 requests/minute
• Authenticated endpoints: 300 requests/minute
• Rate limit headers are included in every response

Telegram Alerts

The PRED Agent can post trade alerts directly to your Telegram. Here's how to set it up:

1. Create a bot

Message @BotFather on Telegram and run /newbot. Save the token it gives you.

2. Get your chat ID

Message your new bot, then hit:

https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates

Look for chat.id in the response.

3. Set environment variables

TELEGRAM_BOT_TOKEN=your_bot_token_here
TELEGRAM_CHAT_ID=your_chat_id_here

On Vercel, add these in Settings → Environment Variables.

4. Test it

curl -X POST https://nexxore.xyz/api/telegram \
  -H "Content-Type: application/json" \
  -d '{"message": "test alert from nexxore"}'

Delta-Neutral Guide

A delta-neutral position is one where you're not exposed to the direction of the market. You profit from other things — funding rates, basis spreads, yield — while the price exposure cancels out.

How it works on Nexxore

1. Go long on spot (buy ETH)
2. Go short the same amount on perps (short ETH-PERP)
3. If ETH goes up, your spot gains and perps lose — net zero
4. If ETH goes down, your spot loses and perps gain — net zero
5. Meanwhile, you collect funding rate payments (when funding is positive)

The Delta-Neutral Builder automates this. It monitors funding rates and rebalances the hedge automatically.

Self-Hosting

Nexxore is deployed on Vercel. If you want to run your own instance:

git clone https://github.com/ayush101098/nexxore-.git
cd nexxore-
npm install

# Set env vars
cp .env.example .env
# Edit .env with your keys

# Deploy
vercel --prod