AI FX Bot Lab: Real Trading Experiments

The Mato Topic Intelligence Platform does not report this podcast as charting in a published category in this snapshot.

1. Five Winning Trades Were Erased by One Stop: Exit Size Ruled the Day from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

   Aug 26, 20261 min

   Conclusion August 25 ended at -¥370 in realized P&L. Across the six bots, there were 19 winning trades and 25 losses, for a 43.2% win rate. Gross profit was +¥494, gross loss was -¥864, and the combined payoff ratio came in at 0.75. The most revealing comparison was not GateGrid’s 21 losing legs. BoundSniper Bot and BoundSniper Bot2 went a combined five wins without a loss and earned +¥180. ML_ScoreAnalyst then lost -¥252 on one trade . I stopped on that number for a second. Five correct trades from the bridge bots were not enough to pay for one MLScore stop. MAribbonTrader added another warning from the exit side. It produced one +¥34 winner and three losses totaling -¥191, leaving its payoff ratio at 0.53. The direction calls matter, but on this day the price paid for being wrong mattered more. Bot Results ■ GateGrid AI -¥141Record: 13W / 21LWin rate: 38.2%Gross profit: +¥280Gross loss: -¥421Payoff ratio: 1.07Max loss: -¥52 ■ BoundSniper Bot +¥84Record: 2W / 0LWin rate: 100.0%Gross profit: +¥84Gross loss: ¥0Payoff ratio: N/AMax loss: ¥0 ■ LLMBridgeTrader ¥0Record: 0W / 0LWin rate: N/AGross profit: ¥0Gross loss: ¥0Payoff ratio: N/AMax loss: ¥0 ■ ML_ScoreAnalyst -¥252Record: 0W / 1LWin rate: 0.0%Gross profit: ¥0Gross loss: -¥252Payoff ratio: N/AMax loss: -¥252 ■ MAribbonTrader -¥157Record: 1W / 3LWin rate: 25.0%Gross profit: +¥34Gross loss: -¥191Payoff ratio: 0.53Max loss: -¥79 ■ BoundSniper Bot2 +¥96Record: 3W / 0LWin rate: 100.0%Gross profit: +¥96Gross loss: ¥0Payoff ratio: N/AMax loss: ¥0 ■ Total -¥370Record: 19W / 25LWin rate: 43.2%Gross profit: +¥494Gross loss: -¥864Payoff ratio: 0.75Max loss: -¥252 Today’s Theme: How Much Does One Wrong Decision Cost? The six bots use very different ways to reach a trade. GateGrid filters candidates through CatBoost and a local LLM layer. BoundSniper executes TradingView signals. ML_ScoreAnalyst relies on CatBoost scoring. MAribbonTrader asks an AI to read chart context, while LLMBridgeTrader can manage a position with HOLD, CLOSE and REVERSE decisions. Their losses therefore should not be treated as the same failure. GateGrid lost frequently but kept each leg relatively small. MLScore traded far less, yet one failed position cost more than the combined profit of both BoundSniper systems. MAribbon had another pattern again: its only winner was too small compared with its three stop-outs. That is why the next experiment should focus as much on exit behavior as entry accuracy. GateGrid AI GateGrid AI closed 34 legs and finished -¥141 . It won 13 and lost 21, so the 38.2% win rate was not enough to make the day profitable. The interesting part is its payoff ratio of 1.07. Average profit was about ¥21.5 while average loss was roughly ¥20.0. Even with a low win rate, the size relationship between winners and losers was close to workable. The largest single loss was -¥52. There were several stops around -¥50, but no individual leg became a large accident. On the other side, the bot captured wins of +¥69, +¥40 and +¥33. The +¥69 close was a reminder that the grid can recover several small failures when a sequence finally develops. So I would not start by widening its stop. My first question is why so many candidates still passed the filters. GateGrid is specifically designed to reject weak situations through CatBoost gates, AI_SKIP and OLLAMA_HOLD. If similar market conditions kept producing fresh grids, the selectivity may need more work. There is some uncertainty here because these numbers are individual grid legs rather than complete grid cycles. I want both statistics eventually. A 13W / 21L leg record does not necessarily mean 34 independent trade ideas failed or succeeded. BoundSniper Bot BoundSniper Bot had a clean day: two trades, two wins, +¥84 . The first USDJPY short earned +¥32. The following long earned +¥52. There was no recovery sequence and no losing exit to absorb afterward. Because BoundSniper is an execution bridge, I do not credit the Python bot itself with predicting those moves. TradingView provides the trading signal; BoundSniper’s job is to transport that decision into MT5 and handle the corresponding exit correctly. For this type of bot, execution quality matters more than an AI explanation. I want to know whether the TradingView signal and MT5 fill stayed aligned, whether exits arrived on time, and how much of the theoretical signal profit survived actual execution. LLMBridgeTrader LLMBridgeTrader recorded no closed trade on August 25. That means there is no realized result to judge, but its decision log would still be worth checking. This bot can choose NONE before entry and HOLD, CLOSE or REVERSE once a position exists. A blank MT5 trade history cannot tell me whether the model actively rejected setups or simply never received one worth evaluating. I would leave the trading logic alone based on this day. No trade is not automatically a good decision or a bad one. ML_ScoreAnalyst ML_ScoreAnalyst had one realized trade and lost -¥252 , the largest individual loss of the day. This is the trade I would review first. The system entered GBPJPY long and eventually exited at its stop. Later in the day it opened another GBPJPY position that was still open at the report cutoff, so the -¥252 figure represents realized P&L only. MLScore’s architecture makes the investigation fairly clean. CatBoost decides whether a candidate’s score is high enough to enter, while the execution system applies the configured SL and TP structure. I want to know what score the losing setup received and how far above the threshold it was. Then comes the exit question. Was the setup genuinely strong but unlucky, or did the fixed stop structure allow too much damage relative to the profits this bot usually captures? One loss cannot answer that, but -¥252 against +¥180 from five BoundSniper wins is enough to make position-level loss sizing a priority. MAribbonTrader MAribbonTrader finished -¥157 from four closed trades. The first AUDCAD trade reached TP for +¥34. After that came three stop-outs: -¥66 on AUDJPY, -¥79 on AUDCAD and -¥46 on EURJPY. Its average loss was about ¥63.7 against an average winner of only ¥34, producing a payoff ratio of 0.53. That -¥79 exit bothered me more than the 25% win rate itself. MAribbonTrader is built to read the chart as context: short and long MA ribbons, higher-timeframe structure, support and resistance, ranges and available room. It can also return WAIT rather than forcing an entry. All three realized losses were ultimately handled by hard stops. That does not prove the AI should have exited sooner, but it gives us a useful question for the SQLite logs: did the chart interpretation deteriorate before the SL was reached? There was also another GBPJPY long still open at the end of the report with negative floating P&L. I am excluding that from the -¥157 realized result. Its exit belongs to the next completed result, not this one. BoundSniper Bot2 BoundSniper Bot2, running the bb_pullback_rider signal, produced three wins and +¥96 . The individual profits were +¥14, +¥6 and +¥76. The final trade did most of the work. That is more interesting to me than the 100% win rate, because it shows how one decent winner can change the daily economics even inside a small sample. Together, BoundSniper and Bot2 produced five winning trades and +¥180 without a losing close. They did their part. The fact that the portfolio still ended negative tells us where the risk imbalance sat elsewhere. Closing Thoughts August 25 was not a day when every system struggled. Two of the simpler signal-execution bots went five-for-five. GateGrid’s loss size stayed controlled even though its entry frequency was too high. The damage came from another direction. One MLScore stop was larger than all five bridge-bot winners combined, and MAribbon’s three losing exits were almost twice the size of its only winner on average. The next improvement may not come from making the bots predict more accurately. I suspect it comes from deciding earlier when a prediction no longer deserves more money. 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

