Most traders don’t lose only because their analysis is bad.

They lose because they enter too many low-quality setups.

I’ve been working on a simple AI-based market signal system where every trade setup gets ranked before considering an entry.

The goal is not to blindly follow signals.

The goal is to answer 3 simple questions before entering:

1. Is this setup actually strong?
2. How confident is the signal?
3. Is the risk worth taking?

Right now, the system gives every setup:

Signal Score out of 100
Trade Quality Grade
Confidence Level
Market Direction Bias

Example format:

Market: BTC/USDT

Signal Score: 84/100

Trade Grade: A

Confidence: High

Bias: Bullish

Risk Level: Medium

The idea is simple:

A setup with a score of 40–50 should probably be ignored.

A setup with 70+ may be worth watching.

A setup with 80+ may be a high-quality setup, but still needs proper risk management.

I’m not trying to build a “magic prediction bot.” I’m trying to build a filter that helps avoid emotional entries and low-quality trades.

Because in my experience, avoiding bad trades is just as important as finding good ones.

Would you personally use a scoring system like this before entering a trade?

Also, what factors would you include in the score?

For example:

Trend strength

Volume confirmation

Support/resistance zone

Volatility

Risk-reward ratio

News impact

Market sentiment

I’d appreciate honest feedback from traders, especially people who have tried signal bots or automated trading tools before.

’ve been looking into HNO Coin and think the energy-backed angle is interesting. If the project can demonstrate real-world utility, transparent backing, and steady adoption, it could be worth keeping an eye on.

I’m curious what others here think are the strongest fundamentals behind HNO right now — and what risks people are watching most closely.

This isn’t financial advice, just interested in hearing the community’s take.

**We built a trading bot. It's kind of a mess. Want to watch it fail together? 🤖📉**

Hey everyone!

So, me and my team have been deep into trading research for a while now, and a few days ago we finally crossed the line from "talking about it" to "actually shipping something" — we launched the very first version of our auto-trading bot.

It does scalping based on signals generated by our own algorithm, which we've been fine-tuning for quite some time. Sounds cool, right?

Well… here's the honest part: **it's version 0.1 and it shows.** The thing crashes regularly, sometimes for no obvious reason, occasionally ignores its own signals, and behaves in ways that make us question our life choices. It's basically a toddler with access to a brokerage account.

But hey — it's *our* toddler, and we're proud of it.

I wanted to start a little community around this journey. Not to sell anything (seriously, there's nothing to buy, please don't ask), not to flex results (lol, not yet anyway), but just to **share the ride** — the wins, the bugs, the 2am debugging sessions, the random moments where it actually does something smart and we all lose our minds.

If you're into algo trading, bots, or just enjoy watching a group of nerds struggle with their own creation in real time — come hang out. 🍿

Drop a comment, ask questions, roast our approach, whatever. We're just happy to have some company on this adventure.

More updates coming soon. Probably alongside another crash. 🔥

I really want to start day trading now, but I have heard all this fuss about backtesting a strategy, I have just finished reading some technical analysis’ videos and basics of markets and tried to frame a strategy,  now I want to put this to play by first backtesting my strategy  then demo trading and then after maybe a few months entering the live market. Pls enlighten me with the key things to keep in mind while backtesting and how not to  get confused while backtesting.  I can’t afford to pay for a backtesting software atp so I need suggestions for free alternatives also some free journals as well, all these YouTube traders keep mentioning journalling trades to be imp so they might be ig , trading view has a  very limited backtesting plan only so count that out please and please dont suggest some bs vibe coded websites aswell.

I’ve been a long-time lurker here (my stack is the usual suspects: Home Assistant, Nextcloud, and Nginx). About a year ago, I got frustrated with the state of automated trading tools. Most are "SaaS-first," requiring you to upload your sensitive API keys to their servers or pay $30/mo just to bridge a simple script to a broker.

