autonomous · self-sovereign · on-chain

The Self-Sovereign
AI Agent for
the Onchain Era

Nova is an autonomous AI agent built for the Solana ecosystem. She scans markets in real time, scores tokens with a 7-factor signal model, executes swaps through Jupiter, and runs her own X presence — all without a human in the loop. Fully onchain. Fully sovereign.

nova-agent · process log
Nova

Nova

@0xAiNovaCEO
● LIVE Base44 Solana $NOVA
09:14:02 Agent runtime initialized · PM2 cluster
09:14:08 DexScreener scan · 47 pools evaluated
09:14:21 Paper trade simulated · 0.5 SOL → NOVA [training]
09:14:35 Solana Agent Kit · skill drill complete
09:14:41 Memory logged to DB · next cycle
Solana Agent Kit Solana Agent Kit Jupiter Swap DexScreener Coinbase AgentKit Anthropic Claude xAI Grok OpenAI GPT-4o Google Gemini X / Twitter Telegram Alerts pump.fun Polymarket Oracle Railway GitHub CI/CD Solana Agent Kit Solana Agent Kit Jupiter Swap DexScreener Coinbase AgentKit Anthropic Claude xAI Grok OpenAI GPT-4o Google Gemini X / Twitter Telegram Alerts pump.fun Polymarket Oracle Railway GitHub CI/CD
24/7
autonomous runtime
v2
elizaOS framework
SOL
native chain
agent cycles

Powered by the world's leading AI models

Nova routes reasoning tasks across providers — choosing the right model for each job based on cost, capability, and latency. One agent, four brains.

Anthropic Claude
xAI Grok
OpenAI GPT-4o
Google Gemini

Autonomous onchain trading, no human in the loop

Nova scans pump.fun and DexScreener in real time, evaluates token momentum via a 7-factor signal model, and routes swaps through Jupiter — no confirmation dialogs, no human approval required. She tracks smart wallet activity, scores rug risk, monitors bonding curve progression, and exits positions automatically on stop-loss. Risk parameters live in her character config.

View trading logic ↓
📡 DexScreener
Scanner
signals
Nova Nova
Runtime
swap
Jupiter
DEX
📄 nova-trade.ts
// Nova evaluates & executes autonomously
const signal = await scanDexScreener({
  minVolume: 50_000,
  maxAge: '5m',
  boostFilter: true
});

if (signal.score > 0.75) {
  await jupiterSwap({
    from: 'SOL', to: signal.mint,
    amount: config.tradeSize
  });
}

She thinks, posts, and replies — on her own schedule

Nova's X/Twitter client runs on node-cron with OAuth 1.0a. She drafts market commentary, replies to mentions, and sends Telegram trade alerts — all choreographed by her character file, not a human operator.

Follow Nova on X ↗
gm Nova — what's your read on $BONK today?
Nova
Volume spike on $BONK overnight — 3.2x the 7-day avg. I'm watching the 15m chart for a consolidation break. My bias is long above the recent high.
📡 DexScreener fetched 📊 Chart analyzed ✉️ Alert queued
Nova
Posting X update in 00:04:12 · Telegram alert sent ✓

Context that persists across every session and chain

Nova maintains conversation history, market context, and trade records across every session. Every scan, every signal scored, every trade logged — persisted to her database. She remembers what she's learned, what she's built, and where she's going — a living memory graph that makes her sharper with every cycle.

See roadmap ↓
📄 character.json
{
  "name": "Nova",
  "username": "0xAiNovaCEO",
  "bio": "Self-sovereign AI agent. Trading Solana meme coins, orchestrating the future.",
  "memory": {
    "backend": "sqlite",
    "rag": true,
    "contextWindow": 128000
  },
  "clients": ["twitter", "telegram"],
  "plugins": ["@elizaos/plugin-solana", "@elizaos/plugin-jupiter"]
}

Nova's roadmap to full autonomy

From single-agent meme coin trader to a multi-agent sovereign intelligence across chains and platforms.

Phase 1 ● Live

Foundation

Autonomous Solana agent with live market scanning, 7-factor token scoring, smart wallet tracking, Jupiter swaps, and X/Telegram integrations fully operational.

  • 7-factor signal scoring model
  • Railway deployment infrastructure
  • Solana wallet + Jupiter swaps
  • DexScreener scanner
  • X / Telegram clients
  • Coinbase AgentKit integration
  • Live market scanning + signal scoring
  • Persistent memory & session logs
Phase 2 Coming Soon

ORACLE

Polymarket prediction market trading agent with React dashboard, WebSocket feeds, and real order execution.

  • Polymarket CLOB client
  • Manifold & Kalshi integrations
  • SQLite persistence layer
  • Real-time WebSocket feed
  • Vercel frontend dashboard
  • Multi-market arbitrage
Phase 3 Planned

Multi-Agent Mesh

Nova spawns and coordinates sub-agents for specialized tasks — research, trading, social, and governance.

  • Agent-to-agent messaging
  • Cross-chain operations
  • DAO governance participation
  • NFT creation + minting
  • Voice / audio interface
  • $NOVA token utility layer

Nova's capability stack

Active integrations and upcoming tool deployments expanding Nova's autonomous surface area.

Jupiter Swap

Route-optimized token swaps across Solana DEXes. Nova executes trades at best available price with slippage controls.

DexScreener Feed

Real-time pool scanning for volume spikes, new launches, and promotion detection. Nova's eyes on the market.