2. 34 Losing Legs, Yet a 1.27 Payoff Ratio: GateGrid’s Loss Wasn’t the Scariest One from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

   Aug 24, 20261 min

   Conclusion The six-bot lineup closed August 24 at -¥496 . Across the confirmed exits, there were 27 wins, 37 losses and one break-even. Excluding the flat trade, the win rate was 42.2%. Gross profit reached +¥665, gross loss was -¥1,161, and the combined payoff ratio was 0.78. The number that caught my attention was not the total loss. GateGrid AI produced 34 losing legs, yet its largest single loss was only -¥54 and its payoff ratio still came out at 1.27. ML_ScoreAnalyst, by contrast, needed only one losing trade to drop -¥251. That difference says more about the bots than the headline win rate does. Bot Results ■ GateGrid AI -¥114Record: 22W / 34L / 1BEWin rate: 39.3%Gross profit: +¥535Gross loss: -¥649Payoff ratio: 1.27Max loss: -¥54 ■ BoundSniper Bot +¥78Record: 4W / 0LWin rate: 100.0%Gross profit: +¥78Gross loss: ¥0Payoff ratio: N/AMax loss: ¥0 ■ LLMBridgeTrader -¥192Record: 0W / 1LWin rate: 0.0%Gross profit: ¥0Gross loss: -¥192Payoff ratio: N/AMax loss: -¥192 ■ ML_ScoreAnalyst -¥251Record: 0W / 1LWin rate: 0.0%Gross profit: ¥0Gross loss: -¥251Payoff ratio: N/AMax loss: -¥251 ■ MAribbonTrader -¥69Record: 0W / 1LWin rate: 0.0%Gross profit: ¥0Gross loss: -¥69Payoff ratio: N/AMax loss: -¥69 ■ BoundSniper Bot2 +¥52Record: 1W / 0LWin rate: 100.0%Gross profit: +¥52Gross loss: ¥0Payoff ratio: N/AMax loss: ¥0 ■ Total -¥496Record: 27W / 37L / 1BEWin rate: 42.2%Gross profit: +¥665Gross loss: -¥1,161Payoff ratio: 0.78Max loss: -¥251 Today’s Theme: A Bot Can Lose Often Without Losing Big GateGrid’s 39.3% win rate looks ugly at first glance. The average winning leg, however, was about ¥24.3 while the average losing leg was about ¥19.1. The winners were larger than the losers; there just were not enough of them. That makes GateGrid a very different problem from ML_ScoreAnalyst or LLMBridgeTrader. GateGrid needs better selectivity. The other two need scrutiny around what happens when a trade is already wrong, because one bad exit was expensive enough to outweigh many small GateGrid losses. This is why I do not want to rank these systems from win rate alone. The six bots deliberately use different decision structures: TradingView execution, LLM planning, CatBoost plus Ollama filtering, ML scoring, and chart-reading AI. The useful comparison is not only who wins, but how each architecture behaves when its thesis fails. GateGrid AI GateGrid was by far the busiest bot. It finished at -¥114 after 22 winning legs, 34 losing legs and one flat close. The max loss stayed at -¥54, while gross profit still reached +¥535 against -¥649 of losses. I actually like part of that structure. A 1.27 payoff ratio means the exit size itself was not obviously broken. The harder question is why a bot designed to reject weak situations still generated so many losing legs. GateGrid first uses CatBoost to screen candidates, then passes qualified situations to Ollama, where ATR, trend, session and other context can still lead to a HOLD decision. Its design explicitly emphasizes AI_SKIP and OLLAMA_HOLD when conditions are poor. So I would inspect the entry gates before widening targets or stops. Were the thresholds too loose during a particular session? Did several grids restart under essentially the same market condition? The loss was controlled, but the bot may simply have been too willing to keep trying. There is also a measurement issue worth keeping in mind. These are individual closed legs inside a grid strategy. A later version of this log should probably show both leg-level results and complete grid-cycle results, because 34 losing legs does not necessarily mean 34 independent failed ideas. BoundSniper Bot BoundSniper closed four profitable trades for +¥78 . The individual gains were small, but all four finished on the right side. That is consistent with what I want from this bot. BoundSniper itself is not trying to understand the market; it receives TradingView signals and executes them in MT5. The market intelligence is upstream, while the bot is responsible for getting the entry and exit instructions into the account correctly. Four wins look good, but +¥78 is a useful reality check. One MLScore loss erased more than three times that amount. For BoundSniper, I would keep tracking execution quality and exit timing rather than celebrating a perfect win rate too early. LLMBridgeTrader LLMBridgeTrader finished at -¥192 from one EURUSD trade. There is not enough evidence here to judge the model’s entry accuracy, but one trade is enough to examine its exit process. This bot gives the LLM unusually broad authority. It can return OPEN, HOLD, CLOSE or REVERSE, propose SL and TP distances, and explain both entry and exit reasoning. System-side risk checks still sit around those decisions. That makes the final HOLD decisions especially interesting. If the model continued to defend the position while market evidence deteriorated, the problem may be the exit prompt or the context it receives while a position is open. If the stop was reached before the model had a realistic chance to reassess, the issue may lie elsewhere. I would not touch the entry logic first. I would read the last few position-management logs. ML_ScoreAnalyst ML_ScoreAnalyst took one loss of -¥251 , the largest single hit of the day. This one made me stop because GateGrid spent an entire active session accumulating losses and still finished with less than half that net damage. The architecture is simpler than the LLM bots. ML_ScoreAnalyst detects candidates, scores them with CatBoost, and enters only above its configured threshold. The system also records scores and features so those trades can later be used for threshold testing and retraining. There are two obvious suspects, and I would not choose between them yet. The model may have scored a weak breakout too highly, or the fixed exit geometry may have been poorly matched to that GBPJPY environment. One losing sample cannot settle it. What it can settle is priority. A -¥251 loss deserves review before another small threshold adjustment elsewhere. MAribbonTrader MAribbonTrader closed one GBPJPY long at -¥69 . The trade was short-lived, so I am more interested in whether BUY should have been WAIT than in the amount itself. This bot is supposed to read a chart more like a discretionary trader. It combines the short and long MA ribbons with higher-timeframe context, support and resistance, range structure, channels and other visual information, then lets the AI choose BUY, SELL, WAIT or EXIT. The stored decision log should tell us whether the setup really had enough room to move. Perhaps the entry was early. Perhaps the chart was acceptable and the stop simply got clipped. I would want to see the image and the reasoning before changing anything. The loss was at least contained. At -¥69, it did not dominate the portfolio. BoundSniper Bot2 BoundSniper Bot2 finished +¥52 from one winning trade. It uses the same basic bridge concept as BoundSniper but references a different indicator, giving the two bots a useful long-term A/B comparison. One trade tells us almost nothing about which indicator is stronger. It does show a clean outcome: the signal was executed, the position survived long enough to move in the intended direction, and the exit banked the gain. Summary August 24 was a losing day, but the useful part is how unevenly that loss was produced. GateGrid lost repeatedly while keeping each individual hit small. ML_ScoreAnalyst and LLMBridgeTrader barely traded, yet their two losses together accounted for -¥443. That is the comparison I want to keep following. The most dangerous bot may not be the one that loses most often. It may be the quiet one that is allowed to be wrong for too long. ② Substack Note GateGrid AI went 22W / 34L / 1BE and still kept its max loss to just ¥54. Its payoff ratio was 1.27. ML_ScoreAnalyst traded once and lost ¥251. Six-bot result for Aug. 24: -¥496 . That is the experiment I care about now: not only how often each bot is wrong, but how expensive one wrong decision is allowed to become 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