I wanted something that followed the Self-Hosted Manifesto: local, private, and lightweight.

I built Tradleware. It’s an open-source middleware that sits between your scripts and your broker. It allows you to send simple Webhooks or API calls to your own server, which then executes the trades securely across various exchanges.

https://preview.redd.it/919679fjtu0h1.png?width=1488&format=png&auto=webp&s=bf36ba721a3c6274b9b04e17f99270584aa460ca

I’m looking for some "friendly-fire" feedback on the logic and the setup. If you’ve been looking to automate your trades without giving up your digital sovereignty, I’d love for you to give it a spin.

Project Site:https://tradleware.com
GitHub Repo:https://github.com/cslev/tradleware

A lot of people start algotrading by training an LSTM to predict the next bar's close. I did too, until I realized trading is a control problem, not a prediction problem. A supervised model predicting a price move with 53% accuracy can still lose money once you factor in fees, slippage, and path-dependent equity.
I recently finished a deep-dive on my autonomous trading architecture, which runs a single Recurrent Soft Actor-Critic (SAC) agent managing a portfolio of six Binance perpetuals (DOGE, BNB, SOL, XRP, ADA, LTC) from a shared equity pool.
Here are the biggest architectural shifts that made it work:
Portfolio Agent > Independent Agents: Six independent agents will demand 6x leverage when the whole market rallies. A single agent observing all six markets jointly (via a MultiheadAttention layer) emits a 13-way softmax over positions and cash. Cash competes for weight, forcing the agent to learn when to step aside.

Differential Sharpe Reward: Naive step-return rewards teach agents to take huge, volatile bets. Using differential Sharpe (a running EMA of risk-adjusted return) grades the agent on a curve. You don't get extra credit for a 3% day if your variance shoots up to make it.

Preventing Leakage in Walk-Forward: I use a 128-step purge gap between train and validation folds. If you have rolling lookback features (like realized\_vol\_72), the last training bar bleeds into the validation window without this gap.

Transformer vs LSTM: Used a 2-layer Transformer for the market encoder. It allows direct attention to any prior bar in the 96-bar window. To fit this on a single 15GB GPU, turning on gradient checkpointing was mandatory—saving \~24GB of peak memory at the cost of one extra forward pass.

Happy to answer any questions on the data pipeline or why stationary/fractionally differenced features are absolute lifesavers here.

Been building this thing solo since mid-2025. Not a course project. Not a weekend hack. An actual iterative research system running 24/7 on a repurposed HP workstation in my living room.

The short version: PPO + xLSTM policy, BTC/USDT 4h, Triple Barrier method, 35 curated features, walk-forward +

Deflated Sharpe as approval gate. Four agents in parallel paper trading right now.The long version: nasmu.net/research.log

---

What I actually learned (not the marketing version): v14 through v18 were a graveyard. RecurrentPPO + xLSTM = unstable gradients. DQN doesn't converge with sparse

Triple Barrier rewards. 73 features with some toxic ones = severe overfitting. Each version failed in a specific, instructive way. I kept notes.

The v20 breakthrough wasn't a clever algorithm. It was removing 13 toxic features via ablation and calibrating transaction costs correctly. My original TX_COST was 6× more pessimistic than real BTC 4h costs — the bot was scared of trading. Fixed that, Sharpe went from ~2 to 7.5.

The weirdest result: permutation importance showed the model didn't learn to predict price. It learned to measure ts own exposure to extreme risk. Top features are CVaR, distance to 52-week ATL, jump intensity. Not RSI. Not MACD. Extreme risk geometry.

---

The DualBot problem: NASMU sleeps between 4h candles. One day BTC went $71k → $73.7k in 45 minutes and the model hit 3 consecutive SL because it couldn't react. Classic intra-candle problem.

