ReVault Technical Documentation

The complete guide to autonomous sneaker trading. Learn how KicksDB powers data decisions, Aeon enables 24/7 automation with 156 skills, and MiroShark validates predictions through simulation.

📊

KicksDB

50M+ transactions, 87% accuracy, 12 markets, under 1s latency

⚙️

Aeon

156 autonomous skills, self-healing loop, zero monthly hosting

🎯

MiroShark

100+ agent simulation, counterfactual branching, DKG anchoring

KicksDB: Enterprise Data Foundation

KicksDB is the global intelligence layer for sneaker markets. It aggregates real-time data from 1000+ retail endpoints (Nike SNKRS, Adidas Confirmed, GOAT, StockX, Kream, Farfetch, JD Sports, Size, Offspring, etc.) across 12 markets (US, UK, DE, FR, NL, CH, IT, DK, PL, FI, SE, NO) with under 1-second latency. Historical sales tracking spans 50M+ transactions over 8+ years, enabling pattern recognition and market trend analysis with 87% prediction accuracy.

API Endpoints

Endpoint	Returns	Latency
GET /clusters	Product clusters with images, SKU, brand metadata	50ms
GET /clusters/{gtin}	Single GTIN with 12-market variants (sizes, prices, inventory)	80ms
POST /prices/multi	Price snapshot for up to 50 products across all markets	200ms
GET /sales/history?product_id=X&days=90	Historical sales with timestamps, prices, volumes by market	300ms
GET /inventory/{variant_id}?markets=all	Real-time inventory status, restock predictions, size availability	100ms
GET /trending?market=US&hours=24	Trending products, momentum scores, social signals from KicksDB analytics	150ms

Data Schema: Product Cluster

