AIRBX

AI-powered intelligence that predicts whether arbitrage opportunities will survive long enough to execute profitably.

Comment

Inspiration

My interest in the stock markets began early. Although I was unable to invest as a student and my family initially preferred that I pursue a different path, my passion for trading persisted. After completing high school, I hoped to work at the Bombay Stock Exchange (BSE). However, at my father's advice, I enrolled in a B.Tech program instead.

During my college studies, I learned about Jane Street and the mechanics of arbitrage. Discovering how high-frequency trading (HFT) firms utilize algorithms developed by engineers to generate returns inspired me to create a real-world project of my own.

What it does

AIRBX predicts whether a cross-exchange crypto arbitrage opportunity will stay profitable long enough to be worth acting on.

You enter the details of a price gap (spread %, liquidity, volatility, momentum, arbitrage amount and quantity) into a live web app. A trained Random Forest model returns persistent or not persistent with a confidence score. Then an NVIDIA Nemotron model running on Nebius Token Factory explains the result in plain English, using the numbers you entered.

How we built it

  • Data: a public Mendeley dataset of 9,799,130 BTC/EUR arbitrage records across 18 exchanges (Jan 2019 to Mar 2020).
  • Target: the dataset doesn't say how long a gap lasted, so we derived a proxy from the timestamps. An opportunity counts as persistent if the next one on the same exchange pair appears within 60 seconds and its profit is at least 0.5%. We chose both cutoffs from the data's percentiles, not the mean, because rare multi-month gaps pushed the mean up to 543 seconds while the median was only 31.
  • Features: spread %, liquidity score, volatility (rolling standard deviation), momentum, arbitrage amount and quantity.
  • Models: Logistic Regression, Decision Tree and Random Forest, evaluated on a time-based 80/20 split so no model trains on data from after its test examples.
  • NVIDIA and Nebius: after each prediction, the app calls an NVIDIA Nemotron model (NVIDIA-Nemotron-3-Nano-30B-A3B) through the Nebius Token Factory API, which uses the OpenAI-compatible format. The prompt gives the model the inputs and the prediction, and it writes a short plain-English explanation. The API key is stored in Streamlit's secrets, not in the code.
  • App: a Streamlit web app deployed from a public GitHub repository.

Results on the held-out test set:

  • Logistic Regression: 90.5% accuracy, 0.966 ROC-AUC
  • Decision Tree: 94.9% accuracy, 0.958 ROC-AUC
  • Random Forest: 96.1% accuracy, 0.969 ROC-AUC, 98.7% recall, 97.3% F1-score

Challenges we ran into

  • Data leakage: our first model scored suspiciously well because profit % was both part of the target definition and an input feature. We removed it and retrained. The scores barely changed, because spread % carries similar information but was never part of the target's formula.
  • Bad data: a few rows had a price of zero, which caused division-by-zero errors. We found and removed them.
  • Scale: 9.8 million rows made uploads and training slow, so we trained on a 500,000-row sample.
  • Deployment: a misnamed requirements.txt and a scikit-learn version mismatch broke our first deployments.
  • Connecting the NVIDIA model: getting billing and an API key working took several attempts, including authentication errors, before the explanations appeared.
  • Learning as we built: we started with very little coding experience, so we learned each tool as we needed it.

Accomplishments that we're proud of

  • Catching and fixing a real data-leakage bug instead of reporting inflated scores.
  • Building the persistence label ourselves from raw timestamps, with cutoffs justified by the data.
  • Using a time-based split to avoid look-ahead bias.
  • Taking the project from a raw CSV to a live web app that predicts and explains, using an NVIDIA model on Nebius.

What we learned

  • How to clean, explore and engineer features from a large real-world dataset.
  • Why the mean misleads on skewed data and percentiles are safer.
  • The difference between data leakage and a legitimately strong feature.
  • How to train, compare and deploy a machine-learning model, and how to call a hosted LLM from an app.

What's next for AIRBX

  • Test on more exchanges, trading pairs and more recent data.
  • Add XGBoost and a view of which features drive each prediction, so the explanation can come from the model itself and not only from a language model.
  • Build a backtesting layer that includes fees, latency and slippage.
  • Measure persistence directly from order-book data instead of using a proxy.

Limitations: the model covers one pair (BTC/EUR) and one period, and "persistent" is a proxy derived from timestamps. The NVIDIA explanation interprets the inputs and is not the Random Forest's internal reasoning. AIRBX is a research and educational project, and its predictions do not guarantee profitable trading outcomes.

Built With

Share this project:

Updates

Submission history