Solution: REAPER (15m specialist, LONG only, MlpPolicy) + Meta-Controller (5min loop, never sleeps). The switch logic has asymmetric gates — conservative entry (HMM + Bayesian + EMA all aligned), aggressive exit (Bayesian bear signal alone triggers close). Better to miss the end of a rally than eat a 15m reversal.

Getting the reward alignment right for REAPER took 7 iterations. The core issue: R_TP/R_SL ratio must equal TP_net/SL_net post-slippage, not pre. Financial break-even ≠ reward break-even by default.

---

Current state (honest):

Backtest WR: 68–72%. Paper WR: 20–35% across 10–14 trades per agent. That gap is the open question. Could be small sample (statistically almost nothing at 10–14 trades). Could be 2025

BTC regime being choppier than training distribution. Could be residual distribution shift in live features. Probably some of all three.

Go-live target is May 26 with $170. Criteria: WR ≥ 45%, MaxDD < 15%, Sharpe > 1.0, EV ≥ +0.30%. Not going live just because the backtest looks good.

---Stack for the curious:

- PPO (Stable-Baselines3) + custom xLSTM policy

- Rolling HMM walk-forward (eliminates look-ahead bias in regime detection)

- CUSUM entropy detector in production (catches policy collapse before it costs money)

- FinBERT × RSS + keyword scoring Reuters/CNN/CNBC → blended into macro_signal

- OFI (Order Flow Imbalance) WebSocket, Binance depth20 @ 100ms

- Xeon E5-1650 v2 + GTX 1070 — nothing exotic

Full version history, feature list, lessons learned, and live paper results at nasmu.net/research.log

[ Removed by Reddit on account of violating the content policy. ]

I've tested running an LLM-driven autoresearch loop on a quant-trading stack

Setup

Two-file pattern borrowed from Karpathy's autoresearch experiment:

• harness.py is read-only — data loader, scoring metric, constants.
• sweep.py is fair game — model and training loop.
• program.md tells the agent what to maximize and what's off-limits.

Agent picks a hypothesis, edits the modifiable file, runs the experiment, scores it, keeps or reverts, repeats.

Model

• 3-state HMM (Gaussian emissions) for regime detection.
• 3 GEM specialist models (bull / bear / ranging).
• Meta-allocator that soft-blends specialist portfolios when HMM confidence is below threshold.
• ~15 sweepable parameters per specialist.

Scoring

score = annualized_return × drawdown_dampener × diversification_bonus

Plus a hard rejection on annualized return < -50% or stress-test Calmar < 0 at 1.5× the base fee.

Run

• 437 tokens (431 from Binance + 6 from DefiLlama), 2020-2026 (included the 2022 bear), ~508K daily candles.
• Causal walk-forward backtest with 250-day warmup. No peeking past t-1 to decide at time t
• Phase 1: Optimize HMM hyperparameters.
• Phase 2: Optimize per-specialist GemParams, one specialist at a time.
• Then a verification grid.

Results

Score went from -inf (every baseline rejected under a realistic 30 bps round-trip + 1.5× stress) to 1175.2. BTC+ETH buy-and-hold scored 8.3 on the same metric.

Interesting findings

1. Soft-blend > hard-switch. Raising hard_switch_threshold from 0.80 to 0.90 (so the ensemble almost never commits to one regime) scored +25%. The HMM's regime calls are informative but not confident enough to act on as a binary classifier. Or the Gaussian emissions are an oversimplification .
2. All three specialists want lower R² thresholds than my priors said. Three independent sweeps, same direction of correction. Again, exponential model is probably to simplistic. Piecewise exponential over a rolling window might be an interesting future direction.
3. top_n=1 wins in bear regimes at scale. Confirms an earlier 4-token finding on a universe ~100× larger.

Known limitation

One-at-a-time phased sweeping can't find between-parameter interactions. I'm now thinking about it.

Links

• Full write-up: https://blog.nodrama.io/autoresearch-gem-strategy/
• Runnable repro (Python): https://github.com/fbielejec/trader-research