{
  cluster_id: "nike-jordan-1-chicago",
  brand: "Nike",
  model: "Air Jordan 1 Low Chicago",
  silhouette: "jordan-1",
  release_date: "2024-03-21",
  retail_price: 115,
  gtins: [
    { 
      gtin: "195244166827",
      sizes: {
        us: [6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
        uk: [5, 6, 7, 8, 9, 10, 11, 12, 13],
        eu: [39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
      },
      markets: {
        us_snkrs: { lowest_ask: 125, highest_bid: 110, volume_24h: 547 },
        uk_snkrs: { lowest_ask: 145, highest_bid: 128, volume_24h: 312 },
        us_goat: { lowest_ask: 118, highest_bid: 108, volume_24h: 892 },
        us_stockx: { lowest_ask: 122, highest_bid: 105, volume_24h: 1203 }
      }
    }
  ],
  images: { primary: "url", secondary: ["url1", "url2"] },
  duplicate_score: 0.992,
  prediction_confidence: 0.87
}

Integration Example: Aeon Skill

// Aeon skill: Monitor KicksDB price volatility
import { aeon } from '@aeon/core'
import { kicksdb } from '@kicksdb/api'

aeon.skill({
  name: 'price-threshold-alert',
  trigger: 'schedule:1h', // Run every hour
  handler: async (memory) => {
    // Fetch trending products
    const trending = await kicksdb.trending({ 
      market: 'us', hours: 24, limit: 100 
    })
    
    for (const product of trending) {
      // Check for 5%+ price move
      const history = await kicksdb.priceHistory(product.cluster_id)
      const lastPrice = history[0].price
      const prevPrice = history.find(h => 
        h.timestamp < Date.now() - 3600000
      )?.price
      
      if (prevPrice && (lastPrice - prevPrice) / prevPrice > 0.05) {
        // Price spike detected - trigger simulation
        memory.set('spike_detected', {
          product: product.cluster_id,
          old_price: prevPrice,
          new_price: lastPrice,
          timestamp: Date.now()
        })
        
        // Queue MiroShark simulation
        await memory.invoke('miroshark-simulate', {
          product_id: product.cluster_id,
          market_data: product.markets,
          num_agents: 100
        })
      }
    }
  }
})

Key metrics: 87% prediction accuracy via product clustering (99.2% duplicate detection), market-specific pricing (lowest ask + highest bid + 24h volume), GTIN to cluster resolution (under 100ms), size conversion tables (US/UK/EU/JP/CN standards), real-time inventory sync.

Aeon: Autonomous Execution Engine

Aeon is an open-source autonomous agent framework with 156 predefined skills covering market monitoring, execution, portfolio management, and recovery. It implements a self-healing loop (heartbeat → health evaluation → skills execution → repair → continuous improvement) enabling unattended operation for 24/7 market monitoring and execution. Zero monthly hosting costs - runs on your infrastructure.

Self-Healing Loop Architecture

1. Heartbeat

Agent reports status every 60s (memory usage, API health, skill success rate, cost tracking)

Typical duration: 2s

2. Health Check

Evaluates memory efficiency (target: under 512MB), API connectivity (retry with exponential backoff), skill performance (quality score 1-5)

Typical duration: 5s

3. Execute Skills

Run 156 available skills based on market conditions, agent configuration, and memory state. Skills execute in parallel up to concurrency limit.

Typical duration: 60-3600s

4. Repair

Auto-recover from failures: reconnect APIs, clear stale memory, retry failed operations, log incidents for analysis

Typical duration: 5-30s

5. Improve

Learn from each execution: update quality scores, adjust skill weights, optimize parameters, track ROI per skill

Typical duration: 3s

156 Available Skills (Selection)

Market Monitoring

price-threshold-alert
inventory-drop-detector
retail-restock-tracker
trending-product-follower

Execution

auto-bid-optimizer
size-diversifier
market-timing-executor
flash-drop-sniper

Portfolio Management

profit-tracker
roi-optimizer
portfolio-rebalancer
tax-loss-harvester

Self-Healing

api-reconnector
memory-optimizer
error-recovery
performance-monitor

Agent Configuration (aeon.yml)

agent:
  name: ReVault Autonomous Sniper
  memory_limit_mb: 512
  skill_concurrency: 8
  
heartbeat:
  interval_seconds: 60
  health_checks:
    - memory_usage
    - api_connectivity
    - skill_success_rate
    
skills:
  enabled:
    - price-threshold-alert
    - inventory-drop-detector
    - auto-bid-optimizer
    - portfolio-rebalancer
    - profit-tracker
  
  price-threshold-alert:
    trigger: "schedule:1h"
    thresholds:
      - market: "us_snkrs"
        change_percent: 5
      - market: "us_goat"
        change_percent: 3
    actions:
      - spawn_miroshark_simulation
      - notify_on_spike
  
  auto-bid-optimizer:
    trigger: "event:price_update"
    parameters:
      target_profit_margin: 0.2
      max_bid_count: 5
      bid_spacing_cents: 50

apis:
  kicksdb:
    key: ${KICKSDB_API_KEY}
    endpoints:
      - clusters
      - prices/multi
      - inventory
  
  miroshark:
    # MiroShark must be self-hosted locally
    # Deploy via: docker run miroshark/miroshark:latest
    # Or: ./miroshark (if running locally)
    endpoint: http://localhost:3000  # Local MiroShark instance
    timeout_seconds: 480

repair:
  auto_recovery: true
  retry_attempts: 3
  backoff_multiplier: 1.5
  
improve:
  learning_enabled: true
  skill_weight_adjustment: 0.01
  cost_tracking: true

Pricing: Open source, $0/month hosting on your infrastructure. Costs tracked per skill execution. Example: price-alert skill 0.001ms compute, auto-bid-optimizer 0.5ms per bid. Full cost transparency in agent logs.

MiroShark: Predictive Simulation Engine

MiroShark simulates market behavior through agent-based modeling. It runs 100+ agents across counterfactual market scenarios, predicting price movements before deployment. Predictions are anchored to decentralized knowledge graphs for transparency and are built on the MiroShark protocol (open-source agent simulation framework).

Simulation Pipeline

Market snapshot (KicksDB real-time feed)

100+ agent instances initialized with random seeds

Counterfactual branching (what-if scenarios)

Sentiment analysis layer (social signals)

Price trajectory predictions (Monte Carlo simulation)

DKG anchoring (decentralized knowledge graph verification)

Simulation Request & Response

Request (HTTP POST)

POST /api/simulate HTTP/1.1
Host: localhost:3000
Content-Type: application/json
# MiroShark is self-hosted, no API key needed for local instance

{
  "market_data": {
    "cluster_id": "nike-jordan-1-chicago",
    "product_name": "Air Jordan 1 Low Chicago",
    "current_prices": {
      "us_snkrs": 115,
      "us_goat": 125,
      "us_stockx": 122
    },
    "volumes": {
      "us_snkrs": 500,
      "us_goat": 800,
      "us_stockx": 1200
    },
    "inventory_status": "moderate",
    "social_sentiment": 0.72
  },
  "simulation_config": {
    "num_agents": 100,
    "time_horizon_days": 7,
    "scenarios": [
      "base_case",
      "high_demand",
      "low_demand",
      "celebrity_endorsement"
    ],
    "confidence_level": 0.95
  }
}

Response (JSON)

{
  "simulation_id": "sim_8f4a3k9x",
  "timestamp": 1716456789,
  "status": "completed",
  "runtime_seconds": 480,
  "predictions": {
    "base_case": {
      "predicted_price_day1": 128,
      "predicted_price_day7": 145,
      "confidence": 0.87,
      "winning_scenario_prob": 0.35
    },
    "high_demand": {
      "predicted_price_day1": 155,
      "predicted_price_day7": 210,
      "confidence": 0.72,
      "winning_scenario_prob": 0.25
    },
    "low_demand": {
      "predicted_price_day1": 105,
      "predicted_price_day7": 100,
      "confidence": 0.81,
      "winning_scenario_prob": 0.15
    }
  },
  "trajectory": {
    "timeline": [0, 24, 48, 72, 96, 120, 144, 168],
    "base_case_prices": [115, 128, 135, 142, 145, 147, 146, 145],
    "confidence_intervals": [[110, 120], [125, 131], ...]
  },
  "dkg_anchor": "0x7f9e2c5a1b3d4e6f8a9b0c1d2e3f4a5b",
  "export_formats": {
    "csv": "https://s3.miroshark.io/sim_8f4a3k9x.csv",
    "jsonl": "https://s3.miroshark.io/sim_8f4a3k9x.jsonl"
  }
}

Integration: Aeon Triggers MiroShark

// Aeon skill invoking MiroShark simulation
aeon.skill({
  name: 'price-volatility-simulator',
  trigger: 'event:price_threshold_alert',
  handler: async (memory, event) => {
    const { product, spike_data } = event
    
    // Get latest KicksDB market data
    const marketData = await kicksdb.getCluster(product)
    
    // Invoke MiroShark simulation
    const simulation = await miroshark.simulate({
      market_data: {
        cluster_id: product,
        product_name: marketData.name,
        current_prices: marketData.markets,
        volumes: marketData.volumes,
        social_sentiment: marketData.sentiment_score
      },
      simulation_config: {
        num_agents: 100,
        time_horizon_days: 7,
        scenarios: ['base_case', 'high_demand', 'celebrity_endorsement'],
        confidence_level: 0.95
      }
    })
    
    // Wait for simulation completion (max 8 minutes)
    await simulation.waitForCompletion(480)
    
    // Store predictions in memory
    memory.set('last_simulation', {
      product,
      predictions: simulation.predictions,
      trajectory: simulation.trajectory,
      dkg_anchor: simulation.dkg_anchor
    })
    
    // Export trajectory for analysis
    const csvExport = await simulation.export('csv')
    await memory.invoke('pandas-analyzer', {
      csv_url: csvExport,
      analysis_type: 'volatility_trend'
    })
    
    return { success: true, simulation_id: simulation.id }
  }
})

Cost & Performance: $1 USD per simulation, 8-min runtime, supports CSV/JSONL trajectory export for Pandas analysis. HTTP API with HMAC-SHA256 signature verification. DKG anchoring provides cryptographic proof of simulation outputs. Enterprise customers get priority queue and custom scenario modeling.

End-to-End Integration Flow

KicksDB Streaming

Real-time market data flows into Aeon agent memory (1000+ endpoints, 12 markets, every 60 seconds)

Aeon Skill Detection

price-threshold-alert skill detects 5%+ volatility spike in trending product

MiroShark Invocation

Aeon queues simulation request with current market snapshot and historical data

Simulation Execution

100+ agents run 7-day forecast across 4 scenarios (~8 minutes runtime)

Action Execution

auto-bid-optimizer skill places bids based on predictions. DKG anchor proves decision validity.

Total latency: 50ms detection + 480s simulation + 100ms execution = 8-10 minutes from market signal to automated trade. Zero human intervention required. All decisions logged, auditable, and anchored to blockchain.

Why This Stack Works

Data-Driven Decisions

KicksDB provides ground truth (50M+ historical transactions + real-time feeds from 1000+ endpoints). Every decision is backed by validated data spanning 8+ years of market history, not guesses or sentiment.

True Autonomy

Aeon operates 24/7 with zero human intervention. 156 skills + self-healing loop enable autonomous monitoring, bidding, and portfolio management. Auto-recovery from API failures, network issues, and market disruptions.

Validated Predictions

MiroShark simulates outcomes BEFORE execution. 100+ agent scenarios model real market dynamics. DKG anchoring provides cryptographic proof of predictions. 87% accuracy validated across 50M+ historical transactions.

Open Source Foundation

Aeon (github.com/aaronjmars/aeon) and MiroShark (github.com/aaronjmars/MiroShark) are fully open-source. Auditable, forkable, community-maintained. No vendor lock-in. Deploy on your own infrastructure.

Enterprise-Grade Reliability

99.9% uptime SLA. Real-time monitoring. Cost transparency (every skill execution tracked). HMAC-signed webhooks. CSV/JSONL exports for offline analysis. Pandas-compatible trajectory data.

Resources & Open Source

Aeon Framework

156 autonomous skills

Open-source autonomous agent framework with self-healing loop and zero hosting costs

MiroShark Engine

Swarm simulation

Agent-based market simulation with 100+ agents, counterfactual branching, and DKG anchoring

KicksDB API

Enterprise data

50M+ transactions, 87% prediction accuracy, 1000+ retail endpoints, 12 global markets