Road to $50,000

Fixed the “hidden trade” bug where high-profit targets (~17.5%) were ignored by active-trade tracking. Patched avg-entry logic to respect dynamic thresholds, so “home run” sells are never skipped.

Added a 3-stage accumulation guardrail. In Stage 3 (50–100%), the bot is forbidden to add unless price < avgEntry (rescue mode only).

Switched position-limit sizing from daily to hourly compounding. Added a 24h moving average “shock absorber” so sizing uses average equity, not the lowest dip.

Resolved chart/logic drift by writing the bot’s internal brain to bot_state_BOTNAME.json and making stats read that state for 100% accuracy.

Tried doubling size on high confidence (score > 80). In the crash, the AI flagged panic as opportunity and the bot doubled into a falling knife. Turbo was removed entirely.

Added a hard stop: if score is > 90, the bot halts trading (treats it as a panic regime, not a valid setup).

Raised the minimum accuracy threshold from 0.51 to 0.55 (26-week window). This freezes weak regimes (protect capital) while allowing strong regimes to continue.

Dual-head (Long/Short separate). Sizing: ~0.5% per trade ($10 min), max 5x leverage. Defense: freeze if recent accuracy < 55%. Goal: survival → funding/yield → $50k.

The model outputs three probabilities: up, down, neutral. They sum to ~1.0. The UI displays BUY/SELL/NEUTRAL and the split.

strength = score_up − score_down. It’s the confidence gap. Positive leans BUY; negative leans SELL. Small values mean weak edge.

Trading can be halted if recent accuracy drops below a floor (capital preservation).

RR bot applies limits and safety rules: avoids trading when the model is “too confident” (skips ≥ ~90), and scales take-profit based on volatility while keeping stop-loss bounded.

Hydra RR runs two independent executors (LONG and SHORT) against BTC-PERPETUAL. Each side reads the latest AI_scores row for model 36_combo, then decides whether to add a small unit, and continuously rebuilds stop-loss + take-profit orders.

Uses the most recent probabilities: score_up / score_stay / score_down + the current BTC price. The executor never “predicts” itself — it only consumes the model output.

A rolling volatility multiplier (derived from price range) scales take-profit for a subset of trades, capped to avoid absurd targets.

The bot periodically recalculates a global LIMIT_POSITION from recent equity history and derives a UNIT_SIZE as a small fraction of that limit (rounded to clean steps).

If the recent regime accuracy is below a floor, the engine halts (capital protection). This prevents “death by a thousand trades” during weak regimes.

Requires score > a threshold (per side). Also skips trading if the model is “too confident” (panic/regime-change guard).

Won’t grow past max position. After ~50% of the max size, it refuses to add if doing so would worsen average entry (rescue mode only: add only when price is favorable vs avg).

Enforces minimum time between adds and minimum % move from last trade / from average entry (scaled by volatility), so it doesn’t machine-gun trades in chop.

Rebuilds avg-entry from the subset of “still active” fills (ignoring fills that should’ve already TP’d), then writes that state to bot_state_BOTNAME.json. Stats readers use that file so UI + logs stay consistent.

Places a bounded stop around avg-entry (and can optionally “spread” stops across levels for large positions).

Uses a hybrid TP system: most trades follow a conservative harvest TP, while a small subset get a volatility-scaled TP (“home-run” allocator). This keeps the strategy stable while still capturing occasional larger moves.

The execution engine is replicable: database feed + a rules-based order placer + risk gates. The hard part is the model-signal pipeline: collecting custom features, iterating architectures, re-training, and evaluating across regimes — that’s the ~9 years of work this dashboard represents.