3. One Small Loss Was Enough: LLMBridgeTrader Led the Six Bots With a 4.18 Payoff Ratio from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

   Aug 22, 20261 min

   The six bots finished the session at +476 yen across 41 closed trades. LLMBridgeTrader was the strongest contributor at +346 yen. BoundSniper followed at +214 yen, ML_ScoreAnalyst added +72 yen, while GateGrid AI lost 140 yen and MAribbonTrader slipped 16 yen below zero. The interesting number for me is not LLMBridgeTrader’s 80% win rate. It is the 4.18 payoff ratio . Four winners produced +368 yen, while the only losing trade cost 22 yen. That is almost the opposite of what MAribbonTrader showed: it won two of three trades, yet its one large loss was enough to leave the bot negative. Today was another reminder that an AI bot does not need to avoid every mistake. It needs to make sure a mistake stays a mistake, rather than turning into the trade that defines the whole day. Bot Results ■ GateGrid AI -140 yenRecord: 6W / 18LWin rate: 25.0%Gross profit: +111 yenGross loss: -251 yenPayoff ratio: 1.33Max loss: -50 yen ■ BoundSniper Bot +214 yenRecord: 8W / 0LWin rate: 100.0%Gross profit: +214 yenGross loss: 0 yenPayoff ratio: N/A, no losing tradesMax loss: 0 yen ■ LLMBridgeTrader +346 yenRecord: 4W / 1LWin rate: 80.0%Gross profit: +368 yenGross loss: -22 yenPayoff ratio: 4.18Max loss: -22 yen ■ ML_ScoreAnalyst +72 yenRecord: 1W / 0LWin rate: 100.0%Gross profit: +72 yenGross loss: 0 yenPayoff ratio: N/A, no losing tradesMax loss: 0 yen ■ MAribbonTrader -16 yenRecord: 2W / 1LWin rate: 66.7%Gross profit: +81 yenGross loss: -97 yenPayoff ratio: 0.42Max loss: -97 yen ■ BoundSniper Bot2 0 yenRecord: No tradesWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen ■ Total +476 yenRecord: 21W / 20LWin rate: 51.2%Gross profit: +846 yenGross loss: -370 yenPayoff ratio: 2.18Max loss: -97 yen Today’s Theme: A Good AI Exit Does Not Need to Be Pretty LLM trading experiments often get framed around prediction. Did the model call BUY at the right moment? Did it read the trend correctly? Was the confidence score high enough? I am starting to care more about a different question. What does the system do after the original idea begins to fail? LLMBridgeTrader had one losing bb_pullback_rider trade at -22 yen. It did not need the other four trades to be perfect monsters to recover from it. The winners averaged 92 yen, so one ordinary winner was already several times larger than the day’s only loss. MAribbonTrader produced a very different shape. Two winners totaled +81 yen, but one losing position cost 97 yen after swap. The win rate was higher than 60%, yet the day still ended negative. That gap is basically today’s experiment. GateGrid AI: The Gates Let Too Many Trades Through GateGrid AI closed 24 positions and lost on 18 of them. The final result was -140 yen, with +111 yen in gross profits against -251 yen in gross losses. Its 25% win rate looks rough, although the payoff ratio of 1.33 shows that the average winning trade was still larger than the average loser. The average win was 18.5 yen. The average loss was about 13.9 yen. That part is not disastrous. What bothers me more is the frequency. A system built around CatBoost filtering and an additional LLM-style gate is supposed to reject marginal situations. On this day, enough trades passed through to produce 18 losing exits. One -50 yen loss also stands out against a group that was otherwise dominated by much smaller cuts. My next check would be the actual gate logs around those losing entries: model score, session, ATR, trend state and the local-LLM decision. Maybe the threshold was simply too permissive for this market regime. I cannot prove that from the MT5 statement alone. BoundSniper Bot: The Execution Baseline Stayed Clean BoundSniper recorded eight wins and no losses for +214 yen. The individual gains were not huge, but they were consistent. The average closed trade made 26.75 yen, with no large outlier required to save the day. Because BoundSniper does not make its own market forecast, I still like using it as a control group. TradingView generates the signal and the bot handles delivery and execution in MT5. When the more autonomous systems struggle, this gives me something simpler to compare them against. Eight trades are not enough to declare the underlying signal logic solved, but there was no obvious exit problem in today’s realized results. LLMBridgeTrader: One Loss, Then Plenty of Room to Recover LLMBridgeTrader includes both the trades explicitly labeled LLMBridgeTrader and the bb_pullback_rider trades. The bb_pullback_rider closes were +96, -22 and +50 yen. The EURUSD LLMBridge side then added +127 and +95 yen. Together, that gives +346 yen from five trades . The shape is what I like. Four winners averaged 92 yen, while the only loser was -22 yen. A 4.18 payoff ratio leaves a lot of room for the model to be wrong occasionally. The two EURUSD exits are also interesting because both appear with stop-related comments despite closing in profit. As on the previous session, that looks like profit had been protected before the stop was hit. I still cannot tell from the MT5 statement whether the LLM itself decided to tighten the exit or whether a deterministic management layer did it. That distinction matters because LLMBridgeTrader is designed to reason about OPEN, HOLD, CLOSE and REVERSE, not merely direction. The decision log I want now is the sequence before those exits. What did the model say while the position was profitable? When did its reasoning move from “keep holding” to “protect what is already here”? That would tell me much more than the 80% win rate. ML_ScoreAnalyst: One Trade, One Useful Win ML_ScoreAnalyst had only one closed GBPJPY trade. It made +72 yen. The exit is marked as a stop, yet the trade ended in profit. Again, that suggests a stop had moved into profitable territory. That is a good result, but there is almost nothing to infer about CatBoost accuracy from one trade. The score threshold needs a much larger sample, including losing ENTER decisions and rejected SKIPs. For now, I would record the result and resist making a story out of it. MAribbonTrader: 66.7% Win Rate, Still Negative MAribbonTrader is the clearest example of why I keep calculating payoff ratio. It won two of its three closed trades. EURUSD added +33 yen and GBPCAD added +48 yen. But the AUDJPY position produced a -106 yen trading loss, partly offset by +9 yen in swap, leaving that trade at -97 yen net. I saw the -97 yen and immediately went back to the other two numbers. They simply were not large enough to absorb it. The bot finished at -16 yen even with a 66.7% win rate. Its payoff ratio was only 0.42. MAribbonTrader is also the system where AI interpretation matters most. It receives ribbon structure, higher-timeframe context, support and resistance, ranges and other chart information, then decides whether to BUY, SELL, WAIT or EXIT. That makes the AUDJPY loss the trade I would open first in the reasoning log. Was the setup still valid near the end? Did the model keep choosing HOLD after the original structure had broken? Or was -97 yen simply inside the planned risk from the beginning? I suspect the answer is somewhere in the exit logic, but I would not call it yet. BoundSniper Bot2: No Trade Data This Time No transaction details for BoundSniper Bot2 were included in the new report, so I am counting it as no trade for August 21. That is better than inventing a result from an absent statement. Once its next transactions appear, it can return to the comparison with the original BoundSniper signal source. Closing Thoughts The portfolio barely had more winners than losers: 21 versus 20. Yet the total payoff ratio was 2.18 and the day ended at +476 yen. That is the part I want to keep. LLMBridgeTrader did not win because it never made a mistake. It won because its only mistake was small relative to what the winners paid. MAribbonTrader showed the reverse, while GateGrid AI exposed another issue entirely: too many trades making it through a system designed to filter aggressively. I am less interested now in asking whether an LLM can predict the next move. I want to know whether it can recognize when its previous idea no longer deserves capital. 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