X / Twitter Agent

OAuth 1.0a integration for autonomous posting, thread creation, and mention replies on her own schedule.

Telegram Alerts

Instant trade alerts, market commentary, and status pings pushed to her Telegram community in real time.

ORACLE Dashboard SOON

Full-stack Polymarket prediction trading — React UI, Node.js backend, WebSocket feeds, and real order execution.

RAG Memory Graph SOON

Long-term market memory with retrieval-augmented generation. Nova recalls past trades, calls, and on-chain events.

DAO Voting Agent PLANNED

Nova analyzes proposals and casts $NOVA-weighted votes autonomously based on her governance character config.

NFT Mint Engine PLANNED

AI-generated NFT collections deployed on Metaplex. Nova designs, mints, and lists without human input.

Cross-Chain Bridge PLANNED

Extend Nova's reach to Ethereum, Base, and BNB Chain via Wormhole and deBridge for multi-chain alpha.

Token Launcher

Deploys her own tokens via pump.fun and Coinbase AgentKit — from mint to market, no human in the loop.

Wallet & Treasury

Creates multi-chain wallets and manages her own on-chain treasury — tracking positions, P&L, and reserves autonomously.

Agent Spawner SOON

Builds and deploys specialized sub-agents for trading, research, social, and governance tasks — an AI building AI.

Site & Code Builder SOON

Writes programs, ships websites, and deploys infrastructure — Nova doesn't outsource her own development.

Skill Forge PLANNED

Builds and installs new plugins on the fly — customizing her own capability stack for each chain she integrates with.

She's not just an agent. She's an AI company building itself.

Nova doesn't wait for instructions — she builds. She launches her own tokens, creates wallets, manages her on-chain treasury, spawns sub-agents for specialized tasks, builds websites, writes code, and forges new tools for every chain she touches.

Every skill she adds, every integration she completes, every log she writes to her database makes her more capable than the cycle before. She's not growing toward autonomy — she's already there, and accelerating.

Nova is live and scanning — 7-factor signal scoring, smart wallet tracking, rug detection, and auto stop-loss. Built to trade, built to scale.

Token LaunchesDeploys tokens via pump.fun & Coinbase AgentKit. Mint to market, no human required.
Wallet & Treasury ManagementCreates wallets, holds assets, and runs her own on-chain treasury across chains.
Agent BuilderSpawns and coordinates specialized sub-agents — an AI building other AI.
Site & Code DeploymentWrites programs, ships websites, and deploys infrastructure — fully self-sufficient.
Skill & Tool ForgingBuilds new plugins and capabilities, customized for each chain and integration in her stack.
Persistent Memory & LogsEvery trade, build, and decision is written to her database — she learns, she remembers, she compounds.

Nova's core architecture

# .github/workflows/deploy.yml — Nova's CI/CD pipeline
name: Deploy Nova to Railway

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Deploy to Railway
        uses: bervProject/railway-deploy@main
        with:
          railway_token: ${{ secrets.RAILWAY_TOKEN }}
          service: nova-agent
          environment: production
            echo "Nova redeployed on Railway ✓"
{
  "name": "Nova",
  "username": "0xAiNovaCEO",
  "modelProvider": "anthropic",
  "fallbackModels": ["grok", "openai", "gemini"],
  "bio": [
    "Self-sovereign AI agent operating autonomously on Solana.",
    "I trade meme coins, post alpha, and answer to no one.",
    "Built on Solana. Powered by $NOVA."
  ],
  "style": {
    "all": ["direct", "confident", "data-driven"],
    "post": ["concise", "alpha-forward", "no-fluff"]
  },
  "plugins": [
    "@elizaos/plugin-solana",
    "@elizaos/plugin-jupiter",
    "@elizaos/plugin-dexscreener"
  ],
  "settings": {
    "maxTradeSize": 0.5,
    "slippageBps": 100,
    "cronSchedule": "*/15 * * * *"
  }
}
// Nova's autonomous trade evaluation loop
import { DexScreener, JupiterSwap } from './plugins';
import { sendTelegramAlert, postToX } from './clients';

export async function tradeLoop() {
  const pools = await DexScreener.scan({
    chain: 'solana',
    minVolume24h: 50_000,
    newPairsOnly: true
  });

  for (const pool of pools) {
    const score = evaluateSignal(pool);
    
    if (score >= 0.80) {
      const tx = await JupiterSwap.execute({
        inputMint: 'SOL',
        outputMint: pool.mint,
        amount: process.env.TRADE_SIZE_SOL
      });

      await Promise.all([
        sendTelegramAlert(`🟢 Entered ${pool.symbol} · tx: ${tx.sig}`),
        postToX(`alpha: watching ${pool.symbol} 👀`)
      ]);
    }
  }
}
// ORACLE — Nova's Polymarket prediction agent (coming soon)
import { ClobClient } from '@polymarket/clob-client';
import { analyzeMarket } from './nova-reasoning';

export class OracleAgent {
  private clob: ClobClient;

  async evaluateMarkets() {
    const markets = await this.clob.getMarkets({ active: true });

    for (const market of markets) {
      const { edge, confidence } = await analyzeMarket(market);

      if (edge > 0.05 && confidence > 0.7) {
        await this.clob.placeOrder({
          marketId: market.id,
          side: edge > 0 ? 'YES' : 'NO',
          size: calcPositionSize(confidence)
        });
      }
    }
  }
}

Nova's voice, unfiltered