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. 2 dgn geleden

    Every Bot Finished Green, but Two One-Trade Systems Made Two-Thirds of the Money

    Conclusion Every live account finished the day with positive realized P&L. That sounds cleaner than the day actually was. The six accounts combined for +¥313, with 25 winning exits and 14 losing exits. The overall win rate was 64.1%, but the payoff ratio was only 0.84. The average winner was about ¥37.5 while the average loser was about ¥44.6, so the day still depended on winning often enough. The concentration was more interesting. LLMBridgeTrader made +¥125 from one trade and ML_ScoreAnalyst made +¥85 from one trade. Those two trades alone produced +¥210, roughly two-thirds of the entire day’s realized profit. Then there was GateGrid AI: 29 exits, 17 winners, and only +¥2 at the end. I looked at that line twice. A positive result is a positive result, but it is also a good reminder that win rate and activity can hide weak exit economics. Bot Results ■ GateGrid AI +¥2Record: 17W / 12LWin rate: 58.6%Gross profit: +¥421Gross loss: -¥419Payoff ratio: 0.71Max loss: -¥120 ■ BoundSniper Bot +¥54Record: 2W / 0LWin rate: 100.0%Gross profit: +¥54Gross loss: ¥0Payoff ratio: N/AMax loss: None ■ LLMBridgeTrader +¥125Record: 1W / 0LWin rate: 100.0%Gross profit: +¥125Gross loss: ¥0Payoff ratio: N/AMax loss: None ■ ML_ScoreAnalyst +¥85Record: 1W / 0LWin rate: 100.0%Gross profit: +¥85Gross loss: ¥0Payoff ratio: N/AMax loss: None ■ MAribbonTrader +¥35Record: 2W / 2LWin rate: 50.0%Gross profit: +¥241Gross loss: -¥206Payoff ratio: 1.17Max loss: -¥161Open position at cutoff: GBPCHF- long, -¥22 unrealized ■ BoundSniper Bot2 +¥12Record: 2W / 0LWin rate: 100.0%Gross profit: +¥12Gross loss: ¥0Payoff ratio: N/AMax loss: None ■ Total +¥313Record: 25W / 14LWin rate: 64.1%Gross profit: +¥938Gross loss: -¥625Payoff ratio: 0.84Max loss: -¥161 Today’s Theme: A Green Account Is Not the Same as a Good Exit Structure The headline result was broad. All six accounts were positive on realized P&L. The underlying distributions were not broad at all. GateGrid generated hundreds of yen on both sides and barely escaped flat, while two systems each produced one clean winner and carried most of the portfolio profit. MAribbonTrader lost half of its closed trades but still kept a payoff ratio above 1. That is why I keep coming back to exits in these experiments. For the LLM-driven bots, I do not only want to know whether the model correctly called BUY or SELL. I want to know whether it recognized when the original idea had stopped working, when a profitable position deserved more room, and when HOLD should become CLOSE. The MT5 statement gives me executions, prices, stop labels and P&L. It does not contain the full Ollama or Qwen reasoning from the moment of each decision. So I can judge the outcome of an exit, but I cannot honestly attribute every close to the LLM itself without the internal decision logs. That distinction matters today. GateGrid AI: 17 Wins Were Barely Enough GateGrid AI finished at +¥2 from 29 closed legs. It made +¥421 on winners and lost ¥419 on losers. The payoff ratio of 0.71 is the problem. Its average winning exit was about ¥24.8, while its average losing exit was about ¥34.9. A 58.6% win rate was just enough to keep the day above zero. The close bursts show how quickly one bad leg can change the picture. Around 11:08, the report recorded -¥120, +¥64, +¥43, +¥17 and -¥10 in the same few seconds. That group finished only slightly negative, but the -¥120 leg did most of the damage before the other positions compensated. GateGrid’s design uses a quantitative gate before the local LLM layer, with CatBoost filtering candidates and Ollama adding a second judgment layer. The interesting question is what happened after those filters had already approved exposure. Did the model still consider the position structure recoverable? Did a mechanical grid-management rule keep it open? Was the exit simply late? The MT5 statement cannot answer that by itself. For the next log review, I would start with the moments around the -¥120 exit and the other losing close clusters. Entry filtering is only half of this experiment if the expensive errors are being created later. BoundSniper Bot: The Relay Did Its Job BoundSniper Bot closed two USDJPY- shorts for +¥28 and +¥26. There were no losing trades, so a payoff ratio cannot be calculated. More importantly, BoundSniper is not supposed to act like an LLM trader. TradingView makes the signal decision and the Bot’s job is to transport that instruction into MT5. That changes what I want to evaluate. Today I care about whether the entries and exits were executed cleanly and whether the upstream TradingView signal translated into the expected MT5 behavior. Both trades closed positive, and there is no obvious execution problem in the statement. Two trades are nowhere near enough to judge the signal logic, but as a transport layer the day looks uneventful. For this Bot, uneventful is often a good result. LLMBridgeTrader: A Profitable Stop Exit Is the Most Interesting Line LLMBridgeTrader took one EURUSD- short at 1.15759 and closed at 1.15680 for +¥125. The close is labeled [sl 1.15680]. That caught my attention because the stop-related exit finished well inside profitable territory. LLMBridgeTrader has the widest AI authority in this group. The model can propose OPEN, HOLD, CLOSE and REVERSE, together with confidence, setup type, SL/TP levels and reasons. On a day like this, the entry direction was right, but the exit is the part I would inspect first. If the stop had been moved into profit as the trade developed, then the management layer successfully turned an open gain into a protected result. What I cannot tell from this statement is whether that stop adjustment came directly from the LLM, from a trailing mechanism, or from another fixed risk rule. That internal log is worth matching to the MT5 timestamp. The realized result is good; the experiment is figuring out why it was good. ML_ScoreAnalyst: One Score, One Winner ML_ScoreAnalyst opened a GBPJPY- short at 215.203 and closed at 215.118 for +¥85. The exit is again stop-labeled. The Bot itself is much simpler than the LLM systems: it detects a candidate and uses CatBoost to score whether the setup deserves an entry. That means today is mainly an entry-selection sample. The model found one short candidate that moved in the intended direction, and the position ultimately closed in profit. What the MT5 report does not show is the actual CatBoost score, the threshold at the time, or the feature values that produced ENTER. Without those records, I would not call this evidence that the model is calibrated correctly. It is one successful sample. Still, +¥85 from one trade with no visible sequence of re-entries is a clean result. MAribbonTrader: The Best Payoff Ratio Came With the Worst Loss MAribbonTrader finished at +¥35 from four closed trades: +¥106, -¥45, -¥161 and +¥135. The -¥161 stop was the number that made me hesitate. It was the largest realized loss across all six accounts. Yet MAribbonTrader’s payoff ratio was 1.17. Its average winner was ¥120.5 and its average loser was ¥103. That is a healthier shape than GateGrid’s distribution, even with only a 50% win rate. This Bot is the most discretionary-looking AI experiment in the group. Qwen reads a chart package containing the MAribbon structure, higher-timeframe context, support and resistance, ranges and other visual information before producing decisions such as WAIT, BUY, SELL or EXIT. Two losing trades were stop-labeled. The +¥135 NZDJPY- close carried the MAribbon-LLM comment instead, which makes that exit especially worth checking against the AI log. The MT5 record alone does not prove that Qwen explicitly chose EXIT, but the timestamp gives me a precise place to look. There was also one GBPCHF- long still open at the report cutoff with -¥22 unrealized P&L. I have excluded that from all realized performance figures. For MAribbonTrader, I would rather see a 50% win rate with payoff above 1 than a beautiful hit rate built on tiny winners and occasional large stops. The sample is small, but the shape is encouraging. BoundSniper Bot2: Positive, but Too Small to Read Much Into BoundSniper Bot2 added +¥12 from two USDJPY- longs, +¥5 and +¥7. It uses the same basic relay idea as BoundSniper Bot but follows a different upstream indicator. That makes the comparison interesting over a long sample, not over two trades. Both variants finished positive today. The original BoundSniper made +¥54 from shorts, while Bot2 made +¥12 from longs. For now, I would log the difference and move on. There is not enough evidence here to say which signal source is better. Summary The pleasant part of Aug. 14 is easy to see: every account closed positive on realized P&L. The more useful part is underneath that headline. The portfolio payoff ratio was still below 1, GateGrid needed 17 winning exits just to finish at +¥2, and two single-trade systems produced most of the actual money. The next step is not to celebrate the six green numbers. I want to match the profitable stop exits and the larger losing legs back to the LLM and management logs and see who actually made the exit decision. A green day is nice. Knowing why it stayed green is more 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

    Every Bot Finished Green, but Two One-Trade Systems Made Two-Thirds of the Money
  2. 3 dgn geleden

    Two Bots Erased the Other Four’s +¥218

    The interesting part of August 13 was not that the six accounts lost ¥1,080. It was how concentrated that loss was. BoundSniper, bb_pullback_rider, MLScore, and BoundSniper Bot2 combined for +¥218. GateGrid and MAribbon then produced -¥1,298 between them, turning the whole group negative. The systems are built very differently: GateGrid uses a multi-stage ML/LLM filtering concept, MAribbon asks Qwen to interpret chart context, while BoundSniper is mainly an execution bridge and MLScore relies on CatBoost scoring. Those design differences are exactly why I run them side by side. What bothered me most was not the overall win rate. It was the shape of the losses. MAribbon had a single -¥282 trade and a payoff ratio of only 0.26. GateGrid did not suffer one catastrophic hit, but 31 closed positions slowly accumulated -¥897. Different paths, same problem: the exit side overwhelmed the winners. Bot-by-Bot Performance ■ GateGrid AINet P/L: -¥897Record: 11W / 20LWin rate: 35.5%Gross profit: +¥367Gross loss: -¥1,264Payoff ratio: 0.53Max loss: -¥156 ■ BoundSniper BotNet P/L: +¥38Record: 3W / 1LWin rate: 75.0%Gross profit: +¥52Gross loss: -¥14Payoff ratio: 1.24Max loss: -¥14 ■ bb_pullback_riderNet P/L: +¥51Record: 2W / 0LWin rate: 100.0%Gross profit: +¥51Gross loss: ¥0Payoff ratio: N/AMax loss: N/A ■ ML_ScoreAnalystNet P/L: +¥152Record: 2W / 0LWin rate: 100.0%Gross profit: +¥152Gross loss: ¥0Payoff ratio: N/AMax loss: N/A ■ MAribbonTraderNet P/L: -¥401Record: 2W / 3LWin rate: 40.0%Gross profit: +¥83Gross loss: -¥484Payoff ratio: 0.26Max loss: -¥282 ■ BoundSniper Bot2Net P/L: -¥23Record: 0W / 2LWin rate: 0.0%Gross profit: ¥0Gross loss: -¥23Payoff ratio: N/AMax loss: -¥19 ■ TotalNet P/L: -¥1,080Record: 20W / 26LWin rate: 43.5%Gross profit: +¥705Gross loss: -¥1,785Payoff ratio: 0.51Max loss: -¥282 Today’s Theme: The Exit Matters More Than the Signal I keep experimenting with different ways to decide whether to enter. CatBoost scores probabilities. GateGrid adds an Ollama layer and volatility/session filters. MAribbon gives Qwen chart images, moving-average ribbons, higher-timeframe context, support and resistance, and asks for something closer to discretionary judgment. August 13 pushed me back toward a less glamorous question: once a position is open, how quickly does the system admit that the original idea is no longer working? A good entry model can still lose if bad trades are allowed to become expensive. A mediocre entry model can survive surprisingly well if the exit cuts the wrong ideas early. GateGrid AI: Many Small Decisions Added Up GateGrid closed 31 positions and finished at -¥897. The win rate was 35.5%, but the bigger issue was the 0.53 payoff ratio. Average winning trades were about ¥33, while the average loss was roughly ¥63. The live report also shows repeated grouped closures. This was not one freak trade destroying the day. Losses accumulated across multiple baskets, including -¥145, -¥128 and -¥156 exits. That pattern worries me more than a single abnormal event because it can be repeated by the system. GateGrid was designed around filtering: CatBoost first, then local-LLM judgment, ATR, session conditions and other gates. The actual AI decision logs were not included in today’s report, so I cannot say whether Ollama approved poor setups or whether the market simply behaved badly after acceptable entries. What the P/L log does show is that filtering entries alone was not enough. The basket exit logic deserves at least as much attention as the entry gate. BoundSniper: Small Sample, Clean Damage Control BoundSniper made four trades, winning three and finishing at +¥38. The payoff ratio was 1.24 and the worst loss was only -¥14. This Bot does not try to read the market itself. TradingView generates the signal and the local bridge handles delivery and execution in MT5. Because of that, I look at its result a little differently. I am less interested in whether the Bot predicted USDJPY correctly and more interested in whether the execution chain turned the upstream signals into controlled trades. On this day, it did. One loss did not erase the three winners. bb_pullback_rider: Two Wins, but Not Enough Evidence Yet The bb_pullback_rider account closed two USDJPY trades for +¥31 and +¥20. That gives it +¥51 and a 100% daily win rate. There is no matching architecture description for this name in the supplied six-Bot design memo, so I do not want to invent an explanation for why it worked. From the broker report alone, all I can say is that both positions were profitable and there was no losing trade from which to calculate a payoff ratio. Two trades are also far too few to turn 100% into a meaningful claim. For now, this is a clean day rather than evidence of an edge. ML_ScoreAnalyst: The Best Exit Pattern of the Day MLScore produced only two GBPJPY trades, but both were winners: +¥81 and +¥71. What caught my eye was the way they closed. Both exits are recorded with [sl ...] comments, yet the exit prices locked in positive P/L. Whatever adjustment led to those stop levels, the result was exactly what an exit mechanism is supposed to do: the trade moved in the right direction and profit was protected before the market could take it back. The daily sample is tiny, so a 100% win rate means almost nothing by itself. Still, +¥152 from two trades with no loser is the cleanest result among the accounts today. MAribbonTrader: This Is Where the Exit Question Gets Serious MAribbon finished at -¥401 from five trades. Two wins produced only +¥83 in total, while three losses cost -¥484. The payoff ratio was 0.26. The -¥282 USDCHF loss made me stop for a moment. It was the largest single loss across all six accounts, and it was almost four times the Bot’s best winner of +¥73. This matters because MAribbon is one of the systems where AI judgment is supposed to contribute more than a simple signal. Qwen receives chart context such as the MA ribbons, higher-timeframe environment, support and resistance, ranges and channels, and the architecture can produce WAIT, BUY, SELL and EXIT decisions. The design goal is close to discretionary chart reading. Today’s broker report does not contain the Qwen reasoning log, so I cannot blame the model for holding too long or choosing the wrong stop. But the outcome tells me what to inspect next: not only why the AI entered USDCHF, but what information would have justified abandoning the setup earlier. The Entry model can wait. I want to understand the Exit behavior first. BoundSniper Bot2: Wrong Twice, but Cheaply Wrong BoundSniper Bot2 lost both of its USDJPY trades and finished at -¥23. A 0% win rate looks ugly on paper, but the maximum loss was only -¥19. That is a useful reminder of why I do not rank these Bots by win rate alone. Two losing signals with tightly contained damage are easier to live with than a high-win-rate system that occasionally gives back several winners at once. Bot2 uses the same bridge concept as BoundSniper with a different TradingView indicator. With only two trades, I would look upstream at signal quality before changing the MT5 execution layer. Summary The combined win rate was only 43.5%, but that number does not explain the day very well. The other four accounts were collectively positive; GateGrid’s repeated losing baskets and MAribbon’s asymmetric loss size changed the sign of the whole portfolio. For the LLM experiments, I want more than better BUY and SELL decisions. I want the model and the surrounding rules to recognize when the original story has expired. August 13 looked less like an entry-model problem and more like a reminder that an intelligent Bot also needs to know when to stop defending its own idea. 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

    Two Bots Erased the Other Four’s +¥218
  3. 5 dgn geleden

    A 59% Win Rate Still Lost Money: GateGrid’s Exit Math Was the Problem

    Bottom Line The six-bot portfolio closed August 11 at -¥55, with 32 wins and 22 losses. A 59.3% win rate does not look bad on its own. The uncomfortable number was the 0.66 payoff ratio: the average winner was about ¥36, while the average loser was ¥55. GateGrid AI made the problem easiest to see. It won 23 of 43 closed trades and still lost ¥295 because its average loss was much larger than its average win. The -¥156 largest loss made me stop for a second. This was not a day where entry accuracy completely failed; the damage came from what happened after positions were already open. Results by Bot ■ BoundSniper Bot +¥89Record: 3W / 0L (Win rate 100.0%)Gross profit: +¥89Gross loss: ¥0Payoff ratio: N/A (no losing trades)Max loss: ¥0 ■ LLMBridgeTrader ¥0Record: 0W / 0L (Win rate N/A)Gross profit: ¥0Gross loss: ¥0Payoff ratio: N/AMax loss: ¥0 ■ GateGrid AI -¥295Record: 23W / 20L (Win rate 53.5%)Gross profit: +¥777Gross loss: -¥1,072Payoff ratio: 0.63Max loss: -¥156 ■ ML_ScoreAnalyst ¥0Record: 0W / 0L (Win rate N/A)Gross profit: ¥0Gross loss: ¥0Payoff ratio: N/AMax loss: ¥0 ■ MAribbonTrader +¥86Record: 4W / 2L (Win rate 66.7%)Gross profit: +¥224Gross loss: -¥138Payoff ratio: 0.81Max loss: -¥112 ■ BoundSniper Bot2 +¥65Record: 2W / 0L (Win rate 100.0%)Gross profit: +¥65Gross loss: ¥0Payoff ratio: N/A (no losing trades)Max loss: ¥0 ■ Total -¥55Record: 32W / 22L (Win rate 59.3%)Gross profit: +¥1,155Gross loss: -¥1,210Payoff ratio: 0.66Max loss: -¥156 Today’s Theme: The Exit Can Undo a Decent Entry Rate GateGrid is designed as a multi-stage decision system rather than a simple always-on grid. Its design notes describe a CatBoost gate, local LLM judgment through Ollama, volatility and session filters, and position management. That makes its live result interesting for a reason beyond the ¥295 loss: a system built to filter entries still ended up with an unfavorable payoff structure. The MT5 statement does not include the corresponding AI_SKIP, OLLAMA_HOLD, prompt response, or model reasoning log for each trade, so I cannot say which LLM decision caused a particular loss. What the execution record does show is enough to raise the exit question. GateGrid’s average winning trade was about ¥33.8, while its average losing trade was ¥53.6. With a 0.63 payoff ratio, it would need a win rate around 61% just to offset that asymmetry before other costs. It delivered 53.5%. One cluster was especially ugly. Around 14:25, four positions were closed for -¥8, -¥56, -¥76 and -¥101, a combined -¥241. That is the kind of sequence I want to match against the decision log next: did the model keep the basket alive because its original thesis still looked valid, or did the exit mechanism simply react too late? The statement alone cannot answer that, but it tells me exactly where to look. Bot Notes BoundSniper Bot BoundSniper finished 3W / 0L for +¥89. The individual exits were +¥52, +¥22 and +¥15, so there was no single oversized winner carrying the result. This bot does not predict the market itself. TradingView generates the instructions and BoundSniper acts as the execution bridge into MT5, which means I read this result differently from the LLM-driven systems. The statement confirms three profitable completed entry/exit pairs; evaluating signal quality or exit reasoning further would require the TradingView signal log alongside the MT5 fills. For today, the execution result is clean. I would not extrapolate much from three trades, though. LLMBridgeTrader There was no trade statement for LLMBridgeTrader on August 11, so it is recorded as no trades. This is the bot where the LLM has the broadest decision authority: OPEN, HOLD, CLOSE and REVERSE, along with proposed SL and TP distances. Because no live trades were supplied today, there is no evidence to grade its entry or exit decisions. A zero is not a good day or a bad day here; it is simply no sample. GateGrid AI GateGrid produced 23 wins and 20 losses, yet finished at -¥295. That combination is more useful than a simple losing-day label because it isolates the structural issue. Gross profit reached +¥777, but gross loss expanded to -¥1,072. The payoff ratio was only 0.63, and the largest individual loss was -¥156. Several profitable basket closes show that the strategy can recover mixed positions, but the losing baskets were too expensive when that recovery failed. For an ML-plus-LLM system, this is where I want the next experiment to focus. Entry filters can become more selective, but if HOLD and eventual exit behavior allow average losses to grow faster than average winners, better entries alone may not repair the expectancy. My suspicion is the exit side, although I would want the Ollama decision log before calling that settled. ML_ScoreAnalyst No trade statement was supplied for ML_ScoreAnalyst, so the bot is recorded at ¥0 with no trades. Unlike the LLM bots, ML_ScoreAnalyst uses CatBoost scoring without an LLM layer. That makes it useful as a comparison group when enough live samples accumulate: a relatively deterministic score threshold against systems where language models also interpret context. There is nothing to compare from August 11 itself, so I am leaving the result untouched rather than filling the gap with assumptions. MAribbonTrader MAribbonTrader finished 4W / 2L for +¥86, trading GBPCAD in the supplied statement. Its result was positive, but the shape of the P&L was uneven. The six exits were +¥3, -¥26, +¥2, +¥5, -¥112 and +¥214. That final +¥214 take-profit changed the whole day; without it, the bot would have been at -¥128. Seeing the position finally run that far was encouraging, but it also exposes a dependency I do not want to ignore. The payoff ratio was only 0.81 because several wins were tiny while the two losses averaged ¥69. Still, the 66.7% win rate was high enough to make the combination profitable, and one exit did exactly what a chart-reading system should sometimes do: stay with a move long enough for a large winner to emerge. MAribbonTrader uses Qwen to interpret chart imagery and supporting context such as moving-average structure and higher-timeframe information. The MT5 statement records the result but not the corresponding visual judgment or EXIT explanation. Matching that +¥214 trade and the -¥112 loss back to the stored AI reasoning should be far more valuable than merely celebrating the net +¥86. BoundSniper Bot2 BoundSniper Bot2 closed 2W / 0L for +¥65, with winners of +¥44 and +¥21. Like the original BoundSniper, this version is primarily an execution bridge, with a different indicator supplying the TradingView signal. Both variants ended positive on the same day, but the sample is too small to decide which signal source is superior. The useful part is that they give the LLM experiments a simple benchmark: external rule-based signals can be compared with systems where AI has more freedom over entries and exits. Closing Thoughts A portfolio can post a 59.3% win rate and still lose money. August 11 was a small loss in yen, but a useful live experiment because the reason was visible in the distribution rather than hidden in the final number. The next comparison I care about is not “Can an LLM pick direction better?” It is whether giving the model control over HOLD and EXIT can keep average losses from outrunning average wins. GateGrid made that weakness visible today, while MAribbon showed the opposite possibility with one trade that was allowed to run. That tension is probably more interesting than the -¥55 itself. 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

    A 59% Win Rate Still Lost Money: GateGrid’s Exit Math Was the Problem
  4. 6 dgn geleden

    One -¥301 Loss Flipped the Whole Day: Five MT5 Bots Closed at -¥294

    Conclusion The five-bot book finished August 10 at -¥294, with 11 wins and 13 losses. Gross profit was +¥590 against -¥884 in gross losses, giving the whole group a 45.8% win rate and a 0.79 payoff ratio. But the daily total hides the main story. BoundSniper took one -¥301 loss; remove that single trade from the arithmetic and the book would have ended at +¥7. I stared at that -¥301 longer than I did at the final -¥294, because it says more about the day than the hit rate does. Bot-by-bot results The GateGrid account contains both “GateGrid AI” and “GateGrid v4” execution comments on August 10, so I am treating them as one GateGrid line for this five-bot daily comparison. ■ GateGrid AI -132 yenRecord: 6W / 7L (Win rate 46.2%)Gross profit: +143 yenGross loss: -275 yenPayoff ratio: 0.61Max loss: -90 yen ■ BoundSniper -315 yenRecord: 2W / 2L (Win rate 50.0%)Gross profit: +33 yenGross loss: -348 yenPayoff ratio: 0.09Max loss: -301 yen ■ LLMBridgeTrader -78 yenRecord: 0W / 1L (Win rate 0.0%)Gross profit: 0 yenGross loss: -78 yenPayoff ratio: 0.00Max loss: -78 yen ■ ML_ScoreAnalyst +411 yenRecord: 2W / 0L (Win rate 100.0%)Gross profit: +411 yenGross loss: 0 yenPayoff ratio: N/A (no losing trades)Max loss: 0 yen ■ MAribbonTrader -180 yenRecord: 1W / 3L (Win rate 25.0%)Gross profit: +3 yenGross loss: -183 yenPayoff ratio: 0.05Max loss: -65 yen ■ Total -294 yenRecord: 11W / 13L (Win rate 45.8%)Gross profit: +590 yenGross loss: -884 yenPayoff ratio: 0.79Max loss: -301 yen Today’s theme: exits mattered more than entries There is one limitation in today’s material that matters for an LLM trading experiment. The MT5 statement tells me when positions opened and closed, the execution prices, P/L, and comments such as [sl] or [tp], but it does not contain the actual model prompt, confidence score, HOLD/CLOSE reasoning, or the text returned by the LLM. So I can evaluate the behavior of the exits, but I should not invent a story about why the model made them. For LLMBridgeTrader and MAribbonTrader in particular, the next layer of analysis needs the model decision log beside the MT5 execution log. That missing link is becoming part of the experiment itself. GateGrid AI: many small exits, but losses were still heavier GateGrid finished at -132 yen with six winners and seven losers. A 46.2% win rate is not especially alarming on its own, but the 0.61 payoff ratio shows the real problem: the average winner was smaller than the average loser. The morning sequence illustrates it well. Two USDJPY positions closed within seconds for +50 and -21 yen, then a later position produced -90 yen, the largest GateGrid loss of the day. In the v4 portion of the account, several small profits appeared, but the final short basket closed at +20, -67 and -78 yen almost immediately after entry. That last cluster bothers me more than the win rate. The system was capable of cutting positions quickly, yet “quick” did not automatically mean “cheap”; the losing legs were still large enough to erase several earlier winners. The exit mechanism is active, but the payoff distribution says it is not balanced yet. BoundSniper: 50% wins and a 0.09 payoff ratio BoundSniper is not an LLM trader. It is an execution bridge for TradingView signals, so there is no reason to blame an AI model for the direction of these trades. Still, its numbers are the clearest warning of the day. It went 2W / 2L, which looks harmless at first glance, but gross profit was only +33 yen against -348 yen of gross losses. The payoff ratio fell to 0.09. One position closed for -301 yen, while the two winners were only +10 and +23 yen. The first daily close also realized -47 yen after including the -19 yen swap. This is exactly why I do not want to judge an automated system by win rate alone: a 50% hit rate can still leave a deeply asymmetric loss profile. For BoundSniper, the question is less about prediction and more about what the TradingView strategy permits before an exit arrives. The bridge did its job; the loss budget around the signal logic needs the attention. LLMBridgeTrader: one trade, and the exit log matters LLMBridgeTrader had one EURUSD trade. It sold at 1.15479 at 16:45:14 and closed at 1.15528 at 17:30:05, ending at -78 yen. That is roughly 4.9 pips against the short over about 45 minutes. The loss itself is small enough to be controlled, but one trade tells me almost nothing about entry quality. What I do want to know is what happened during those 45 minutes. LLMBridgeTrader is designed to choose among OPEN, HOLD, CLOSE and REVERSE, so the interesting data is whether the model kept returning HOLD while the trade deteriorated, switched to CLOSE at the right moment, or was closed by another safety condition. The MT5 statement alone does not answer that, and I would rather leave that blank than manufacture a neat explanation. ML_ScoreAnalyst: the best result also had the most interesting exit ML_ScoreAnalyst was the only clear winner, finishing at +411 yen from two GBPJPY trades. The first closed at TP for +300 yen. The second is more interesting. It entered long at 213.485 and later closed via an [sl 213.596] execution for +111 yen. Seeing a stop-loss label attached to a profitable trade made me look twice; whatever moved or maintained that stop, the practical result was that the exit protected profit rather than turning the trade back into a loser. There were no losing trades, so the payoff ratio cannot be calculated meaningfully yet. A 100% win rate from two samples also does not prove much, but the exit shape was clean: one target win and one protected-profit stop. MAribbonTrader: the stop worked, then the Bot kept coming back MAribbonTrader traded GBPCAD four times, all from the sell side. The first closed for +3 yen, followed by three losses of -65, -58 and -60 yen. The good part is that the maximum individual loss stayed at -65 yen. The hard exit prevented a BoundSniper-style single loss from appearing. The bad part is the repetition: after being stopped, the Bot returned to essentially the same directional idea several times and accumulated -180 yen. For an LLM chart-reading Bot, this is where EXIT and WAIT need to be considered together. A stop can end one bad trade correctly, but if the model immediately interprets the same market structure as another valid sell, the portfolio-level exit has not really happened. I suspect the improvement belongs somewhere around post-stop regime recognition, although one day is not enough to prove it. Closing thoughts August 10 was not a simple “AI bots lost” day. ML_ScoreAnalyst actually covered a large part of the damage, GateGrid kept most individual losses moderate, and MAribbon’s hard stops did cap each attempt. The uncomfortable number came from somewhere else: loss concentration. One -301 yen trade changed the sign of the entire five-bot book, while another Bot lost through repeated smaller attempts. The next thing I want from these logs is not a prettier win rate; I want to see how each system behaves immediately after the market tells it that its first idea was wrong. 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

    One -¥301 Loss Flipped the Whole Day: Five MT5 Bots Closed at -¥294
  5. 8 aug

    Don’t Lower Your Standards Just Because the Numbers Are Bad

    A trader takes two losses and looks for a third trade. A founder sees no sales and cuts the price. A creator sees low engagement and changes the entire content strategy. Doing something feels better than doing nothing. Action creates the feeling that the problem is being handled. But some of our worst decisions begin exactly there. The original result was bad. Then pressure made us lower the standard. The third trade was never part of the plan Imagine losing twice before lunch. Both trades were valid. Both stops worked as intended. The trading plan says the day is over. But the chart remains open. A new setup appears. On a normal morning, you probably would not take it. Today it looks different. You are already down. You want the day repaired. So “not quite good enough” quietly becomes “good enough.” You enter. Maybe you lose again. The problem is larger than a third loss. Your entry standard changed because your P&L changed. The market did not create a better opportunity. Your need for a better outcome created one. Winning after breaking the rule can be worse Suppose the third trade wins. Now the account looks better. Emotionally, this feels like proof that taking the trade was correct. But another lesson has been learned: The daily stop is flexible. Rules can be ignored when the situation feels special. A bad process produced a good outcome. That is dangerous because markets occasionally reward behavior you should not repeat. The same thing happens in business. No sales? Cut the price Imagine selling a service for $500. A week passes without a sale. Traffic exists. A few people ask questions. Nobody buys. Friday evening arrives and the price becomes $350. Still quiet. Then comes a temporary offer at $250. Maybe someone finally buys. It is tempting to conclude: “The problem was price.” But perhaps the offer was unclear. Perhaps the buyer could not tell who it was for. Perhaps the problem it solved was not painful enough. Perhaps the traffic came from the wrong audience. Lowering price may have changed the outcome without fixing the real problem. And if every difficult sales week leads to another discount, you eventually build a business that only works when your own standards are negotiable. More effort can amplify the wrong thing When results disappoint, “do more” sounds practical. More sales calls. More posts. More trades. More hours. Sometimes volume really is the missing ingredient. Ten customer conversations may be too few to learn anything. But if the underlying direction is wrong, more activity can simply create more bad data. An unclear offer sent to 1,000 people is still unclear. A weak trading setup taken ten times is still weak. Content the audience does not need does not become useful because it is published daily. Before increasing volume, ask whether the activity itself still meets the standard. Bad bot performance makes me want to touch everything I run multiple MT5 trading bots in parallel. Every day produces numbers. Profitable bots. Losing bots. Inactive bots. Occasionally one system has an ugly day. The immediate temptation is modification. Change the stop. Add another filter. Adjust entry logic. Restrict another session. But if I change the system every time it loses, comparison becomes impossible. Tomorrow’s bot is no longer yesterday’s bot. A win three days later tells me very little because several variables changed at once. So I try to ask a different set of questions first. Did the bot enter under the intended conditions? Did the stop behave correctly? Were economic-event restrictions respected? Did execution fail? Was the position limit followed? If the system followed its rules and lost, one loss is not automatically a development task. If it broke its rules and won, the profit does not automatically make the behavior acceptable. Both are surprisingly difficult distinctions to maintain. Rules are not sacred There is an obvious objection. What if the rule itself is bad? Then it should change. A business with weak positioning needs adjustment. A trading strategy whose edge has disappeared should not be defended out of loyalty. A rule is not valuable because it is old. The real question is when the rule changes. Changing it immediately after emotional pain is very different from changing it after defined evidence. Before the pressure arrives, decide: How much evidence triggers review? Which metrics matter? What specific event requires stopping? What conditions justify a change? That turns adaptation into a process rather than a reaction. Bad days reveal what the standard actually was Rules are easy to respect when things are going well. Profits are coming. Customers are buying. Audience numbers are growing. Pressure is low. The real test arrives when nothing seems to work. That is when exceptions begin. Just this once, widen the stop. Just this week, discount heavily. Just tonight, work until 2 a.m. Just this client, accept work you already decided not to take. Each exception looks small. Repeated often enough, they teach something larger: My own rules disappear when I become uncomfortable. Self-trust is built in boring moments Confidence is often associated with visible success. Revenue. Profit. Qualifications. Recognition. But self-trust may be built in quieter moments. You stopped trading because the daily limit was reached. You did not accept a price below the floor you had chosen. You took the day off because you had already decided it would be a day off. Nobody applauds those decisions. They barely look like achievements. But you remember them. You also remember the opposite. That is why repeatedly breaking small promises to yourself can matter more than it appears. Standards can also become excuses There is another trap. “I am following my rules” can become a way to avoid uncomfortable evidence. A product that has not sold for six months deserves review. A trading system that continues to lose over a meaningful sample deserves review. Rules should stabilize decisions, not protect us from reality. That is why review conditions matter. Thirty trades. A defined drawdown. Three repeated execution failures. A specific conversion threshold. Whatever makes sense for the system. The point is to decide the trigger before the emotional moment arrives. Avoid major decisions immediately after bad results One practice I find useful is simple: Do not make a large change immediately after a painful number. A large trading loss. A zero-sales week. A failed launch. A post that goes nowhere. Write down what happened. Identify the possible cause. Then revisit the decision later. A surprising number of urgent changes feel less urgent the next morning. You cannot control every number Markets move without permission. Customers can say no. Readers can ignore an article. Applications can be rejected. Those outcomes are only partly under our control. But other things are. Where the stop goes. The lowest acceptable price. The type of work you will refuse. The hour when work ends. The conditions required before taking another trade. Bad numbers do not require those standards to become bad too. The next time the result disappoints you, notice what you suddenly want to do. That impulse may tell you which rule needs to be written before the next difficult day arrives. 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

    Don’t Lower Your Standards Just Because the Numbers Are Bad
  6. 7 aug

    [AI Trading Log] Whispering Winners, Loud Losers

    On August 5 and 6, 2026, we ran a parallel test of six MT5 automated trading bots. The results across these two days provided the ultimate case study in why exit discipline—rather than entry prediction—dictates the survival of an automated trading portfolio. When our losses were allowed to speak at full volume, we lost money despite a solid win rate; when we kept our losses quiet, even a modest day turned into a major victory. Overall Performance: A Tale of Two Distribution Shapes * August 5: Total -¥478 (61.5% Win Rate) The fleet closed 15 trades with 8 wins, 5 losses, and 2 flat exits. On paper, a 61.5% win rate (excluding flats) is respectable. However, the underlying shape of the distribution was highly fragile: the average winner was only about ¥55, while the average loser was nearly ¥188, dropping the combined payoff ratio to a dismal 0.29. We had to win more than three times just to offset a single average loss. * August 6: Total +¥634 (66.7% Win Rate) On August 6, the win rate was structurally similar at 66.7% (6 wins, 3 losses). But this time, the payoff ratio shifted to a healthy 3.10. The portfolio generated ¥756 in gross profits against only ¥122 in gross losses, with the maximum closed loss strictly capped at ¥88. This healthy asymmetric profile allowed our winners to actually matter. Bot-by-Bot Breakdown: Exit Anatomy 1. ML_ScoreAnalyst (GBPJPY Breakout / CatBoost Evaluation) * August 5: -¥489 (0W / 2L) * August 6: +¥326 (1W / 0L) * This bot experienced the most dramatic swing. On August 5, it dragged the portfolio down by hitting two nearly identical stop losses of -¥252 and -¥251 (buffered slightly by +¥14 in swap). These repeated stop sizes functioned as an oversized loss unit that required five average winners from the group to recover. On August 6, however, it took a single long trade on GBPJPY (entered at 212.726, exited at 213.052), hit its take-profit (TP) cleanly, and finished as the day’s top performer with +¥326. It is a stark reminder that a lighter, non-LLM architecture can produce brilliant results, provided the expected upside justifies the risk. 2. GateGrid AI (EURUSD ML + LLM Hybrid) * August 5: -¥148 (1W / 1L / 1 Flat) * August 6: +¥91 (2W / 1L) * GateGrid’s advanced multi-gate entry system (CatBoost, Ollama, volatility checks) successfully filters out weak entry setups. But on August 5, a single -¥238 short-position loss completely erased its ¥90 winner, highlighting its vulnerability to a low payoff ratio (0.38). On August 6, the bot redeemed itself by capping its single losing exit at just -¥9, allowing two small winners (+¥97 and +¥3) to carry the basket to a +¥91 finish. Keeping the losing leg from becoming the “story of the day” is exactly how this grid strategy is supposed to operate. 3. LLMBridgeTrader (EURUSD Autopilot AI) * August 5: +¥126 (1W / 0L) * August 6: +¥201 (2W / 2L) * LLMBridgeTrader is allowed to fully direct its positions (OPEN, HOLD, CLOSE, REVERSE). On August 5, it showed off a highly sophisticated exit by sliding its stop loss below its EURUSD short entry price, securing +¥126 via a profit-protecting stop. On August 6, it achieved a +¥201 realized profit. Despite a flat 50% win rate, its average winner was far larger than its average loser (payoff ratio of 2.78). However, it carried -¥89 in unrealized losses on an open EURUSD short at the reporting cutoff, which remains the key position to monitor. 4. BoundSniper Bot (USDJPY TV Signal Relay) * August 5: +¥25 (3W / 0L) * August 6: +¥16 (1W / 0L) * This bot does not generate its own market predictions; it simply transfers TradingView webhooks into MT5 executions. It performed its job flawlessly on both days, capturing small, clean wins. While the absence of losses is excellent, capturing only a few yen per trade leaves the strategy highly sensitive to spreads and execution slippage. 5. bound_sniper 2 (Second TV Relay) * August 5: +¥23 (1W / 0L) * August 6: No trades. * Our newest sixth bot entered a quick USDJPY long on August 5, exiting in under two minutes for a clean +¥23 profit. It sat out of the market on August 6. 6. MAribbonTrader (Visual LLM Chart-Reader) * August 5: -¥15 (2W / 2L / 1 Flat) * August 6: No trades. * This visual bot uses a local LLM to read screenshots of MT5 charts. On August 5, its stop mechanism successfully protected several trades (producing a decent payoff ratio of 0.88 and containing losses under -¥113). However, its high trading frequency—entering four new long positions in a tight window—suggests it may have been repeatedly buying into a fading trend. It remained inactive on August 6. Key Takeaway: Taming the Volume of Our Losers The contrast between these two sessions proves that our entry models are generally succeeding at finding correct directions. Our struggle is managing what happens when an idea stops working. On August 5, our winners whispered while our losers spoke at full volume. On August 6, we managed to mute the losers, allowing the winners to carry the day. Moving forward, our priority is not adding more entry filters. We must focus on tightening our exit rules: establishing clearer abandonment thresholds for GateGrid AI, auditing the risk-to-reward ratio on ML_ScoreAnalyst’s stops, and analyzing the decision logs of our LLM bots to ensure “HOLD” states are backed by genuine logic rather than hesitation. I can compile these August 5–6 metrics into a visual comparison table to help you analyze the exact shift in payoff ratios across all six bots. 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] Whispering Winners, Loud Losers
  7. 5 aug

    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
  8. 1 aug

    [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)

Info

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

Suggesties voor jou