AI FX Bot Lab: Real Trading Experiments

Kimi | Japan FX Bot Lab

Can AI really trade forex? AI FX Bot Lab is a real-time experiment from Japan, where I build and test AI-assisted FX trading bots using MT5, Python, machine learning, and local LLM tools. I share live results, failures, risk lessons, and bot improvements from rule-based, AI-driven, and ML + LLM hybrid systems. Not financial advice. fxaibotlab.substack.com

  1. 7h ago

    Ten Wins Still Ended Negative: Five MT5 Bots Exposed an Exit Problem

    The five bots closed 13 trades on August 4 and won 10 of them. That sounds like a strong session, but the realized result was negative 16 yen after swap. The problem was not a lack of winning trades. It was the size and shape of the losses. The average winner was 62.6 yen, while the average loser was 208 yen, leaving the combined payoff ratio at only 0.30. BoundSniper Bot won four of five closed trades, yet one 263-yen loss and 18 yen of negative swap erased all four small wins. ML_ScoreAnalyst produced a 303-yen winner and a 304-yen loser, almost a perfect cancellation. I had to look at those two numbers twice. The MT5 reports also showed two positions still open at the end of the day. ML_ScoreAnalyst carried a 90-yen floating loss, and MAribbonTrader carried a 111-yen floating loss. The realized result was close to flat, but the risk had not disappeared. Bot-by-Bot Results ■ GateGrid AI +99 yenRecord: 2W / 0LWin rate: 100.0%Gross profit: +99 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yenOpen P/L: 0 yen ■ BoundSniper Bot -225 yenRecord: 4W / 1LWin rate: 80.0%Gross profit: +56 yenGross loss: -263 yenSwap: -18 yenPayoff ratio: 0.05Max loss: -263 yenOpen P/L: 0 yen ■ LLMBridgeTrader +61 yenRecord: 2W / 1LWin rate: 66.7%Gross profit: +118 yenGross loss: -57 yenPayoff ratio: 1.04Max loss: -57 yenOpen P/L: 0 yen ■ ML_ScoreAnalyst -1 yenRecord: 1W / 1LWin rate: 50.0%Gross profit: +303 yenGross loss: -304 yenPayoff ratio: 1.00Max loss: -304 yenOpen P/L: -90 yen ■ MAribbonTrader +50 yenRecord: 1W / 0LWin rate: 100.0%Gross profit: +50 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yenOpen P/L: -111 yen ■ Total -16 yenRecord: 10W / 3LWin rate: 76.9%Gross profit: +626 yenGross loss: -624 yenSwap: -18 yenPayoff ratio: 0.30Max loss: -304 yenOpen P/L: -201 yen The gross trading result before swap was positive by only 2 yen. Once the 18-yen swap was included, the realized result became negative 16 yen. Today’s Theme: A High Win Rate Can Hide Weak Exits The day was a clean example of why I do not want to rank these bots by win rate alone. Ten winners looked reassuring, but most of them were too small to absorb the three losing trades. This matters even more for bots that let an LLM decide whether to HOLD, CLOSE, or REVERSE. An entry can be reasonable and still become a poor trade if the model keeps defending the position for too long. The useful question is not only whether the model predicted the direction correctly, but whether it stopped believing its own thesis at the right moment. The MT5 report tells me when and where a trade was closed. It does not contain the full AI response, confidence score, chart interpretation, or exit reason. To evaluate the LLM layer properly, each deal now needs to be joined with the model log that produced OPEN, HOLD, CLOSE, REVERSE, WAIT, or EXIT. GateGrid AI: Clean Realized Result, but the Exit Reason Is Missing GateGrid AI finished with two winners worth 99 yen in total and no open position. Six earlier pending orders were canceled before two buy-stop orders were eventually filled, so the order-management layer did not simply leave old entries sitting in the market. The first position was opened at 14:44 and the second at 17:08. Both were closed by market orders around 17:12, producing 91 yen and 8 yen. Closing the two grid legs together left the account flat, which is the result I want to see from a strategy that manages positions as a group. Still, the report does not show whether the close came from trailing logic, a local Ollama decision, a grid-level target, or another rule. A profitable exit is welcome, but one two-trade sample does not tell me whether the exit manager is improving. The next step is to match the close timestamp with the CatBoost score, ATR state, session gate, Ollama response, and recorded exit trigger. BoundSniper Bot: Four Wins Could Not Repair One Old Loss BoundSniper Bot posted four winners after its first closing trade, but those wins were only 31, 8, 10, and 7 yen. Together they earned 56 yen. The earlier loss was 263 yen, with another 18 yen charged as swap. That single exit made the whole day negative 225 yen. Seeing a payoff ratio of 0.05 made me pause; the bot could repeat this exact 80% win rate and still lose money. BoundSniper itself does not predict the market. It receives TradingView signals through the webhook pipeline and executes them in MT5. The issue therefore appears less like an MT5 execution problem and more like an exit problem in the upstream TradingView strategy, or in the management of a position carried from the previous session. The losing position was closed at 01:02, while no corresponding same-day entry appears in the report. That suggests it was already open before August 4. I cannot determine from this report whether the exit was late, but the negative swap and oversized loss make the inherited-position logic worth reviewing. LLMBridgeTrader: The Most Balanced Exit Profile of the Day LLMBridgeTrader closed three EURUSD trades for a net gain of 61 yen. Its two winners totaled 118 yen, while its single loss was 57 yen, producing a payoff ratio of 1.04. The first short was closed by a stop order for a 93-yen profit. After that, two long positions were opened and closed within about 15 minutes, one for a 57-yen loss and one for a 25-yen gain. The loss was contained rather than allowed to grow into the largest loss of the session. This was the best balance between winning and losing size among the bots that recorded both outcomes. The numbers do not prove that the LLM made good discretionary decisions, though. The MT5 report does not reveal whether those exits were CLOSE responses, fixed safety rules, stop movement, or scheduled reevaluations. Because LLMBridgeTrader can choose OPEN, HOLD, CLOSE, and REVERSE, its real experiment is the change of mind. The valuable log is the moment when confidence weakens enough to replace HOLD with CLOSE. Today’s trade sizes look reasonable, but I still need the decision trace before giving the model credit. ML_ScoreAnalyst: One Winner, One Loser, and No Edge Left Over ML_ScoreAnalyst earned 303 yen on its first GBPJPY trade and lost 304 yen on the next. The realized result was negative 1 yen, almost a numerical draw, while a third long position remained open with a 90-yen floating loss. The 304-yen stop was the largest closed loss across the five bots. It canceled a trade that had been held for several hours and reached a similarly sized profit. Again, almost the same amount in both directions — not disastrous, but not much of an edge either. This bot uses CatBoost to score entries rather than an LLM to interpret chart context. Its entry model may still have selected valid breakout candidates, but the day shows that entry scoring alone cannot create positive expectancy when the exit distribution is symmetrical. The open third trade also means the day cannot be evaluated only from the negative 1-yen realized result. The next useful comparison is the entry score of the 303-yen winner, the 304-yen loser, and the still-open trade. If the scores were similar, the model may not be separating strong and weak setups yet. MAribbonTrader: A Good Protective Exit Followed by a Difficult Re-entry MAribbonTrader closed one GBPCAD long for a 50-yen gain. The position was exited through a stop above the entry price, which looks like a protective stop that had already locked in profit. About ten minutes later, the bot opened another long. That second position ended the reporting period with a 111-yen floating loss. The realized exit was good, but the immediate return to the same direction is the part I want to inspect. MAribbonTrader sends chart images, moving-average ribbons, higher-timeframe context, support and resistance information, ranges, and channel structure to Qwen. The model is supposed to distinguish a fresh setup from a chart that only resembles the previous one. The open question in the log is whether the second BUY came from genuinely renewed evidence or from a bullish interpretation that never really changed. The first trade shows that EXIT can protect profit. The second entry will test whether WAIT is strong enough after that exit. Closing The five bots did not have a bad day in the usual sense. Three finished with positive realized results, one was almost flat, and only BoundSniper Bot recorded a clear realized loss. Yet the fleet still finished negative because the losing trades were allowed to carry much more weight than most of the winners. A 76.9% win rate did not rescue a 0.30 payoff ratio. For the next review, I care less about adding another entry filter. I want the decision logs around the three losing exits, the BoundSniper position carried into the day, and MAribbonTrader’s quick re-entry. The bots are finding winners. I am not convinced they all know when their idea has expired. ② Substack Note Five MT5 bots closed 13 trades on August 4. The record was 10 wins and 3 losses, but the realized result was still -16 yen. BoundSniper won four times, yet one larger loss erased them. ML_ScoreAnalyst made +303 yen and then lost 304 yen. The fleet’s win rate was 76.9%. Its payoff ratio was only 0.30. The entries were not the main problem today. The exits were. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

    Ten Wins Still Ended Negative: Five MT5 Bots Exposed an Exit Problem
  2. 4d ago

    [AI Trading Log] Exits Made the Difference: Five-Bot Portfolio Covers Each Other’s Weaknesses (July 30 to July 31)

    Hello! I have been running a parallel test of five distinct MT5 automated trading bots to evaluate their real-world behaviors. For the two days of July 30 and 31, the bots successfully covered each other’s weaknesses, resulting in two consecutive days of positive returns. However, looking closely at the data reveals a stark contrast between successful exits and remaining challenges. July 30 Overall Performance: GateGrid AI Dominates with Tiny Losses On July 30, the portfolio finished with a total profit of 592 yen. The star of the day was GateGrid AI. Alongside a high win rate of 12 wins and 2 losses, the combined losses of the two losing trades were kept to a mere 9 yen, with a maximum loss of 7 yen. With an average win of 68.5 yen and an average loss of 4.5 yen, it achieved an incredible payoff ratio of 15.22, earning 813 yen on its own. Meanwhile, ML_ScoreAnalyst closed a carried position from the previous day for a 215 yen loss, but GateGrid AI’s profits completely covered it. This day proved the strength of admitting defeat quickly and cutting losses. July 31 Overall Performance: Saved by Two Take-Profits Amidst Recurring Exit Issues On July 31, the portfolio managed a narrow positive finish of 189 yen. However, the leading bots completely swapped. ML_ScoreAnalyst successfully executed two clean take-profits to earn 593 yen, and BoundSniper Bot added 405 yen through a run of short entries. Their profits were absolutely necessary because yesterday’s hero, GateGrid AI, recorded a massive loss of 843 yen. During a multiple-position unwinding process, GateGrid AI allowed a large loss, dragging down the overall performance. Without ML_ScoreAnalyst, the day would have ended at minus 404 yen. Bot-by-Bot Analysis 1. GateGrid AI While it can keep losses extremely small as seen on July 30, it still has a weakness of realizing large losses, such as a 451 yen loss on July 31, when unwinding multiple positions. Since its entry accuracy is not bad, the decision-making process for transitioning from holding to closing is the primary challenge. 2. BoundSniper Bot It had no submitted trades on July 30, but made a 405 yen profit with a 68.8 percent win rate on July 31. However, it also took a 399 yen loss in just 43 seconds. The structure of stacking small wins only to be heavily reduced by a single loss still exists, suggesting the need for an independent emergency loss limit rule as an execution relay. 3. ML_ScoreAnalyst It saved the entire portfolio on July 31 with two clean take-profits totaling 593 yen. Because its targets are clearly defined, its results are very easy to audit. However, as seen with the 215 yen loss on July 30 from a carried position, it is still necessary to accumulate more data on its losing patterns. 4. LLMBridgeTrader It had no submitted trades on July 30. On July 31, it recorded 1 win and 1 loss for a 34 yen profit. It demonstrated a smart move by shifting the stop loss above the entry price to protect the gains of a profitable position. 5. MAribbonTrader It had no realized profits on either day, only recording a minor 6 yen loss in about 14 minutes on July 30. Although it is a highly discretionary bot, it deserves credit for keeping the loss small and exiting early. Summary: Diversification Effects and Remaining Exit Challenges Over these two days, the portfolio’s diversification effect worked beautifully, with bots covering for each other’s poor performances to secure consecutive winning days. However, the overall payoff ratio on July 31 remained at 0.65, meaning the fundamental risk of average losses exceeding average wins is still unresolved. The success of automated trading depends not on the entries, but on exit discipline—how cheaply the system can admit defeat. I will continue to verify the systems by focusing on the exit data. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

    [AI Trading Log] Exits Made the Difference: Five-Bot Portfolio Covers Each Other’s Weaknesses (July 30 to July 31)
  3. 6d ago

    [AI Trading Log] Surviving FOMC and the Trap of High Win Rates:

    Hello! I have been running a parallel test of five distinct MT5 automated trading bots to evaluate their real-world behaviors and AI decision-making processes. July 28 and 29 provided incredibly insightful data for the portfolio. On July 29, I deliberately left all five bots running through the highly volatile FOMC event instead of shutting them down. The data from these two days delivered a harsh reality check: Event risks like the FOMC do not blow up accounts; ordinary, poorly designed exits and payoff asymmetry are what truly destroy a portfolio. Overall Performance: A 64 percent Win Rate Cannot Outrun Bad Exits Looking purely at the win rates, the portfolio seemed highly capable of predicting market direction. However, both days resulted in net realized losses. July 28: Total minus 64 JPY (Win Rate 63.6 percent) The fleet closed 7 winning trades and 4 losing trades, ending the day with a realized loss of 64 JPY. The root cause was glaringly obvious: the average winner brought in about 80.4 JPY, while the average loser wiped out 156.8 JPY. The AI successfully called the direction, but it paid far too much when those ideas were wrong. July 29 (FOMC): Total minus 333 JPY (Win Rate 64.3 percent) Despite the FOMC volatility, the damage remained contained with no single closed trade losing more than 314 JPY. The portfolio achieved 18 wins and 10 losses, yet the payoff ratio was a dismal 0.45. The average winner was about 78 JPY, while the average loser reached roughly 174 JPY. FOMC did not create an uncontrolled failure; it was the ordinary exit asymmetry that did most of the damage. Bot-by-Bot Breakdown: Different Brains, Same Exit Struggles Because each bot processes information and makes decisions differently, their results and failure points varied drastically. 1. BoundSniper Bot: The Disciplined Execution Layer This bot relays TradingView signals into MT5 and does not predict the market itself. It had no trades on July 28. On July 29, it was the undisputed MVP of the FOMC session, closing 7 wins and 1 loss for a profit of 284 JPY. It posted an incredible payoff ratio of 3.52, proving that fast, externally defined exits can keep risk incredibly small, even during severe market events. 2. LLMBridgeTrader: The AI Planner’s Hesitation This AI operates with high autonomy, deciding whether to OPEN, HOLD, CLOSE, or REVERSE a position. On July 28, it closed flat at 0 JPY realized, though it carried an unrealized loss. On July 29, it secured a 105 JPY profit. It successfully protected several winners through stop-based exits, but it also hesitated on holding positions, resulting in late exits and large losses like a 295 JPY loss on July 28 and a 199 JPY loss on July 29. 3. GateGrid AI: Small Wins Swallowed by Heavy Exits This hybrid bot uses a CatBoost probability gate and an Ollama review to filter entries. It fell victim to the classic “small win, massive loss” trap. On July 28, it lost 65 JPY, as four wins were wiped out by a single 252 JPY loss. On July 29, it lost 259 JPY with a terrible 0.42 payoff ratio. It proved that entry filtering alone cannot repair a fundamentally flawed exit profile. 4. ML_ScoreAnalyst: Improving Risk-to-Reward Balance This fast bot evaluates confirmed GBPJPY breakouts using a CatBoost score. It had no trades on July 28. On July 29, it lost 69 JPY. Among the losing bots, it came the closest to a balanced risk-to-reward profile with a payoff ratio of 0.88, though its stops were still slightly heavier than its target profits. 5. MAribbonTrader: Rich Context, Weakest Payoffs A chart-reading AI that sends MT5 screenshots and rich visual context to a local LLM for discretionary analysis. It won 1 JPY on July 28. On July 29, it lost 394 JPY. Despite receiving the richest visual context of all five bots, it exposed the weakest payoff structure at 0.12. A 60 percent win rate was useless when the average winner of 30 JPY was forced to absorb an average loss of 242 JPY. It highlighted that giving an AI more information does not automatically produce a better exit. Conclusion: The Flaw is Inside the System, Not the Event The ultimate takeaway from these two days is that the systems were not defeated by a lack of winning trades or by market events. They were defeated by the massive distance between their normal profits and normal losses. The most critical part of an experimental trading model is the brief window of time between the setup weakening and the actual closure of the position. Moving forward, the primary focus must shift away from entry accuracy and prioritize strict exit discipline, ensuring the AI learns how to quickly and cheaply abandon bad ideas. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

    [AI Trading Log] Surviving FOMC and the Trap of High Win Rates:
  4. Jul 27

    The Exit Layer Won: Five MT5 Bots Closed at +¥624

    Conclusion The five-bot portfolio finished the session with a realized gain of ¥624. Three bots were positive, one did not trade, and LLMBridgeTrader closed four positions without a single win. The -¥195 stop on its first trade made me pause. The later losses shrank to -¥80, -¥16, and -¥5, so the bot did become quicker about getting out, but it never found a profitable exit during the reporting window. That makes this less of an entry contest and more of a test of when each system gives up on its original idea. MAribbonTrader also needs a closer look despite ending positive. Its +¥316 closing trade appears to have come from a position carried into the day, and the three positions opened and closed on July 27 produced a combined -¥89 before swap. The account made money, but the fresh setups did not. Win rate below includes the zero-yen GateGrid AI closure in the total number of closed trades. Gross profit, gross loss, and payoff ratio exclude swap. Bot-by-bot results ■ GateGrid AI +384 yen Market: EURUSD- Record: 5W / 0L / 1 flat Win rate: 83.3% Gross profit: +384 yen Gross loss: 0 yen Payoff ratio: N/A, no losing trade Max loss: 0 yen ■ BoundSniper Bot 0 yen Trades: None reported Record: N/A Win rate: N/A Gross profit: 0 yen Gross loss: 0 yen Payoff ratio: N/A Max loss: N/A ■ LLMBridgeTrader -296 yen Market: EURUSD- Record: 0W / 4L Win rate: 0.0% Gross profit: 0 yen Gross loss: -296 yen Payoff ratio: N/A, no winning trade Max loss: -195 yen Unrealized P/L at cutoff: -16 yen ■ ML_ScoreAnalyst +300 yen Market: GBPJPY- Record: 1W / 0L Win rate: 100.0% Gross profit: +300 yen Gross loss: 0 yen Payoff ratio: N/A, no losing trade Max loss: 0 yen ■ MAribbonTrader +236 yen Market: GBPCAD- Record: 2W / 2L Win rate: 50.0% Gross profit: +505 yen Gross loss: -278 yen Payoff ratio: 1.82 Max loss: -154 yen Swap: +9 yen ■ Total +624 yen Record: 8W / 6L / 1 flat Win rate: 53.3% Gross profit: +1,189 yen Gross loss: -574 yen Payoff ratio: 1.55 Max loss: -195 yen Swap: +9 yen Unrealized P/L at cutoff: -16 yen Today’s theme: the MT5 report knows what happened, but not why The execution report gives a clear sequence of entries, exits, stops, and take-profits. What it does not contain is the model context behind those actions: confidence, setup type, HOLD or CLOSE reasoning, chart state, or the inputs shown to the LLM. That gap matters most for LLMBridgeTrader. Its design allows the model to choose OPEN, HOLD, CLOSE, and REVERSE while also proposing SL and TP distances. Looking only at the MT5 result, I cannot tell whether the -¥80 market exit was a sensible early escape from a broken setup or a late reaction after the model ignored an earlier warning. The same issue exists in MAribbonTrader. The trading report shows the outcome, but not whether Qwen saw a first pullback to the long-term ribbon, a resistance retest, a narrowing channel, or a reason to switch from HOLD to EXIT. Without that join, a winning trade can look smarter than it was, and a losing trade can look worse than the decision that produced it. GateGrid AI GateGrid AI had the cleanest realized record of the day. It closed six short positions for five gains and one flat result, with no losing exit and no open exposure at the cutoff. The closures came in groups. Two positions were closed around 14:30 for +¥92 and ¥0, while another pair was closed around 16:58 for +¥110 and +¥21. That looks like basket-level management rather than demanding that every grid layer reach an individual target, and it worked well in this session. There is one configuration detail worth checking. The bot overview describes GateGrid AI as a GBPUSD system, but this live report records EURUSD- orders. The analysis here follows the actual account report, though the symbol difference should be confirmed before comparing the result with model thresholds or training data. A payoff ratio cannot be calculated because there was no losing trade. That is a pleasant problem for one day, but six closures are not enough to judge the grid’s real downside. Its max-loss behavior remains untested in this sample. BoundSniper Bot No BoundSniper transaction details were included, so it is recorded as no trade. For a bridge bot, inactivity is not automatically a problem; it may simply mean TradingView sent no qualifying signal. Still, its logs should distinguish between “no alert received,” “alert rejected,” and “order submission failed.” All three create an empty MT5 report, but they describe very different system states. LLMBridgeTrader LLMBridgeTrader was the weak point of the portfolio. Four completed EURUSD- trades lost -¥195, -¥80, -¥16, and -¥5, producing a 0% win rate and the day’s largest single loss. The sequence is not entirely negative from a risk perspective. After the first stop, each completed loss became smaller, which may indicate that later CLOSE decisions reacted faster. I would not claim that from execution data alone, though; the market may simply have moved less. The first buy was closed by a stop at -¥195. Two later buys were closed at market for -¥80 and -¥16, followed by a sell closed at -¥5. A new short was then opened at 23:00 and remained open with -¥16 of unrealized loss at the report cutoff. For a bot with broad LLM discretion, the next useful comparison is not just BUY versus SELL accuracy. Each losing trade should be joined to the model’s confidence, setup label, original SL and TP proposal, every HOLD decision, and the final reason for CLOSE. The exit model is where the evidence is missing. ML_ScoreAnalyst ML_ScoreAnalyst took one GBPJPY- short and reached its take-profit for +¥300. It was a simple result: one scored entry, one predefined target, and no further exposure. The fixed exit beat the adaptive LLM exits today, but the sample size is one. I would not promote the score threshold or TP setting on this result alone. What it does provide is a useful control case for the more flexible bots: a narrow decision system can be easier to evaluate because the path from signal to result is short. MAribbonTrader MAribbonTrader recorded two wins and two losses, with a payoff ratio of 1.82. That is the strongest measurable payoff ratio among the five bots, since the other profitable systems had no losing trades from which to calculate one. The +¥316 close appears without a corresponding same-day entry and also earned +¥9 in swap, so it was probably a position carried into July 27. After that, the bot closed a fresh long for +¥189, then lost -¥154 and -¥124 on two more longs. Those three same-day round trips netted -¥89. This split matters. The account-level result was +¥236, but the new setups had a difficult day. The -¥154 stop caught my eye because it arrived shortly after the profitable TP, followed almost immediately by another entry and another stop. That may be a re-entry filter problem, a ribbon-state problem, or just a bad patch of GBPCAD movement. The MT5 report cannot settle it. The MAribbon logs should make it possible to check whether the two losing entries shared the same chart context. I would look first at long-term ribbon direction, distance to resistance, whether the move was still an impulse or already a correction, and why the second long was allowed only about ninety seconds after the previous stop. Summary The portfolio’s realized result was positive, but the most useful output from the day is not the ¥624. It is the contrast between systems whose exits were explicit and systems whose exits depended on changing model judgment. The next improvement may not be a new prompt or another indicator. A shared trade ID connecting every LLM response, chart snapshot, position action, and MT5 execution would make the losses far more valuable. Right now the numbers are clear, while the decisions that created them are still partly hidden. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

    The Exit Layer Won: Five MT5 Bots Closed at +¥624
  5. Jul 25

    Winning 57% Wasn’t Enough: GateGrid’s Exit Math Sank the Five-Bot Day

    The conclusion July 24 was not mainly an entry problem. It was an exit problem. The five-bot portfolio ended the day at -¥461 in realized P/L. GateGrid AI won four of its seven closed trades, giving it a 57.1% win rate, but the payoff ratio was only 0.28. Its winners averaged ¥53, while its losers averaged about ¥189. The final -¥296 loss made me stop for a moment; several small wins had done almost nothing to prepare the account for that exit. LLMBridgeTrader also finished negative, but its loss structure looked different. It lost two of three closed trades, yet its payoff ratio was 0.96 and the final loss was cut at just -¥11. That does not make the day good, but it suggests that the position-management layer was at least willing to abandon a weak idea. BoundSniper Bot and ML_ScoreAnalyst recorded no closed trades. MAribbonTrader opened one GBPCAD position, which remained open with an unrealized loss of ¥17 at the report cutoff. Bot-by-bot results ■ GateGrid AI -356 yenRecord: 4W / 3LWin rate: 57.1%Gross profit: +212 yenGross loss: -568 yenPayoff ratio: 0.28Max loss: -296 yen ■ LLMBridgeTrader -105 yenRecord: 1W / 2LWin rate: 33.3%Gross profit: +97 yenGross loss: -202 yenPayoff ratio: 0.96Max loss: -191 yenSwap included: +6 yen ■ BoundSniper Bot 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen ■ ML_ScoreAnalyst 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen ■ MAribbonTrader 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax realized loss: 0 yenOpen positions: 1Unrealized P/L: -17 yen ■ Total -461 yenRecord: 5W / 5LWin rate: 50.0%Gross profit: +309 yenGross loss: -770 yenPayoff ratio: 0.40Max loss: -296 yenUnrealized P/L excluded: -17 yen Today’s theme: the model can choose an entry, but the exit decides the damage These five bots do not make decisions in the same way. BoundSniper Bot does not predict the market at all. It receives TradingView signals through a webhook and delivers them to MT5. ML_ScoreAnalyst uses a CatBoost score to filter GBPJPY breakout candidates. GateGrid AI is designed as a multi-stage system, using a quantitative gate before asking a local LLM to evaluate volatility, trend, session conditions and grid settings. LLMBridgeTrader gives the AI more freedom. It can propose BUY, SELL or NONE, but it can also choose OPEN, HOLD, CLOSE or REVERSE. It produces confidence, setup type, stop distance, profit target and reasons for entering or exiting. MAribbonTrader goes further into discretionary territory by asking Qwen to read a chart image containing moving-average ribbons, higher-timeframe context, support and resistance, range boxes and channel information. That makes the exit question especially important. An LLM can produce a convincing reason to remain in a position. It can also produce a convincing reason to close it. Only the realized trade tells us whether that flexibility protected the account or merely delayed the loss. The broker statement gives us the actions and outcomes, but not the bots’ internal decision logs. We can see when a position was opened and closed, yet we cannot verify the confidence score, setup classification or written exit reason that led to each action. That missing link matters. The next review should compare the model’s stated reason with the eventual P/L, rather than judging the model only from the broker report. GateGrid AI: the win rate hid an expensive loss structure GateGrid AI closed seven trades on EURUSD during the day. The design memo describes the bot as a GBPUSD system, so either the live configuration has changed or the running instance differs from the documented setup. It is worth recording that configuration change because symbol selection can alter volatility, spread and grid behavior. The first closed position lost ¥67. Two later long positions produced gains of ¥102 and ¥7. Another pair of short positions returned ¥98 and ¥5. At that stage, the sequence probably felt under control. The final two shorts changed the entire result. They were closed together for losses of ¥205 and ¥296. This is the weak point in the day’s result. Four winning trades produced only ¥212 in total, while three losing trades removed ¥568. The bot did not need a higher win rate. It needed either smaller losing exits or more room for the profitable layers to run. GateGrid uses filters before entry, including CatBoost probabilities, session thresholds, ATR conditions and a local Ollama judgment. Those filters may have done their job by selecting several trades that moved in the expected direction. The account still lost because the exit distribution was asymmetric in the wrong direction. The most useful log review is not simply “Why did the bot sell?” It is “Why were the last two positions still being held when their combined loss passed the total value of all four winners?” The answer is probably in the grid-closing or continuation logic, though the broker statement alone cannot prove it. LLMBridgeTrader: a losing day, but a more balanced exit profile LLMBridgeTrader closed three positions for a net realized result of -¥105. The first was a carried position that closed for -¥197 in trading P/L, partly offset by +¥6 in swap. The net loss was therefore ¥191. A new short was then opened at 10:30 and closed eight minutes later for a ¥97 gain. In the afternoon, a long position was opened and abandoned about fourteen minutes later for an ¥11 loss. That last exit is small, but it matters. I saw the -¥11 and thought this is at least the kind of failed idea the account can absorb. The bot’s win rate was only 33.3%, yet its payoff ratio reached 0.96. Average profit and average loss were nearly balanced, unlike GateGrid’s 0.28 ratio. The larger carried loss still dominated the day, but the newer intraday decisions did not show the same pattern of taking tiny gains while tolerating oversized losses. Because LLMBridgeTrader can return HOLD, CLOSE or REVERSE, its quality cannot be measured only at entry. The model must recognize when the original premise has weakened and switch from explanation mode to exit mode. The quick closure of the final long suggests that this transition happened, although the internal reason log is needed before calling it a repeatable improvement. The question for this bot is not whether the AI can describe a good setup. It is whether its confidence falls quickly enough when reality stops matching that description. BoundSniper Bot: no result to judge BoundSniper Bot recorded no closed trades in the supplied report. That is not automatically a weakness. This bot is an execution bridge rather than a market forecaster. Its performance depends on whether TradingView produced a signal and whether the webhook, tunnel and MT5 execution chain delivered it correctly. With no trades, there is no payoff ratio or exit behavior to evaluate. The useful checks are operational: whether alerts were generated, whether webhook events arrived, whether any orders were rejected and whether the absence of trades was intentional. ML_ScoreAnalyst: the filter stayed inactive ML_ScoreAnalyst also recorded no trades. The system uses CatBoost to score GBPJPY breakout candidates and enters only when the score exceeds its threshold. A no-trade day may mean that no valid candidate appeared, or that candidates remained below the entry threshold. The broker statement cannot distinguish between those possibilities. The score log should show whether the bot spent the day returning NONE or actively rejecting low-scoring setups. Both lead to zero trades, but they say different things about the model. MAribbonTrader: the exit test is still open MAribbonTrader opened one 0.01-lot GBPCAD buy at 1.87744. At the report cutoff, the market price was 1.87729 and the position showed an unrealized loss of ¥17. The trade had a stop at 1.87433 and a target at 1.88175. It had not reached either level, so there is no closed result to score. Its realized P/L remains zero. This is the bot where the exit question may be most revealing. Qwen is being asked to interpret moving-average ribbons, higher-timeframe context, support and resistance, range conditions and channel structure. A chart-reading model can decide that a setup remains visually valid even while the position drifts against it. The next log should show whether the model continues to return HOLD, switches to EXIT before the stop, or lets the original risk plan play out. None of those choices is automatically correct. The value lies in whether the decision is consistent with the reason given at entry. Closing thoughts A 50% portfolio win rate sounds neutral. A 0.40 payoff ratio is not neutral. July 24 showed how easily a few modest winners can create the feeling that a system is working while one exit sequence does most of the financial damage. GateGrid’s filters may have selected acceptable entries, and LLMBridge may have produced sensible short-term reactions, but the account was still governed by the size of the losing exits. The next improvement should not be another entry filter added on top of the existing ones. I would first connect every CLOSE, HOLD and forced stop to the model’s recorded reason. A bot that can explain why it entered is interesting. A bot that notices when its own explanation has expired is useful. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

    Winning 57% Wasn’t Enough: GateGrid’s Exit Math Sank the Five-Bot Day
  6. Jul 24

    Stops That Paid: Two AI Bots Banked ¥599 and Carried the Five-Bot Run

    Conclusion July 23 ended with a realized profit of ¥574 across the five-bot lineup. Only three bots had closed trades in the supplied account statements, but two of them did enough: LLMBridgeTrader earned ¥398 and MAribbonTrader added ¥201, while GateGrid AI finished slightly negative at ¥25. What caught my attention was not just the total. Several exits marked as stop-loss orders still closed in profit. That suggests the protective exit layer was doing more than limiting damage; it was also preserving gains after the market had already moved in the bot’s favor. LLMBridgeTrader still held one EURUSD- short position at the end of the report with an unrealized loss of ¥38. That floating result is not included in the ¥574 realized total. Bot Performance ■ LLMBridgeTrader +398 yenRecord: 4W / 1LWin rate: 80.0%Gross profit: +644 yenGross loss: -246 yenPayoff ratio: 0.65Max loss: -246 yen ■ MAribbonTrader +201 yenRecord: 2W / 0LWin rate: 100.0%Gross profit: +201 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen ■ GateGrid AI -25 yenRecord: 8W / 3LWin rate: 72.7%Gross profit: +358 yenGross loss: -383 yenPayoff ratio: 0.35Max loss: -197 yen ■ BoundSniper Bot ±0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: N/A ■ ML_ScoreAnalyst ±0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: N/A ■ Total +574 yenRecord: 14W / 4LWin rate: 77.8%Gross profit: +1,203 yenGross loss: -629 yenPayoff ratio: 0.55Max loss: -246 yen Today’s Theme: A Stop Is Not Always a Losing Exit The account statement contains a useful detail. Four profitable LLMBridgeTrader exits were recorded with stop-related comments, and MAribbonTrader also closed its second trade through a stop-tagged order while still banking ¥41. That ¥41 exit looked modest, but I liked it. A stop that closes above the original entry is no longer just an emergency brake. It becomes a mechanism for turning open profit into realized profit before the market has time to take it back. The exact model reasoning is not included in the broker statement, so I cannot tell whether each stop adjustment came directly from the LLM, a trailing rule, or another risk-management layer. The execution result is clear, though: the profitable bots were able to leave the market with money still on the table. LLMBridgeTrader: Four Winning Exits Absorbed One Full Loss LLMBridgeTrader produced five completed EURUSD- trades: +¥261, +¥88, +¥131, -¥246, and +¥164. Seeing +¥398 from only five closed positions was the first number that made me pause. The bot’s design gives the AI a wide decision space. It can propose BUY, SELL, or NONE, select OPEN, HOLD, CLOSE, or REVERSE, and return confidence, setup type, stop distance, target distance, and reasons for entry or exit. Risk checks then decide whether that plan is acceptable. The day was not flawless. Its single ¥246 loss was also the largest loss across all five bots, and the payoff ratio was only 0.65. The average winning trade was smaller than the losing trade, so the result depended on maintaining a high hit rate. Still, the sequence recovered well. Three early winners built ¥480, the loss removed ¥246, and the following ¥164 winner restored the daily result to ¥398. The exit process did not freeze after taking a hit, which matters for a system allowed to reassess positions through an LLM. MAribbonTrader: Two Shorts, Two Profitable Closures MAribbonTrader completed two GBPCAD- short trades and won both. The first reached a take-profit exit for ¥160, while the second closed through a stop-tagged order for another ¥41. This bot gives Qwen a chart image containing the short- and long-term MA ribbons, higher-timeframe context, support and resistance areas, range boxes, crossings, and channel information. The model then returns WAIT, BUY, SELL, or EXIT together with its reasoning. Two trades are far too few to prove an edge, and the payoff ratio cannot be calculated because there were no losing trades. Even so, this is the kind of small sample I would rather see: limited activity, no forced entry, and profit retained on both positions. The second trade is the more interesting one for the experiment. It did not need to reach its original target to contribute. The exit layer found a way to close positively, although the broker report alone does not reveal whether that came from the visual model’s judgment or a mechanical stop update. GateGrid AI: Gross Profit Was There, but the Exit Leakage Was Larger GateGrid AI won eight of eleven closed trades and generated ¥358 in gross profit. On win rate alone, the day looked healthy. The problem was that three losses totaled ¥383, leaving the bot down ¥25. The ¥197 loss was the one that bothered me. With an average win of only ¥44.75 and an average loss of roughly ¥127.67, the payoff ratio fell to 0.35. The bot needed almost three average winners to recover one average loss. Before the last two exits, GateGrid AI was ahead by ¥161. The final two closures lost ¥43 and ¥143, removing ¥186 and turning a profitable session into a small negative one. Its entry filters found enough favorable movement to create real gross profit, but the closing sequence gave slightly more back. GateGrid AI uses CatBoost as a quantitative gate before passing selected situations to Ollama. The local LLM then considers items such as spread, ATR, higher-timeframe trends, session, grid width, and recent performance. The broker statement does not contain the AI_SKIP, OLLAMA_HOLD, or decision-reason logs, so this report can evaluate the trade outcomes but not the exact rationale behind each entry. There is also a logging detail worth checking. The system description identifies GateGrid AI as a GBPUSD strategy, while the supplied account statement shows EURUSD-. For this article, I have followed the live account statement. BoundSniper Bot and ML_ScoreAnalyst No closed trades from BoundSniper Bot or ML_ScoreAnalyst appeared in the supplied statements. I have therefore recorded both as flat for this daily comparison rather than assuming anything about their broader operational status. BoundSniper is primarily an execution bridge. It carries TradingView signals through a webhook and local server into MT5, so its value is measured not only by strategy profit but also by execution accuracy, logging, and the absence of missed or duplicated orders. ML_ScoreAnalyst uses a CatBoost score to filter GBPJPY breakout candidates. Since there were no trades to evaluate, the useful evidence for this day would be its skipped signals and score distribution, but those logs were not included in the account report. Summary The profitable side of July 23 came from two different AI designs. LLMBridgeTrader used a broad trade-planning framework and recovered after one large loss, while MAribbonTrader took only two positions and kept both positive. GateGrid AI also found profitable moves, but its gross profit did not survive the full exit sequence. That contrast is useful. Entry quality created the opportunity, but the bots that finished ahead were the ones that converted open movement into closed profit. The next step is to connect each broker-side exit with its model output, confidence, decision reason, and stop update history. I do not just want to know which bot made money. I want to know whether the way it kept that money can be reproduced. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

    Stops That Paid: Two AI Bots Banked ¥599 and Carried the Five-Bot Run
  7. Jul 22

    Four Wins, Two Losses, Still Down: The Exit Math Beat the Hit Rate

    The five-bot run finished at **-221 yen**, even though the closed trades produced four wins and only two losses. The combined win rate was 66.7%, but the payoff ratio was just 0.27. That gap tells the story better than the hit rate does. GateGrid AI posted the largest loss at -351 yen. MAribbonTrader won two of its three trades, yet one -125 yen stop erased the +101 yen collected from the first two. LLMBridgeTrader showed the opposite pattern: its EURUSD short was closed through a stop mechanism after moving into profit, leaving +130 yen behind. The entries mattered, but the day was decided by how each bot stopped holding. Bot-by-Bot Results ■ GateGrid AI -351 yen Record: 0W / 1L Win rate: 0.0% Gross profit: 0 yen Gross loss: -351 yen Payoff ratio: N/A Max loss: -351 yen ■ BoundSniper Bot +24 yen Record: 1W / 0L Win rate: 100.0% Gross profit: +24 yen Gross loss: 0 yen Payoff ratio: N/A Max loss: 0 yen ■ LLMBridgeTrader +130 yen Record: 1W / 0L Win rate: 100.0% Gross profit: +130 yen Gross loss: 0 yen Payoff ratio: N/A Max loss: 0 yen ■ ML_ScoreAnalyst 0 yen Record: 0W / 0L Win rate: N/A Gross profit: 0 yen Gross loss: 0 yen Payoff ratio: N/A Max loss: 0 yen Note: No daily trade report was supplied. ■ MAribbonTrader -24 yen Record: 2W / 1L Win rate: 66.7% Gross profit: +101 yen Gross loss: -125 yen Payoff ratio: 0.40 Max loss: -125 yen ■ Total -221 yen Record: 4W / 2L Win rate: 66.7% Gross profit: +255 yen Gross loss: -476 yen Payoff ratio: 0.27 Max loss: -351 yen ## Today’s Theme: The Moment a Bot Stops Holding A win rate can describe how often a decision worked, but it cannot explain how much damage was done when it failed. July 22 made that distinction hard to ignore. Four winning trades averaged 63.75 yen, while the two losses averaged 238 yen. For the LLM-driven bots, the interesting question is not only whether the model selected the correct direction. It is whether the bot knew when the original idea had weakened enough to close, trail, or reverse. An entry model can be slightly wrong and survive. An exit process that stays passive for too long can turn one mistake into the entire day’s result. GateGrid AI GateGrid AI opened an EURUSD short at 1.13997 and closed it at 1.14212 roughly twelve hours later. The result was -351 yen, the largest single loss of the day. I paused at that number because it outweighed every profitable trade from the other bots combined. The design notes describe GateGrid AI as a multi-stage system using CatBoost, local LLM judgment, volatility checks, time filters, and trailing management. The daily broker report alone does not reveal which gate approved this entry or why the position remained open. It also shows EURUSD, while the intended configuration describes GBPUSD, so the live symbol setting deserves a separate check. The immediate issue is the exit path. A filtered entry is useful only if the system can recognize when the approved setup is no longer valid. The next review should match the broker timestamps against the CatBoost score, Ollama response, ATR state, trailing-stop updates, and any hold decision recorded during the position. BoundSniper Bot BoundSniper entered a USDJPY long at 163.067 and closed it one minute later at 163.091 for +24 yen. It was a small trade, but the execution chain appears clean: the TradingView instruction reached MT5, the position opened, and the exit followed without a visible operational error. This bot does not predict the market itself, so its result should not be judged like an LLM strategy. Its job is faithful delivery. The useful questions are whether the correct signal was received, whether latency or spread altered the intended price, and whether the exit command was executed once without duplication. There is no meaningful payoff ratio from one winning trade and no losing sample. Still, the trade did what an execution bridge is supposed to do, which matters more than trying to turn +24 yen into a larger claim. LLMBridgeTrader LLMBridgeTrader sold EURUSD at 1.14172 and closed at 1.14092 for +130 yen. The closing comment indicates a stop-based exit, suggesting that the protection level had moved into profitable territory or was otherwise used to lock in the favorable move. This was the most convincing exit of the day. The bot did not need to catch the entire decline. It converted an open gain into a realized result and avoided letting the trade drift back through the entry. The report does not include the model’s confidence, setup label, original SL/TP proposal, or decision text, so it cannot prove whether the LLM itself initiated the final exit. Those logs matter. Still, the live outcome shows a useful separation between AI planning and mechanical protection: the model can propose the trade, while the system makes sure a favorable position does not remain unprotected. ML_ScoreAnalyst No July 22 trade report was included for ML_ScoreAnalyst. I have recorded it as zero closed trades rather than assuming that the bot was inactive. That distinction matters. A score-based bot may correctly skip an entire day because no candidate cleared its threshold, or it may simply have a missing report. The signal log is needed to tell whether the day consisted of valid SKIP decisions, no breakout candidates, a stopped process, or a reporting gap. For this bot, no-trade days are part of the experiment. They become informative only when the candidate score and rejection reason are retained. MAribbonTrader MAribbonTrader completed three GBPCAD shorts. The first two earned +38 yen and +63 yen. The third lost -125 yen, leaving the bot at -24 yen despite winning two of three trades. That loss felt familiar: two correct reads, then one trade large enough to take them both back. The payoff ratio was 0.40 because the average winner was 50.5 yen and the average loser was 125 yen. A 66.7% win rate looks comfortable until that ratio is placed beside it. The final trade was stopped about nine minutes after entry, so this was not a case of holding for hours without protection. The harder question is whether the initial risk was too large relative to the profit the bot usually accepts. If winners are routinely closed around 38 to 63 yen, a 125 yen loss requires an unusually high hit rate just to stay level. Because MAribbonTrader delegates chart interpretation and exit reasoning to AI, its SQLite logs should be used to compare the three trades. The review needs the ribbon state, H4 context, support and resistance, channel room, entry explanation, and exit explanation. The cause may be the stop width, or it may be that the third setup should have been rejected before entry. The broker statement cannot settle that yet. Summary The day did not expose a shortage of winning signals. It exposed an imbalance between what the bots were willing to take as profit and what they were willing to surrender when wrong. LLMBridgeTrader left the cleanest clue by protecting a profitable short. MAribbonTrader showed why a respectable hit rate can still leak money, while GateGrid AI showed how one unresolved position can dominate a multi-bot portfolio. The next improvement may not be another entry filter. It may be teaching each bot to notice sooner when staying in the trade has become the risk. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

    Four Wins, Two Losses, Still Down: The Exit Math Beat the Hit Rate
  8. Jul 22

    If You Keep Fixing the Strategy, You May Lose the Ability to Understand It

    The day after a loss, every strategy appears easy to improve. The stop was too wide. The entry was too early. The session was wrong. The filter was too weak. There is always something that could have prevented the latest losing trade. So we change it. The next trade loses too. We change something else. Eventually, the strategy has been modified so many times that we can no longer explain what improved or what failed. We wanted a better system. We removed the evidence needed to understand the original one. Change feels like progress Doing nothing during a drawdown feels irresponsible. The account is declining. The same rules are still running. The trader feels expected to act. So the stop is tightened. Another indicator is added. The trading window is reduced. A new market-regime filter is introduced. Editing the code provides immediate relief. The system looks more protected. At least something has been done. But emotional relief and strategy improvement are not the same thing. A change designed to reduce discomfort may not improve long-term performance. Losses do not arrive on schedule Strategy losses may be distributed over hundreds of trades in a test. Live trading does not deliver them evenly. Several losing trades may arrive together. Different bots may fail during the same market transition. What was expected to occur across several months can appear inside one week. Leverage makes this concentration feel even more significant. At small size, the week may look like ordinary variance. At larger size, it feels like structural failure. The market behavior is identical. The financial pain changes the diagnosis. A trader may believe the strategy is being evaluated objectively while actually reacting to the size of the drawdown. One adjustment creates another Suppose a losing streak leads to a tighter stop. The new stop is reached by ordinary price movement. Loss frequency increases. The trader responds by adding stricter entry filters. Trade frequency falls too far. The session is expanded to create more opportunities. The expanded session introduces different spreads and price behavior. Another filter becomes necessary. The first adjustment was small. Its consequences created a chain of additional adjustments. Later, performance improves. Was it the tighter stop? The entry filter? The wider session? Or did the market simply return to a more favorable regime? Nobody knows. The strategy was improved in several places and made impossible to evaluate in any one place. Preserve the baseline Testing requires a comparison. Before and after. The same market. The same costs. The same sizing. The same time horizon. When several variables change together, the comparison disappears. A useful process preserves the original version. Keep one bot on the old configuration. Store the previous parameters. Write one sentence explaining why each change was made. Define the number of trades or amount of time required before judging it. Record what the new rule removes, including the winning trades it may also remove. Improvement is not only the act of adding a better rule. It is also the discipline of protecting the evidence needed to verify that the rule is better. I feel the same urge with trading bots I run several MT5 bots built around different approaches. Some are rule based. Some receive TradingView alerts. Some use machine-learning scores. Some include language-model judgment. After a losing day, the code looks full of obvious improvements. A condition could have avoided this trade. An earlier exit could have protected that profit. A different filter could have rejected the setup. Looking backward makes the answer appear clear. But a rule designed to avoid one historical loss may remove profitable trades in another market. Avoiding a particular loss is not the same as improving the full distribution of outcomes. Without that distinction, a bot gradually becomes optimized for the chart that already happened. Diagnose before changing A negative P&L does not identify the broken component. The problem may be the entry. The direction was wrong, price was chased, or the setup did not fit the regime. It may be the exit. The stop was unsuitable, the strategy gave back profit, or it failed to respond to reversal evidence. It may be the size. The position was too large or several systems carried the same hidden exposure. It may be execution. Spread widened, orders were delayed, or retry logic behaved incorrectly. It may be the market environment. The strategy was designed for movement that was no longer present. The same financial result can come from different operational causes. Changing the full strategy before separating those causes often modifies the parts that were working. Reduce size before rewriting logic Maintaining the same rules during a losing period can still feel dangerous. A practical first response is to reduce size. This is not avoidance. It protects the ability to observe. At full exposure, each result carries more emotional force. Normal variance feels unacceptable. The need to recover becomes stronger. Parameter changes become more urgent. Smaller size reduces the financial pressure without immediately changing the system being evaluated. The strategy can continue producing evidence. Losses have less impact on the account. A favorable regime can return without the original logic having been removed. During a drawdown, the first goal is not always to find the answer immediately. It may be to preserve enough capital and mental space to recognize the answer later. Doing nothing still requires a plan “Do nothing” can become a dangerous excuse. A genuinely broken strategy can be allowed to continue under the label of patience. Observation needs boundaries. For example: Keep the logic unchanged for the next twenty trades. Run at half size. Record entry, exit, spread, session, and execution quality. Separate rule-following losses from operational failures. Stop if the drawdown exceeds a predefined limit. After the observation window, select only one modification to test. This is not passive neglect. It is a controlled period in which changes are delayed so that evidence can remain comparable. Useful improvements are often boring Strategy improvement is often associated with major additions. A new AI model. A new indicator. A new entry engine. A new market. In production, the most valuable changes may be less dramatic. Rejecting trades during excessive spread. Improving retry logic. Preventing duplicate exposure. Writing better logs. Defining restart conditions. Correcting position-size calculations. Each change is small. None creates a completely new strategy. Together, they remove repeated operational mistakes. A modest improvement that remains active for years may contribute more than a sophisticated idea that is replaced after the next drawdown. Activity is not evidence of improvement A large amount of work can be completed without making the strategy better. More code. More backtests. More parameters. More filters. The useful questions remain: What improved relative to the original? Did it improve in unseen periods? Does the result survive transaction costs? Which profitable trades were removed? Can the change be explained and repeated? Changing a strategy is easy. Keeping it unchanged long enough to learn from it is harder. That waiting period is not wasted time. It is what makes the next adjustment interpretable. The same pattern appears outside trading A newsletter fails to grow, so the topic changes. A product receives little attention, so new features are added. A study method feels slow, so another course is purchased. Changing the method produces a sense of movement. But when the method changes before results have enough time to appear, no learning accumulates. Improvement requires adjustment. It also requires periods of stability. Without stable periods, the effect of each adjustment remains invisible. Preserve before you repair There is no perfect trading strategy. Losses cannot be removed completely. Unexpected clusters will occur. Rebuilding the system after each one prevents the strategy from developing a reliable history. The answer is not to ignore poor results. It is to slow the rate of change when poor results create the strongest urge to act. Reduce size. Separate the causes. Keep the logs. Preserve the baseline. Change one variable. Wait long enough to observe the result. Before repairing the strategy, protect the process that allows you to learn what needs repair. Is the next adjustment truly designed to improve the system? Or is it mainly designed to make the latest loss feel easier to live with? This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

    If You Keep Fixing the Strategy, You May Lose the Ability to Understand It

About

Can AI really trade forex? AI FX Bot Lab is a real-time experiment from Japan, where I build and test AI-assisted FX trading bots using MT5, Python, machine learning, and local LLM tools. I share live results, failures, risk lessons, and bot improvements from rule-based, AI-driven, and ML + LLM hybrid systems. Not financial advice. fxaibotlab.substack.com

You Might Also Like