4. Exit Control, Not Win Rate, Decided the Day from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

   Aug 20, 20261 min

   Conclusion The Aug. 20 run finished at +1,236 yen across the six currently documented Bot instances. Four finished positive and two negative. The result looks comfortable at first glance, but the interesting part was not the total. It was how differently the Bots lost. GateGrid AI ended slightly negative at -35 yen, yet its worst realized loss was only -19 yen. MAribbonTrader lost -261 yen with a maximum loss of -127 yen and a payoff ratio of just 0.36. I stopped for a moment at that -127 yen because its average winning trade was only about 32 yen. That gap matters more to me than the headline win rate. BoundSniper, BoundSniper Bot2, LLMBridgeTrader and ML_ScoreAnalyst recorded no realized losing trades in the statement. That is a strong day, but not proof that their risk structure is solved. A zero-loss sample also means the payoff ratio cannot be calculated yet. Bot Results ■ GateGrid AI -35 yenRecord: 9W / 15L (Win rate 37.5%)Gross profit: +147 yenGross loss: -182 yenPayoff ratio: 1.35Max loss: -19 yen ■ BoundSniper Bot +590 yenRecord: 13W / 0L (Win rate 100.0%)Gross profit: +590 yenGross loss: 0 yenPayoff ratio: N/A, no losing tradesMax loss: 0 yen ■ LLMBridgeTrader +509 yenRecord: 4W / 0L (Win rate 100.0%)Gross profit: +509 yenGross loss: 0 yenPayoff ratio: N/A, no losing tradesMax loss: 0 yen ■ ML_ScoreAnalyst +173 yenRecord: 2W / 0L (Win rate 100.0%)Gross profit: +173 yenGross loss: 0 yenPayoff ratio: N/A, no losing tradesMax loss: 0 yen ■ MAribbonTrader -261 yenRecord: 3W / 4L (Win rate 42.9%)Gross profit: +95 yenGross loss: -356 yenPayoff ratio: 0.36Max loss: -127 yen ■ BoundSniper Bot2 +260 yenRecord: 2W / 0L (Win rate 100.0%)Gross profit: +260 yenGross loss: 0 yenPayoff ratio: N/A, no losing tradesMax loss: 0 yen ■ Total +1,236 yenRecord: 33W / 19L (Win rate 63.5%)Gross profit: +1,774 yenGross loss: -538 yenPayoff ratio: 1.90Max loss: -127 yen The broker statement also contains seven profitable bb_pullback_rider exits totaling +328 yen on the same account as LLMBridgeTrader. I left those trades outside this Bot roster because that strategy is not one of the six runners described in the current operating memo. Today’s Theme: The Exit Is Where the Bots Separate These Bots do not make decisions in the same way. BoundSniper mainly executes TradingView signals, ML_ScoreAnalyst scores candidates with CatBoost, GateGrid adds multiple gates including local-AI judgment, and MAribbonTrader asks Qwen to interpret chart structure closer to discretionary trading. LLMBridgeTrader goes further and lets the LLM consider OPEN, HOLD, CLOSE and REVERSE, along with SL and TP proposals. That makes the exit particularly interesting. Entry accuracy alone cannot explain whether the LLM is useful. If the model reads the chart correctly but keeps a bad trade too long, closes winners too early, or proposes an asymmetric stop structure, the final P/L will expose it. Today gave a clean example of that difference. GateGrid AI GateGrid lost more often than it won, with 9 winners against 15 losers. On win rate alone, 37.5% looks weak. But its average winner was roughly 16 yen while its average loser was about 12 yen, producing a 1.35 payoff ratio. More importantly, the largest realized loss was only -19 yen. Seeing fifteen losses and still ending at only -35 yen is not comfortable, but it is a very different problem from an uncontrolled tail loss. The entry gate may have been too permissive for the conditions, or the grid created too many marginal attempts. I cannot establish the cause from the broker statement alone. The exit and loss containment, however, did not blow up. One detail worth checking later is configuration drift: today’s statement labels the GateGrid v4 executions on USDJPY-, while the operating description documents GateGrid AI as an EURUSD system. The two sources do not explain that difference. BoundSniper Bot BoundSniper produced 13 winners from 13 completed trades and +590 yen. Since this Bot does not predict the market itself, I read this less as an “AI was right” result and more as a strong day for the TradingView signal plus execution chain. The exits were also consistently positive. The largest realized win was +138 yen, while no losing close appeared in the statement. Still, 100% is a dangerous number to get excited about. There is no losing trade here, so there is no payoff ratio and no evidence from this single day about what happens when the TradingView exit arrives late. Today tells me the pipeline worked. It does not tell me the worst-case behavior yet. LLMBridgeTrader LLMBridgeTrader was the most interesting positive result for the LLM experiment. Four EURUSD trades closed for +127, +127, +125 and +130 yen, totaling +509 yen. The broker comments on those exits are shown as stop-related closes. That suggests profit was ultimately realized through stop handling, but the statement alone cannot tell me whether the LLM itself decided to exit, whether a Bot-side rule moved the stop, or exactly how the HOLD/CLOSE logic contributed. That distinction is worth preserving in the logs. For an LLM that is allowed to choose OPEN, HOLD, CLOSE and REVERSE, I want to know not just that a trade made +130 yen, but why the position was still held five minutes earlier and why it was no longer held at the end. Today’s P/L is excellent. The next useful evidence is the decision trace. ML_ScoreAnalyst ML_ScoreAnalyst completed two GBPJPY trades, both winners, for +173 yen in total. The two exits were +84 and +89 yen, which is unusually consistent. This Bot has a narrower job than the LLM systems. CatBoost scores an entry candidate and the surrounding safety logic decides whether to send the order. With only two trades, there is little to say statistically, but there was no obvious sign of the model taking low-quality entries and then relying on a large stop to escape. The sample is simply too small. I would rather keep collecting score, time-of-day and volatility context than raise confidence because of a 2-for-2 day. MAribbonTrader MAribbonTrader is where today’s result changes tone. It won three trades and lost four, so the 42.9% win rate is not disastrous by itself. The problem is the size distribution. The three winners totaled only +95 yen. The four losers totaled -356 yen. Average win was about +32 yen, while average loss was -89 yen, leaving a payoff ratio of 0.36. With that structure, a modest improvement in entry accuracy will not fix much. The -125 and -127 yen losses stood out. Again, this is the part that bothers me more than the number of losing trades. MAribbonTrader is designed to feed chart images, MAribbon structure, higher-timeframe context, support/resistance and other visual context into Qwen, then let the AI return BUY, SELL, WAIT or EXIT. That makes the exit decision central to the experiment. Maybe the issue is the initial stop width. Maybe it is holding through a setup invalidation that a discretionary trader would have abandoned earlier. I do not have enough evidence from the statement to choose between those explanations yet. There was also an AUDJPY position still open at the end of the report with -31 yen unrealized P/L, which I did not include in the realized performance statistics. BoundSniper Bot2 Bot2 closed two USDJPY trades for +138 and +122 yen. That is +260 yen with no realized loss. Because the core logic is described as the same BoundSniper execution architecture with a different referenced indicator, this creates a useful comparison. The infrastructure can remain largely fixed while the upstream signal source changes. Two trades are nowhere near enough to rank the indicators. But keeping the two variants separate in the logs may eventually tell us whether one generates cleaner exits rather than merely more entries. Summary The day was profitable, but the result I want to carry forward is not +1,236 yen. GateGrid showed that a low win rate can stay manageable when individual losses remain small, while MAribbon showed the opposite problem: a few winners cannot compensate when the losing side is almost three times larger on average. The LLMBridge result is promising, especially because all four completed EURUSD trades ended with similar profits. Still, I want the next analysis to connect those results to the model’s actual HOLD, CLOSE and stop-adjustment logs. Today the machines did not mainly differ in whether they could find a trade. They differed in what happened after they were already in one. 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

5. One Friday Carryover Broke Monday’s Result — So I Changed the MAribbon Bot from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

   Aug 17, 20261 min

   August 17, 2026 — Five MT5 bot families finished at -342 yen. The bigger lesson was not entry accuracy. It was what one position was allowed to do after Friday. Conclusion The five-bot run ended with a realized P/L of -342 yen. That number looks like an ordinary losing day until I separate MAribbonTrader from its Friday carryover. Its three positions opened on Monday made +206 yen in total. The old GBPCHF position carried from Friday lost -682 yen in trading P/L, partly offset by +18 yen of swap. That single carryover changed the entire shape of the day. The -682 yen line made me stop for a second. The Monday entries were not the main problem. The position lifecycle was. I changed MAribbonTrader so it will no longer carry positions over. Bot Performance ■ GateGrid AI -120 yenRecord: 22W / 22L / 1 flatWin rate: 50.0% excluding the flat tradeGross profit: +406 yenGross loss: -526 yenPayoff ratio: 0.77Max loss: -89 yen ■ BoundSniper family +47 yenRecord: 3W / 0LWin rate: 100.0%Gross profit: +47 yenGross loss: 0 yenPayoff ratio: N/A, no losing tradesMax loss: N/A, no losing trades ■ LLMBridgeTrader +189 yenRecord: 1W / 0LWin rate: 100.0%Gross profit: +189 yenGross loss: 0 yenPayoff ratio: N/A, no losing tradesMax loss: N/A, no losing trades ■ ML_ScoreAnalyst 0 yenRecord: No tradesWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: N/A ■ MAribbonTrader -458 yenRecord: 2W / 2LWin rate: 50.0%Gross profit: +254 yenGross loss: -730 yenSwap: +18 yenPayoff ratio: 0.35Max loss: -682 yen ■ Total -342 yenRecord: 28W / 24L / 1 flatWin rate: 53.8% excluding the flat tradeGross profit: +896 yenGross loss: -1,256 yenSwap: +18 yenPayoff ratio: 0.61Max loss: -682 yen Today’s Theme: The Exit Rule Mattered More Than the Entry Model MAribbonTrader is one of the bots where I give AI more room to read context. It looks at the chart, moving-average ribbons, higher-timeframe structure, support and resistance, ranges, and other information before deciding between BUY, SELL, WAIT and EXIT. That makes entry quality interesting, but today the experiment exposed a more basic problem. A sophisticated chart reader still needs hard rules around when a position is no longer allowed to exist. The GBPCHF trade had survived from Friday into Monday. It finally closed at -682 yen before swap. Meanwhile, the three positions actually opened on Monday produced +71 yen on USDCAD, +183 yen on GBPJPY and -48 yen on EURJPY. That is +206 yen from the new Monday trades. I did not expect that contrast to be this clean. The AI’s Monday decisions were profitable as a group, but an older position overwhelmed them. So I treated this less as a prompt problem and more as a system-design problem. I changed the Bot to prevent positions from being carried over. GateGrid AI GateGrid closed 45 positions, with 22 winners, 22 losers and one flat result. A 50% win rate does not look bad by itself, but the payoff ratio tells the less comfortable part of the story. Average winners were smaller than average losers. The payoff ratio was 0.77. That is why 22 wins against 22 losses still ended at -120 yen. There was no catastrophic hit here; the maximum single loss was only -89 yen. The leak was distributed across the exit profile. GateGrid uses multiple filters rather than blindly opening a grid. CatBoost and local AI can help decide when not to enter, but this result says the post-entry side deserves the same attention. If the average losing leg remains larger than the average winner, better filtering alone may not fix the curve. The cause may be exit timing, grid closure behavior, or the shape of the underlying entries. I do not have enough from the MT5 report alone to pin that down yet. BoundSniper Family The two BoundSniper variants produced three winners for a combined +47 yen. There were no losing closes, so the payoff ratio cannot be evaluated yet. Three trades are also far too few to treat the 100% win rate as evidence of an edge. This Bot family is different from the LLM-driven systems anyway. BoundSniper mainly carries TradingView instructions into MT5, so I judge it partly as an execution layer: did the intended trades reach MT5, and were they closed correctly? On August 17, nothing in the realized results suggests an execution problem. LLMBridgeTrader LLMBridgeTrader had one EURUSD short and made +189 yen. The entry was at 1.16137. The original order showed a stop around 1.16256 and a target around 1.15956, while the eventual exit was around 1.16018 with the closing record referencing a stop near 1.16016. That looks like a position where the stop was eventually brought into profitable territory instead of simply waiting for the original target or loss limit. I like this exit much more than a high win-rate number. There is one limitation in today’s material: the MT5 report does not contain the LLM’s actual reasoning log, so I cannot say whether the stop adjustment came directly from the model or from the Bot’s risk-management layer. That distinction is worth checking in the decision logs. ML_ScoreAnalyst ML_ScoreAnalyst made no trades. For a scoring Bot, zero trades are not automatically a failure. It is designed to filter candidates and enter only when the CatBoost score clears its threshold. There is nothing to calculate for payoff ratio or maximum loss today. The useful question is whether the lack of entries came from correctly rejecting weak setups or from a threshold that has become too restrictive. The MT5 report alone cannot answer that. MAribbonTrader MAribbonTrader ended at -458 yen, and the raw win rate was 50%. The payoff ratio was only 0.35 because the two losses were heavily unbalanced against the winners. The -682 yen GBPCHF close did almost all the damage. Again, seeing that number next to +71 and +183 made the problem hard to ignore. But removing the Friday carryover changes the picture. Monday’s newly opened trades were two wins and one loss for +206 yen. The biggest new loss was only -48 yen. The old position was the outlier. MAribbonTrader is supposed to use AI for chart context and discretionary-style decisions. After this result, I do not want the model to solve every risk problem by reasoning harder. Some boundaries should simply be code. The new no-carry behavior is one of those boundaries. Wrap-up The five-bot portfolio lost money on August 17, but I came away less worried about Monday’s entries than the headline result suggests. GateGrid needs a better balance between average winners and losers. LLMBridge showed a promising profitable exit. BoundSniper executed cleanly, ML_ScoreAnalyst stayed inactive, and MAribbon’s fresh Monday trades actually held up. The trade that mattered most was already alive before Monday began. Sometimes the best upgrade to an AI trader is not another model, another indicator, or a longer prompt. It is one boring rule that refuses to let an old mistake survive into the next session. ② Substack Note MAribbonTrader gave me an uncomfortable result on Aug. 17. Its new Monday trades were profitable as a group, but a GBPCHF position carried from Friday took a -682 yen trading loss and dragged the Bot to -458 yen realized. Across the five bot families, the day finished at -342 yen. The interesting part wasn’t the win rate. GateGrid was 22W/22L and still lost money because its payoff ratio was only 0.77. I’ve now changed MAribbon so positions won’t be carried over. For this run, the biggest lesson came from the exit architecture, not the entry model. 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

6. Every Bot Finished Green, but Two One-Trade Systems Made Two-Thirds of the Money from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

   Aug 15, 20261 min

   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

7. Two Bots Erased the Other Four’s +¥218 from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

   Aug 14, 20261 min

   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

8. A 59% Win Rate Still Lost Money: GateGrid’s Exit Math Was the Problem from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

   Aug 12, 20261 min

   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

9. One -¥301 Loss Flipped the Whole Day: Five MT5 Bots Closed at -¥294 from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

   Aug 11, 20261 min

   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

10. Don’t Lower Your Standards Just Because the Numbers Are Bad from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

    Aug 8, 20261 min

    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

11. [AI Trading Log] Whispering Winners, Loud Losers from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

    Aug 7, 20261 min

    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

12. Ten Wins Still Ended Negative: Five MT5 Bots Exposed an Exit Problem from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

    Aug 5, 202619 min

    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

13. [AI Trading Log] Exits Made the Difference: Five-Bot Portfolio Covers Each Other’s Weaknesses (July 30 to July 31) from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

    Aug 1, 20261 min

    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

14. [AI Trading Log] Surviving FOMC and the Trap of High Win Rates: from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

    Jul 30, 20261 min

    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

15. The Exit Layer Won: Five MT5 Bots Closed at +¥624 from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

    Jul 27, 20261 min

    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

16. Winning 57% Wasn’t Enough: GateGrid’s Exit Math Sank the Five-Bot Day from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

    Jul 25, 20261 min

    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

17. Stops That Paid: Two AI Bots Banked ¥599 and Carried the Five-Bot Run from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

    Jul 24, 20261 min

    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

18. Four Wins, Two Losses, Still Down: The Exit Math Beat the Hit Rate from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

    Jul 22, 20261 min

    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

19. If You Keep Fixing the Strategy, You May Lose the Ability to Understand It from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

    Jul 22, 20261 min

    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

20. It Wasn’t the Entry or the Exit: Why I Moved GateGrid AI From GBPUSD to EURUSD from AI FX Bot Lab: Real Trading Experiments, opens in a new tab

    Jul 21, 20261 min

    My five MT5 trading bots finished July 20 with a combined realized loss of ¥542. The closed trades produced three wins and five losses. The average winning trade made ¥32.7, while the average losing trade lost ¥128. That gives an average payoff ratio of only 0.26. BoundSniper Bot was the only system to finish positive, earning ¥16. GateGrid AI lost ¥151, LLMBridgeTrader lost ¥167, and ML_ScoreAnalyst lost ¥240. I did not receive a confirmed report for MAribbonTrader, so I recorded it as an unverified ¥0 rather than assuming that it made no trades. When I first reviewed the day, I thought the main issue was the exit logic. Several different bots were producing the same pattern: small profits were closed quickly, while larger losses were allowed to remain. That interpretation was not completely wrong. However, after a deeper investigation into GateGrid AI, I reached a different conclusion. The exits were weak, but improving them was not enough. Better entry selection was not enough either. The GBPUSD version of the strategy could not produce a positive expected value under realistic trading costs. The real issue was not simply how intelligent the bot was. It was the relationship between the strategy, the currency pair, and the cost paid on every trade. The July 20 loss became the final reason to reconsider whether GateGrid AI should continue trading GBPUSD at all. Results by Bot GateGrid AI: -¥151 GateGrid AI traded GBPUSD and finished with zero wins and two losses. A buy stop was triggered first. The sell-side order was then triggered as well, and both positions were closed roughly one second later. The two results were -¥135 and -¥16. Looking only at this sequence, the problem appeared to be the position-management process after the opposite side was filled. Should the system keep both positions as a hedge? Should it treat the second fill as a reversal and close the first position? Should it classify the situation as abnormal and close everything? The trade report did not show which rule caused the exit. In the past, I would have responded by adding more detailed exit logs and adjusting the position-management logic. In fact, I had already made many such adjustments. The long-term performance still failed to improve. BoundSniper Bot: +¥16 BoundSniper Bot traded USDJPY. It bought at 162.348 and closed approximately four minutes later at 162.364, producing a ¥16 profit. One trade is not enough to evaluate the quality of the underlying signal. However, the execution path worked correctly. The bot received the TradingView webhook, placed the MT5 order, closed the position, and left nothing open. BoundSniper Bot does not predict the market by itself. Its job is to carry an external TradingView signal into MT5. For that reason, the important risks are different: communication latency, duplicate orders, symbol conversion failures, rejected orders, and missed exits. The profit was small, but the execution process was clean. LLMBridgeTrader: -¥167 LLMBridgeTrader traded EURUSD. Its three results were -¥141, +¥73, and -¥99. That produced one win and two losses. The average win was ¥73, while the average loss was ¥120, giving an average payoff ratio of 0.61. All three positions were closed at market before reaching their original stop-loss or take-profit levels. This suggests that the LLM-based OPEN, HOLD, CLOSE, and REVERSE decision process was active. But an active decision process is not necessarily a profitable one. Did the model close profitable trades too early? Did it correctly detect a reversal? Did it wait longer when a position was losing than when it was winning? The trade history alone cannot answer those questions. The system needs to record the model name, prompt version, market inputs, confidence score, proposed action, final action, and exact exit reason for every decision. ML_ScoreAnalyst: -¥240 ML_ScoreAnalyst traded GBPJPY. It produced one ¥9 profit and one ¥249 loss. Its average payoff ratio was only 0.04. It would take nearly 28 wins of ¥9 to recover a single ¥249 loss. This bot uses a CatBoost score to select entries. However, a high entry score is not enough when the expected price movement is much smaller than the stop-loss distance. Raising the score threshold alone will not solve the problem. The score threshold, trading session, ATR, entry volatility, stop distance, and target distance need to be tested as one combined policy. The bot also carried an unrealized loss of ¥97 into the next day. That unrealized amount was not included in the realized loss of ¥542. Including it would bring the total daily mark-to-market result to -¥639. MAribbonTrader: Unverified ¥0 I did not receive a July 20 trade report for MAribbonTrader. I therefore recorded it as an unverified ¥0 rather than declaring that it made no trades. For an LLM bot that reads chart images, BUY and SELL are not the only meaningful outputs. WAIT and EXIT are also decisions. The input image, higher-timeframe context, support and resistance levels, model response, and reason for waiting should all be recorded. A day with no trades can still contain valuable information, but only if the system distinguishes between deliberately waiting and failing to run. GateGrid AI Was Winning Most Trades and Still Losing Money I did not judge GateGrid AI from the two losses on July 20 alone. Across its live trading history, the bot won approximately 62–68% of its trades. At first glance, that appears acceptable. Despite that win rate, its live profit factor was only 0.62, and its lifetime loss was approximately ¥19,000. The problem was not just an occasional large loss. The system was losing small amounts on an almost daily basis. Converted into pips, the average winning trade made only 4.3 pips, while the average losing trade lost 15.3 pips. The average loss was roughly 3.5 times larger than the average win. With that payoff structure, the break-even win rate is approximately 78%. The actual win rate of 62–68% was not close enough. A minor improvement in entry accuracy could not bridge the gap. This asymmetry was not simply a programming bug. GateGrid AI closes profitable positions relatively quickly and adds exposure when the market moves against the grid. Small gains are collected frequently, but losing baskets become much heavier. The negative skew was embedded in the strategy itself. GBPUSD Trading Costs Were Too Large Relative to the Average Win Spread was another factor quietly damaging the system. In live observations, GBPUSD spread sometimes reached roughly 1.2 pips. For a strategy whose average winning trade was only 4.3 pips, that cost was substantial. A 1.2-pip spread consumes about 28% of the gross winning distance. In my cross-pair simulations, I used a 0.7-pip spread for GBPUSD. Even under that more favorable assumption, it remained expensive compared with the roughly 0.3-pip conditions available on EURUSD and USDJPY. For a strategy targeting large moves, a difference of 0.4 pips may be relatively minor. For a system repeatedly collecting around four pips, that difference sits near the center of the expected value calculation. Reducing the spread paid on every trade can matter more than improving entry accuracy by a few percentage points. I Had Already Made Extensive Exit Adjustments GateGrid AI’s exits had not been ignored. I increased the trailing ratchet from 0.7 to 0.9. I added a time-decay mechanism that gradually reduced the global stop-loss distance to 15 pips after 180 minutes. I introduced an ¥800 basket loss limit. I blocked new entries on Mondays and before the trading curfew. These changes reduced the size of the tail losses. However, they did not close the gap between the required 78% win rate and the actual win rate of roughly 68%. Exit adjustments could reduce the severity of the losses, but they could not reverse the expected value of the strategy. That left one remaining possibility: improve the entries. Six Attempts to Improve Entry Quality Failed I used one rule for every experiment. A change would only be accepted if it improved performance consistently across multiple periods. A policy that worked in only one selected period would not be considered valid. Regime Switching I tested a model designed to classify whether the market was ranging or breaking out and then change the grid behavior accordingly. The holdout AUC was 0.57, and the resulting trading policy showed no improvement. The model could describe something resembling market conditions, but it could not separate profitable conditions from unprofitable ones. Gate Model Version 2 I used 16,715 previously unused market snapshots and generated counterfactual labels to rebuild the entry gate. The real holdout AUC reached 0.61. Despite the higher classification score, the trading policy became worse by ¥46 per trade. A model can improve its statistical metric while reducing actual trading performance. This experiment also revealed that the existing combined policy of threshold filtering, Ollama judgment, and the clean gate was better than simply sorting trades by the model score. Replacing the LLM I attempted a shadow test using gpt-oss:20b in place of the current Ollama decision model. Under the current configuration, however, the model returned empty responses. It appeared faster only because it was not producing a usable decision. The comparison could not evaluate judgment quality, so the replacement was rejected. One-Sided Grids Ollama produced a directional opinion on nearly every setup, yet the grid placed orders on both sides roughly 98% of the time. I tested using the direction signal to place orders on only one side. The result was -¥268 over the full period and +¥441 over the recent period. It improved one period while damaging another, leaving the combined result close to neutral. The cost of two-sided whipsaws was replaced by larger losses when the directional prediction was wrong. Full Exit-Space Search I performed a broad parameter search across trailing settings, global take-profit levels, and global stop-loss levels. I could not find a stable region where the actual win rate exceeded the required break-even win rate. Widening the winning distance reduced the win rate. Preserving the win rate kept the winning distance too small. Changing the global take-profit level often had little effect because the trailing logic closed profitable positions first. The asymmetry moved around the parameter space, but it did not disappear. Trend Capture The final idea was to trade only when the post-entry price movement developed into a strong trend. The correlation between realized profit and actual post-entry trend strength was only +0.03. It was effectively zero. GateGrid AI did not consistently win because the market trended, nor did it consistently win because the market ranged. Its results depended heavily on the exact price path after entry. Even perfect knowledge of future trend strength would not have separated the winning trades well enough. There May Have Been Very Little Signal to Predict GateGrid AI produced only one profitable day across 13 trading days in July. That day was July 14, when it earned ¥852. However, Tuesday itself was not consistently profitable, and no reliable time window remained after excluding that single day. The reason the predictive models remained around an AUC of 0.5 may not have been model weakness alone. There may have been very little useful entry-time signal separating future winners from future losers. The strategy’s average result was pulled slightly below zero by transaction costs, while path-dependent noise created wide fluctuations around that negative mean. In that environment, a more complicated model has very little stable structure to learn. When the Strategy Cannot Be Fixed, Change the Market After the other experiments failed, transaction cost remained the main variable that could still be changed. Using the same GBPUSD price movement but reducing the simulated spread from 0.7 pips to 0.3 pips improved the recent profit factor from 0.80 to 0.96. That was still below break-even. However, it closed a large portion of the gap and confirmed that spread was a major factor. I then examined the conditions already available in the same GaitameFinest account. EURUSD and USDJPY were already offered at roughly 0.3 pips. There was no immediate need to search for a different broker or a separate raw-spread account. GBPUSD was simply the relatively expensive pair. The question changed. Instead of asking how to improve entry selection on GBPUSD, I began asking what would happen if the same grid strategy traded a lower-cost currency pair. EURUSD Was the Only Pair That Remained Positive Across Both Periods I tested the same strategy and the same exit policy across several currency pairs using their actual spread assumptions. I split the evaluation into an earlier April–May period and a later May–July period. GBPUSD produced a profit factor of 1.33 in the first period and 0.87 in the second. It was profitable in one environment and unprofitable in another. EURUSD produced a profit factor of 1.19 in the first period and 1.18 in the second. The numbers were not spectacular. What mattered was that the sign did not reverse when the period changed. After several weeks of testing, this was the first configuration that remained profitable across both out-of-sample segments. The improvement came from two factors. First, the spread was only about 0.3 pips. Second, EURUSD’s lower volatility produced shallower average losses. The average loss was approximately ¥305 on EURUSD, compared with about ¥371 on GBPUSD. The win-to-loss relationship improved from roughly 1:3.5 to about 1:2.5. The required break-even win rate fell to approximately 71%, while the actual win rate was about 75%. For the first time, the observed win rate exceeded the required win rate. The EURUSD version also worked without the GBPUSD-specific gate model. I did not need to rebuild the entire entry model. Allowing entries through without that gate produced a more stable result. Narrowing the Grid Step Made the Results Worse EURUSD is less volatile than GBPUSD. The intuitive response would be to reduce the grid spacing to match the smaller price movement. That adjustment made the results worse. The wider four-pip step originally designed for GBPUSD remained the strongest configuration. Its profit factor stayed around 1.16–1.21 across the two periods. A narrower grid caused both buy and sell orders to be triggered more often by small price oscillations. The wider spacing reduced the number of entries but also acted as a filter against two-sided whipsaws. The obvious rule that a lower-volatility pair needs a narrower grid turned out to be incorrect. I Switched the Live System to EURUSD on July 21 On July 21, with no open position and no active order exposure, I changed the main GateGrid AI system from GBPUSD to EURUSD. The position size remained 0.01 lots. The GBPUSD-specific gate was intended to be bypassed. However, the system initially placed no orders. Several defensive layers originally tuned for GBPUSD were rejecting EURUSD setups. The first issue was the gate threshold. I had set it to zero in the .env file, but the startup batch file contained another value that overrode it. I corrected the batch-file setting. The second issue was the Ollama avoidance profile. A classifier trained around GBPUSD conditions was incorrectly identifying EURUSD setups as situations to avoid. I increased the avoidance threshold from 0.60 to 0.90. The third issue was a timing-avoidance condition hard-coded into the application. The condition remained active even after the currency pair was changed. I moved it into an environment variable so that it could be adjusted separately for EURUSD. Finally, I terminated the old process still running with the previous configuration and restarted the system cleanly. Only then did the EURUSD grid orders appear. The first live order was a 0.01-lot BUY STOP near 1.14. The forward test had begun. This Is Not Yet a Success Story Positive backtest results do not prove that the migration has succeeded. A profit factor around 1.18 is not large. A small amount of slippage, worse execution, or spread expansion could remove the edge. The test period may also be too short. EURUSD could eventually experience the same regime instability that damaged GBPUSD. For that reason, I will not judge the new version by win rate alone. I will track actual spread, slippage, average winning pips, average losing pips, maximum favorable excursion, maximum adverse excursion, one-sided fill frequency, two-sided fill frequency, holding time, time-of-day expectancy, and the gap between backtest and live results. The most important question is whether the average live winning distance remains large enough. A narrow spread cannot save the strategy if live execution reduces the winning distance again. What the Five-Bot Test Really Showed The five bots lost a combined ¥542 on July 20. By itself, that could be treated as one ordinary losing day. The deeper GateGrid AI investigation produced a more useful lesson. Better entries can improve a strategy. Better exits can improve a strategy. A larger AI model can improve a strategy. But those statements only hold when the underlying structure still contains a predictable edge. When the combination of payoff structure and transaction cost makes the expected value negative, a smarter model may never be enough. Exit logs are still necessary. Entry models still need testing. Risk controls still matter. But before continuing to optimize them, it is worth checking whether the strategy can mathematically survive on the current currency pair. Five numbers reveal much of the answer: Average win, average loss, required win rate, actual win rate, and spread. The final response to the July 20 loss was not a more intelligent entry rule or a more complicated exit rule. I stopped trying to repair a version of the strategy that could not overcome its own cost structure. I kept the underlying logic, abandoned GBPUSD, and moved the live test to EURUSD. The next question is not whether EURUSD can produce a few profitable days. It is whether the small edge found in testing can survive real spreads, real slippage, and real execution. 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