SharapovLab Trading Lab

Overview

Trading Lab, formerly known as S.A.M.S. (Smart Autonomous Market System), is a finished, shipping AI trading application. Not a proof of concept, not a demo build. It installs on Windows in a few clicks, no Python, no Docker, no command line, and runs a swarm of independent LLM trading agents against Bybit. A macOS build is on the way, and the product keeps getting updates after purchase.

No single model makes the call here. Trading Lab runs specialized agents for market analysis, a structured Bull/Bear/Probability debate, and a Judge that hands down a verdict with a confidence score. Then a capital-adaptive risk engine sizes the trade and executes it, or turns it down with a stated reason.

Problem

Most retail trading automation boils down to one hard-coded strategy: a single indicator set, one risk model, zero memory of past decisions, and no way to see why a trade got taken in the first place. That breaks the moment the market regime shifts, goes opaque exactly when it fails, and usually demands a technical setup (Python environments, Docker, manual API wiring) that most traders never signed up to manage.

Solution

Trading Lab treats trading as a system-design problem, then ships it as something anyone can actually install. A swarm of LLM strategy agents, each running a different trading style and signal approach, generates candidate trades. Every one of those goes through a structured Bull/Bear/Probability debate and a Judge verdict. After that, a risk engine that automatically scales position sizing to account balance sizes the trade against real market structure and clears it for execution.

Who It's For

Trading Lab is built for people who already understand crypto trading and want a serious automation layer, without spending months building one from scratch.

• Active crypto traders who'd rather have a systematic, always-on execution layer than sit watching charts manually.
• Trading companies and small funds who want a multi-agent research and execution stack without committing to a multi-month build.
• Developers and quants who want to inspect, calibrate and extend agent behavior instead of trusting an opaque black box.
• Investors experimenting with algorithmic strategies who want the reasoning behind a trade visible, not just a blinking signal.

It's not for anyone chasing a guaranteed-profit "set and forget" bot, and not for anyone unwilling to read the disclaimer, wire up their own API keys, and calibrate the system before real capital is on the line.

Architecture

• Python
• FastAPI
• React
• TypeScript
• Knowledge Graph
• Vector Memory
• Bybit API

A Python/FastAPI backend runs the agent swarm, the debate pipeline, the risk engine and order execution, paired with a React + TypeScript frontend. It ships as a single Windows installer with every dependency bundled in, no Docker, nothing separate to install, nothing to configure by hand. A knowledge graph plus vector-based memory let agents reason about market structure and recall similar past situations, rather than working off a rolling price buffer and nothing else. LLM inference isn't tied to one provider: agents run on whichever API key the user supplies, including free-tier options, so reasoning quality and cost stay the user's call rather than a fixed dependency. Bybit is the connected exchange for both paper trading and live execution.

Features

Here's what actually ships:

• A swarm of LLM strategy agents covering multiple trading styles and signal approaches, which the user can create, edit or let evolve over time.
• A structured debate before every trade, resolved by a Judge agent that returns a confidence-scored verdict. Trades get approved or explicitly rejected with a stated reason, never silently skipped.
• Capital-adaptive risk management: position sizing and leverage scale automatically to account balance, with stops and targets pulled from real market structure.
• A self-calibration layer that continuously checks its own decision confidence against actual trading outcomes and gets more conservative once it's been overconfident.
• Strategy Lab, an offline, read-only tool for calibrating strategy parameters against historical data, with a glossary that actually explains metrics like Profit Factor, PSR and Max Drawdown for anyone who isn't already fluent in them. Nothing applies without explicit confirmation.
• Layered safety mechanisms: a multi-stage kill switch, anomaly monitoring on agent behavior and position sizing, and a final exchange-limits check before every order goes out.
• Portfolio, shadow-portfolios and investments, with risk-concentration controls, several competing capital-allocation strategies, and long-term or funding-arbitrage positions tracked separately from active trading.
• An AI chat assistant with live access to project state (agents, balance, open positions, paper or live mode) and the knowledge base, but zero access to API keys or secrets.
• Telegram notifications for trades, entry charts with real candles and levels, and daily briefings.
• A liquidation heatmap, correlation map, whale tracking, funding/OI/CVD monitoring, and an anomaly scanner across every Bybit pair.
• Paper trading by default. Live trading needs an explicit opt-in and real exchange keys; nothing touches real money out of the box.

Technologies

• Python
• FastAPI
• React
• TypeScript
• Knowledge Graph
• Vector Memory
• Bybit API

Gallery

Screenshots are being prepared and will land here through the dashboard.

Videos

Roadmap

1. Multi-agent swarm + debate-based decision pipeline

2. Capital-adaptive risk engine + exchange safety checks

3. Windows installer with zero external dependencies

4. macOS build

5. Continuous feature updates for licensed users

Challenges

Packing a full multi-service backend into a double-click Windows installer, with no Docker and no visible terminal, meant rethinking every service as something the app bundles and supervises itself rather than something a user installs separately. Getting several debating agents to coordinate without contradicting each other took an explicit shared-state layer too. Letting each agent hold its own private state instead is a common failure mode in naive multi-agent designs, and it shows up fast.

Lessons

Separating memory (what happened) from reasoning (what it means) made the agent swarm far easier to debug than one opaque model would ever have been. Shipping the actual product taught a second lesson: the gap between "runs on a developer's machine" and "installs cleanly on someone else's" comes down almost entirely to removing invisible assumptions, one at a time, until nothing's left unstated.

Future

Shipping the macOS build, extending the risk-management agent's coverage across more market conditions, and continuing rolling updates for everyone holding a license.

Pricing & Licensing

Trading Lab is sold as a finished, private, closed-source product. It isn't an open-source project, and it never will be.

• $495 for a single-seat retail license (one user, one machine at a time).
• Includes the current Windows installer, every continuous update released under the same major version, and the macOS build once it ships.
• The source code doesn't come with the license. You get the packaged application, not the dev repository.
• Licensed for personal or single-company use. It's not a redistribution or resale license.

Risk Disclaimer

Trading Lab is provided as-is, without warranty of any kind, express or implied, including fitness for a particular purpose or freedom from errors.

The system can execute real orders with real money on a connected exchange, using API keys the user supplies and controls. SharapovLab carries no liability for financial losses arising from use of this software. That includes, without limitation: errors in trading-strategy logic, outages or delays in third-party services (exchange, LLM providers, network infrastructure), losses from misconfiguration or how the user handles their own API keys, and any direct, indirect, incidental or consequential damages of any kind.

You configure your own trading agents, connect your own exchange and LLM API keys, and calibrate your own risk parameters through Strategy Lab. SharapovLab doesn't manage funds, doesn't provide investment advice, and nothing the system outputs, whether that's signals, agent reasoning or confidence scores, amounts to a recommendation to buy, sell or hold anything. Turning on live trading means confirming you understand and accept the risks of automated trading and won't risk capital you can't afford to lose. Paper mode is the default and needs no such confirmation; live trading requires an explicit opt-in every time.

GitHub

Private, closed-source product. There's no public repository. The application ships as a licensed installer, not as source code.

Demo

No public live demo. The shipped application includes a full paper-trading mode by default, so a license holder can put the system through its paces risk-free before flipping the switch on live execution.

FAQ