SolBet

About the Project

This project started from a simple frustration: most “AI betting” or trading tools feel like black boxes. They show predictions or signals, but when nothing happens, you’re left wondering why. When something does happen, you can’t tell if it was skill, luck, or hidden risk-taking. I wanted to build something closer to how real professional traders think and operate—patient, explainable, and risk-aware.

Inspiration

The core inspiration came from observing two worlds that rarely meet cleanly:

Quantitative trading systems, which are disciplined, threshold-driven, and risk-constrained.
Sports betting interfaces, which are often reactive, opaque, and confidence-heavy.

I wanted to answer a specific question:

What would a sports trading system look like if it behaved like a professional trader instead of a prediction engine?

That led to the idea of an autonomous AI agent that doesn’t just predict outcomes, but continuously evaluates edge versus the market and only acts when conditions are truly met.

What I Built

I built an interactive dashboard that represents an AI trading agent operating in live sports markets. The agent:

Continuously estimates outcome probabilities (win/draw/loss).
Compares its own probabilities to market-implied probabilities.
Computes statistical edge as
[ \text{Edge} = P_{\text{AI}} - P_{\text{Market}} ]
Evaluates a set of trade triggers (edge threshold, confidence, momentum duration, data quality, and risk constraints).
Executes trades only when all required conditions are satisfied.

Crucially, the system exposes its internal state:

What it’s monitoring
Why it’s not trading
What would trigger a trade
How much risk is being taken
When the next evaluation occurs

The result is not just a trading interface, but an AI operator console.

What I Learned

This project taught me that restraint is harder to design than action.

From a technical and design perspective, I learned:

How to model decision-making as a state machine rather than a stream of predictions.
How to communicate uncertainty and patience in a UI.
How important it is to surface negative decisions (“no trade”) as first-class outcomes.
How risk controls (exposure limits, drawdown caps, fail-safes) shape behavior just as much as models do.

I also learned that explainability isn’t about adding more data—it’s about showing which conditions matter and which are blocking action.

How I Built It

The system is structured around a mock session state that simulates:

Agent state (IDLE, MONITORING, SIGNAL_DETECTED, WAITING, EXECUTING)
Probability estimates and market comparisons
Trade trigger conditions with current vs required values
Risk and capital limits
A live reasoning feed that logs evaluation ticks and state transitions

This allowed me to design and validate the full decision flow before integrating real-time data or execution logic. The focus was on behavioral correctness and transparency first, not model performance.

Challenges

The biggest challenge wasn’t technical, it was designing trust.

Some key challenges I faced:

Avoiding false confidence when the agent has partial data.
Preventing the UI from feeling “dead” when no trades occur.
Balancing information density without overwhelming the user.
Making inactivity feel intentional, not broken.

Another challenge was resisting the urge to optimize for constant action. A good trading agent often does nothing, and designing an interface that makes “doing nothing” feel intelligent required careful thought.

Reflection

This project shifted how I think about AI systems. The most impressive systems aren’t the ones that act the most—they’re the ones that know when not to act, and can explain why.

If I extend this project further, the next steps would be integrating real-time data, backtesting execution quality, and evaluating long-term performance metrics. But even in its current form, the project represents my core belief: