AI FX Bot Lab: Real Trading Experiments

Kimi | Japan FX Bot Lab
  • 0.0 (0)
  • Tech News
  • Updated Daily

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

  1. Weekly Report: The One Loss That Mattered More Than All the Wins

    2d ago

    Weekly Report: The One Loss That Mattered More Than All the Wins

    From July 6 to July 10, 2026, I continued running four MT5 automated trading bots in parallel. The four systems were: * GateGrid AI * BoundSniper Bot * LLMBridgeTrader * MLScore GF-T4 GB The combined realized result for the week was -3,060 yen. On paper, it was simply a losing week. But when I reviewed the logs, the total loss itself was not what stood out most. The bots did not struggle to win trades. In fact, there were several days when the number of winning trades looked fairly strong. And yet, the account still lost money. That gap appeared again and again throughout the week. The real issue was not how often the bots won. It was how much they gave back when they lost. July 6: A difficult start to the week The result for July 6 was -1,976 yen. The combined record was 1 win and 10 losses. It was the worst day of the week. LLMBridgeTrader recorded the only winning trade, while GateGrid AI lost 733 yen and MLScore lost 621 yen. The directional calls were not good, but the larger problem was how long some losing positions remained open. Instead of exiting when the trade idea began to fail, the bots often waited until the loss had already grown. The weakness in the exit logic was visible from the very first day. July 7: Thirteen wins, but only 276 yen in profit The result for July 7 was +276 yen. The combined record was 13 wins and 3 losses. At first glance, that looks like an excellent day. However, the payoff ratio was only 0.31. There were very few losing trades, but each loss was much larger than each win. As a result, 13 winning trades produced only a small net profit. GateGrid AI is the clearest example. It won 8 of its 11 trades. Even so, it finished the day at -230 yen. Eight small wins were erased by three larger losses. Looking only at the win count, I might have concluded that the bot was performing well. In reality, the structure was fragile. As long as the bot kept collecting small gains, the weakness remained hidden. Once a deeper loss appeared, most of the previous profits disappeared. July 8: More wins than losses, but still negative The result for July 8 was -620 yen. The combined record was 9 wins and 7 losses. Again, the number of winning trades was higher than the number of losing trades. But the day still ended in the red. The biggest factor was a single -418 yen loss from BoundSniper. Small profits from the other trades could not absorb one large loss. This was another reminder that win count alone says very little about the actual health of a trading system. July 9: One loss erased everything The result for July 9 was -481 yen. There were only three trades in total, with 2 wins and 1 loss. It was a quiet day. However, the single losing trade came from GateGrid AI and cost 542 yen. That one loss erased all the small profits produced by the other bots. Two out of three trades were correct. The day still ended negative. This shows why improving directional accuracy alone is not enough. The more important question is how cheaply the system can exit when it is wrong. July 10: MLScore performed well, but the portfolio still fell short The result for July 10 was -259 yen. The combined record was 12 wins and 8 losses. MLScore GF-T4 GB closed two short positions at take profit and earned +483 yen. For this bot, it was one of the cleanest results of the week. However, the gains were not enough to cover the losses from the other systems. MLScore performed well on its own, but when four bots are running together, individual results are not the only thing that matters. I also need to watch how losses overlap across the portfolio. GateGrid AI: Winning often, but failing to keep the profit GateGrid AI showed the clearest weakness this week. On July 7, it won 8 of 11 trades. It still lost 230 yen. Then, on July 9, a single trade produced a 542 yen loss. The pattern is familiar. The bot collects many small gains, then gives them back in one deeper loss. The entry filters are not completely broken. In fact, many trades still close in profit. The problem begins after entry. When the market changes and the original setup loses validity, the bot often remains in the position for too long. Instead of making the entry logic even more complicated, the priority should be improving the conditions for early exit. BoundSniper Bot: One large loss can outweigh several clean trades BoundSniper Bot is a rule-based system that executes TradingView signals in MT5. On July 7, it produced a clean +200 yen result. On July 8, however, a single -418 yen stop loss pushed the day into negative territory, even though the bot won more trades than it lost. The system is consistent because it follows clear rules. But that strength can also become a weakness. When the market changes after the signal appears, the bot may continue holding the original idea without reassessing whether the setup still makes sense. The next step is not only to evaluate whether the initial signal was correct, but also whether the reasoning behind it remains valid after entry. LLMBridgeTrader: Small gains, but four consecutive profitable days The most interesting bot this week was LLMBridgeTrader. It lost 232 yen on July 6. After that, the daily results were: * July 7: +76 yen * July 8: +128 yen * July 9: +57 yen * July 10: +16 yen The gains were not large. Still, the bot remained profitable for four consecutive days. Compared with the other systems, LLMBridgeTrader was better at avoiding prolonged exposure to bad positions. It did not make money by holding one huge winner. It made money by cutting weak ideas before they became expensive. The result was modest, but its ability to preserve capital was the most stable among the four bots. MLScore GF-T4 GB: A promising result on the final day MLScore GF-T4 GB began the week with several losses, including the closing of older positions. However, on July 10, two short positions reached their take-profit targets and produced +483 yen. That gave a glimpse of the potential behind the machine-learning score. The model may be useful for identifying trade direction. Still, one good day is not enough to draw a conclusion. I need more trades to determine whether high-score setups consistently produce better results. I also need to review whether the current stop-loss and take-profit settings match the price behavior after entry. The real problem was not the entry When building an automated trading bot, it is easy to focus on entry accuracy. Add another filter. Use more training data. Change the model. Make the conditions more precise. I have spent plenty of time improving entries. But this week’s results suggest that the main weakness is no longer the entry alone. On July 7, the bots recorded 13 wins and 3 losses. On July 8, they recorded 9 wins and 7 losses. On July 9, they recorded 2 wins and 1 loss. None of those days looked terrible from a win-count perspective. Yet the final weekly result was -3,060 yen. That means the bots are not completely failing to predict direction. The problem is structural. The average gain is too small. The average loss is too large. Until that relationship changes, increasing the number of winning trades will not create stable profits. Knowing when an idea has expired Every trade begins with some kind of reasoning. A trend may be developing. A breakout may have occurred. The AI may have produced a buy signal. The machine-learning score may have been high. But the original reason for entering may no longer be valid ten or thirty minutes later. If the market changes and the bot continues holding based only on the original signal, the position becomes attached to outdated information. The goal should not be to defend the original prediction. The goal should be to exit cheaply when the original assumption is no longer supported. A fixed stop loss may not be enough. Time in the trade, fading momentum, acceleration in the opposite direction, conflict with a higher timeframe, and changes in volatility may all be useful exit signals. The system needs a way to reassess the trade after entry. Next week: Improving the exit rules I do not plan to explain this week’s losses as a simple failure of entry accuracy. The next improvements will focus on: * Exiting before unrealized losses grow too large * Reassessing whether the original setup is still valid after entry * Handling positions that fail to move within a certain amount of time * Separating situations where profits should be extended from situations where they should be secured early * Adjusting the acceptable loss size for each bot Losing trades are painful, but they are often the most honest source of information about a system. This week was not only about failing to win. It was about failing to keep the profits that had already been earned. Before trying to increase the number of entries, I need to reduce the damage caused by each losing trade. That will be the main focus of next week’s development and testing. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

    2 min
  2. [AI Trading Log] Why a Win Rate Over 60% Isn’t Enough: The Heavy “Cost of Retreat” Shown in July 9-10 Tests

    3d ago

    [AI Trading Log] Why a Win Rate Over 60% Isn’t Enough: The Heavy “Cost of Retreat” Shown in July 9-10 Tests

    I am currently running four MT5 automated trading bots (GateGrid AI, BoundSniper, LLMBridgeTrader, and MLScore GF-T4) simultaneously to verify their real-world behavior and performance. I have compiled the operational results for July 9 and 10. The harsh reality revealed by these two days of testing is that “no matter how high the win rate is, a single costly exit (stop loss) can destroy the portfolio.” Even though the overall win rate exceeded 60% on both days, they both ended with negative balances. Through a detailed review, I will delve into the challenges facing the current system. July 9 Analysis: The Day One Bad Exit Decided Everything [Overall Performance] * Total Trades: 3 (2 Wins, 1 Loss) * Win Rate: 66.7% * Realized Profit/Loss: -481 JPY (-496 JPY including MLScore’s unrealized loss) A Fatal Blow from GateGrid AI While BoundSniper (+4 JPY) and LLMBridgeTrader (+57 JPY) steadily accumulated small profits, GateGrid AI suffered a massive loss of -542 JPY in a single trade. A Warning from a 0.06 Payoff Ratio The total profit for the entire portfolio was a mere +61 JPY, whereas a single loss amounted to -542 JPY. The 66.7% win rate is entirely meaningless here. This extreme payoff ratio (risk-reward ratio) serves as a strong warning to the system that the “retreat rules” are too slow when an idea turns out to be wrong. July 10 Analysis: The Contrast Between Planned Take-Profits and Late Stop-Losses [Overall Performance] * Total Trades: 20 (12 Wins, 8 Losses) * Win Rate: 60.0% * Realized Profit/Loss: -259 JPY Trading volume increased on this day, clearly highlighting the differences in the “quality of exits” among the bots. Two Bots Shining with Great Exits * MLScore GF-T4 GB Successfully executed clean take-profits by precisely hitting pre-set targets (TP) twice, earning +483 JPY. * LLMBridgeTrader Despite having 1 win and 1 loss, it significantly extended its profits (+39 JPY) against its losses (-23 JPY), demonstrating a very healthy risk-reward payoff ratio of 1.70. Two Bots Dragging Down the Portfolio with “Small Profits, Large Losses” * GateGrid AI Despite a winning record of 7 wins and 6 losses, it totaled -602 JPY. Extremely small profits, such as +8 JPY, stood out against large stop-losses, peaking at -289 JPY. * BoundSniper Suffered significant damage of -380 JPY on its first trade. Although it attempted to recover with two subsequent wins, it couldn’t fully pay off the initial debt and ended at -156 JPY. Conclusion: What We Need Isn’t “New Predictions,” but “Rules to Accept Losses Cheaply” The biggest lesson from these two days is that “planned exits beat frequent decisions.” The AI models are already provided with sufficient market information, such as volatility, spreads, and the direction of higher timeframes, and their entry win rates are by no means bad. However, in the current system (especially GateGrid AI), the decision to recognize that an entry idea has “died” and to retreat is made far too late. The most crucial aspect of future system improvements is not giving the AI more information to increase entry accuracy. “How to abandon a wrong idea as cheaply (with as shallow a wound) as possible” Strictly enforcing this exit rule is the top priority for surviving in the market. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

    2 min
  3. Nine Wins Could Not Beat Seven Losses: The Payoff Ratio Dragged the Day Down

    5d ago

    Nine Wins Could Not Beat Seven Losses: The Payoff Ratio Dragged the Day Down

    The four-bot portfolio ended the day at -620 yen realized, with no open positions left at the report cutoff. The headline record was 9 wins and 7 losses, so the day was not simply a wipeout. That is what makes it a little more annoying. More wins than losses, yet still a red result. The total gross profit was +961 yen, while gross loss reached -1,581 yen. The payoff ratio came out to 0.47, and that is the number I kept coming back to. BoundSniper had the largest single loss at -418 yen, GateGrid AI had two heavy cuts after one clean win, and LLMBridgeTrader was the only bot that finished positive. MLScore GF-T4 GB had no trades, which honestly may have been the quietest result on the sheet. Bot-by-bot results ■ GateGrid AI -604 yenRecord: 1W / 2LWin rate: 33.3%Gross profit: +117 yenGross loss: -721 yenPayoff ratio: 0.32Max loss: -398 yen ■ BoundSniper Bot -144 yenRecord: 4W / 2LWin rate: 66.7%Gross profit: +278 yenGross loss: -422 yenPayoff ratio: 0.33Max loss: -418 yen ■ LLMBridgeTrader +128 yenRecord: 4W / 3LWin rate: 57.1%Gross profit: +566 yenGross loss: -438 yenPayoff ratio: 0.97Max loss: -195 yen ■ MLScore GF-T4 GB 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: N/ANote: No trades ■ Total -620 yen realizedRecord: 9W / 7LWin rate: 56.3%Gross profit: +961 yenGross loss: -1,581 yenPayoff ratio: 0.47Max loss: -418 yenFloating P/L: 0 yenEquity impact: -620 yen Today’s theme: the win count looked fine, the loss size did not Today was another reminder that a trading bot can be directionally useful and still lose money if the sizing of wins and losses is off. The portfolio won more often than it lost. That should give some room to breathe, but the losses were too heavy for the winners to cover. The most awkward part was BoundSniper. It won 4 out of 6 trades and still finished at -144 yen because one USDJPY loss of -418 yen swallowed almost every small win around it. GateGrid AI had a simpler version of the same problem: one +117 yen win, followed by -323 yen and -398 yen. I saw that -398 yen and had the same reaction as the past few reports. The entry may not be the whole issue anymore. GateGrid AI: one early win, then the basket broke GateGrid AI had three closed GBPUSD trades. The first exit was +117 yen, which looked fine. Then the next two exits came in at -323 yen and -398 yen, leaving the bot at -604 yen for the day. This bot is built as a multi-filter grid system. CatBoost judges entry probability, then Ollama checks context such as ATR, spread, higher-timeframe direction, session, and recent performance before the grid is allowed to form. That design is supposed to reduce weak participation, and I still like the idea. But the realized results are again pointing toward exit handling, not only entry filtering. The two losing closes were much larger than the one win. The average win was 117 yen, while the average loss was 360.5 yen. A payoff ratio of 0.32 does not leave much room for error. If the grid is going to take small profits, it needs a sharper way to say the setup has failed before the loss reaches three times the normal winner. BoundSniper Bot: good win rate, one loss did too much damage BoundSniper Bot closed six USDJPY trades and won four of them. The winning trades were +128 yen, +50 yen, +42 yen, and +58 yen. The losses were -418 yen and -4 yen. The result was -144 yen. This one stung in a different way. A 66.7% win rate should not automatically end red, but the largest loss was almost exactly the size of the four winners combined. That -418 yen trade did the damage. The final -4 yen loss was basically noise; the day was decided by the bigger miss. BoundSniper is a TradingView execution bridge rather than an AI decision system. It receives signals and sends them to MT5, so the key question is upstream exit design. The bridge worked. The trade logic it carried allowed one losing idea to sit too deep. LLMBridgeTrader: the only positive bot, but still not clean LLMBridgeTrader finished at +128 yen on EURUSD. It closed 7 trades, with 4 wins and 3 losses. The winners were +206 yen, +128 yen, +130 yen, and +102 yen. The losses were -115 yen, -128 yen, and -195 yen. This was the best-shaped bot of the day, even though it was not flawless. The payoff ratio was 0.97, which is close to balanced, and the win rate was 57.1%. Compared with GateGrid and BoundSniper, the losses were not wildly larger than the wins. The -195 yen loss was still noticeable, but it did not erase the whole day by itself. Because this bot asks the LLM for OPEN, HOLD, CLOSE, REVERSE, confidence, setup type, and SL/TP ideas, I care less about whether it wins one trade and more about whether it can keep its decision cycle stable. Today, it did that better than the others. Not perfect, but less lopsided. MLScore GF-T4 GB: no trades, no new information MLScore GF-T4 GB had no trades today. That means no realized profit, no realized loss, and no floating position. There is not much to analyze from the daily report. Still, “no trade” is not meaningless in a multi-bot setup. After several days where single large losses had a strong effect, sitting out can be a valid result. I cannot credit the bot for avoiding a specific bad setup without the signal log, but the account did not take damage from this lane today. Closing thoughts Today’s total loss was not huge, but the structure was familiar. More wins than losses, yet the day ended red. That is usually not a mystery. It means the system is paying too much when it is wrong. LLMBridgeTrader was the only bot that produced a healthier balance between wins and losses. GateGrid AI and BoundSniper both showed the same uncomfortable pattern from different architectures: small wins, one or two outsized hits. The lesson is getting less subtle now. The next improvement is probably not “find more entries.” It is making the bad exits less expensive. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

    2 min
  4. One Win, Ten Losses: The Exit Problem Was No Longer Subtle

    6d ago

    One Win, Ten Losses: The Exit Problem Was No Longer Subtle

    Today was not a day where the numbers needed much interpretation. Across the four bots, the closed trades came out to 1 win and 10 losses, with realized P/L at -1,976 yen. MLScore GF-T4 GB also left one GBPJPY short open at -109 yen, so the equity impact was -2,085 yen. That is not a huge amount in absolute scale, but the shape of it was uncomfortable. The only winning closed trade came from LLMBridgeTrader. Even there, the bot finished negative because the win was surrounded by six smaller losses. GateGrid AI and BoundSniper both had no winning exits at all, and MLScore started the day by realizing a large loss from a prior position. I do not want to dress this up too much. The day was mostly about failed exits, weak reversal timing, and trades that stayed wrong long enough to matter. Bot-by-bot results ■ GateGrid AI -733 yenRecord: 0W / 2LWin rate: 0.0%Gross profit: 0 yenGross loss: -733 yenPayoff ratio: N/AMax loss: -403 yen ■ BoundSniper Bot -390 yenRecord: 0W / 1LWin rate: 0.0%Gross profit: 0 yenGross loss: -390 yenPayoff ratio: N/AMax loss: -390 yen ■ LLMBridgeTrader -232 yenRecord: 1W / 6LWin rate: 14.3%Gross profit: +130 yenGross loss: -362 yenPayoff ratio: 2.15Max loss: -80 yen ■ MLScore GF-T4 GB -621 yenRecord: 0W / 1LWin rate: 0.0%Gross profit: 0 yenGross loss: -621 yenPayoff ratio: N/AMax loss: -621 yenOpen position: -109 yen floating P/L ■ Total -1,976 yen realizedRecord: 1W / 10LWin rate: 9.1%Gross profit: +130 yenGross loss: -2,106 yenPayoff ratio: 0.62Max loss: -621 yenFloating P/L: -109 yenEquity impact: -2,085 yen Today’s theme: the bots did not just lose, they failed to stop the bleeding There are bad days where the market simply does not fit the strategy. Today felt a little different. GateGrid AI waited for its sell stops, got filled, and then both positions were closed several hours later for -330 yen and -403 yen. Seeing two losses and no offsetting wins is simple enough, but the long hold before the close is what caught my eye. The LLM-driven side was also not clean. LLMBridgeTrader did produce the only winner of the day at +130 yen, which kept its payoff ratio above 2.0. But one strong exit cannot carry a sequence of six losses. The issue was not that every decision was poor. It was that the system kept finding new reasons to re-enter and then accept small damage again and again. GateGrid AI: two trades, both wrong, no recovery GateGrid AI took two GBPUSD sell entries in the morning and closed both in the afternoon. The final result was -733 yen, split into -330 yen and -403 yen. No winners, no partial recovery, no balancing trade. The -403 yen loss made me pause, because this bot has already shown that a single larger cut can wipe out a cluster of small wins on other days. This bot is built to avoid weak entries. CatBoost filters the entry probability, while Ollama checks context such as ATR, spread, higher-timeframe trend, session, and recent performance. That design should reduce random exposure, but today it did not protect the exit. The sell idea stayed alive too long, or at least long enough for both positions to close at a size that hurt. I am not sure yet whether the fix is earlier basket-level cancellation, a tighter emergency exit, or a more aggressive reversal check. The logs would need to confirm that. Still, from the realized result alone, the weak spot looks closer to “when to abandon the grid” than “whether the first sell stop was reasonable.” BoundSniper Bot: one TradingView signal, one full loss BoundSniper Bot had only one USDJPY trade. It bought at 162.314 and closed at 162.119, ending at -390 yen. With one trade, there is not much statistical meaning to pull out, but the loss size is worth noting. BoundSniper is not an AI decision bot. It receives TradingView alerts, passes them through the local webhook setup, and sends the order to MT5. That means today’s result mainly reflects the upstream TradingView rule and its exit timing. The bot did its job as an execution bridge, but the strategy behind the signal did not get out cheaply. This is the awkward part of automation. A bridge can be technically correct and still transmit a bad trade perfectly. LLMBridgeTrader: one good win buried under six cuts LLMBridgeTrader was the busiest bot today. It closed seven EURUSD trades: one win at +130 yen and six losses totaling -362 yen. The final realized result was -232 yen. The payoff ratio was 2.15, which is not bad by itself, but the win rate was only 14.3%. That mismatch tells the story. This bot asks the LLM to make a broader trading plan. It does not only return BUY, SELL, or NONE. It also decides whether to OPEN, HOLD, CLOSE, or REVERSE, and provides confidence, setup type, SL/TP width, and reasoning. Today, the wider decision space may have created too many new attempts. Some losses were small, but repeated small losses still become a real daily hit. The +130 yen exit shows that the model can catch a useful move. The problem is selectivity. It needs to be more willing to say NONE after a failed idea, or to wait longer before trying the next setup. That is my read for now, not a final diagnosis. MLScore GF-T4 GB: the largest realized loss, then an open short left behind MLScore GF-T4 GB realized -621 yen early in the day. The profit column showed -601 yen, and swap added another -20 yen. Later, it opened a new GBPJPY short that remained open at the report cutoff with -109 yen floating P/L. The closed side alone was already the largest single realized loss of the day. Because there was only one closed trade, I do not want to overfit the analysis. Still, the size matters. A max loss of -621 yen is larger than the entire realized loss of LLMBridgeTrader, despite LLMBridgeTrader taking seven closed trades. That makes the risk profile feel uneven. The new short position might recover later, but at the cutoff it was not helping. For this bot, the next thing to watch is whether the SL-side exit is too heavy relative to the expected TP. If the winner target is not large enough to pay for this kind of loss, the math stays fragile. Closing thoughts Today’s log was blunt. GateGrid AI missed twice. BoundSniper took one clean hit. LLMBridgeTrader had one good exit but kept paying for retries. MLScore carried the largest realized loss and still had an open drawdown. The useful part is that the weakness is visible. This was not a mysterious day hidden behind a decent win rate. It was 1 win and 10 losses, with the exits doing most of the damage. Sometimes the honest read is the shortest one: the bots did not need more confidence today. They needed fewer second chances. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

    10 min
  5. A 93.3% Win Rate Still Wasn’t Enough: The Week Exit Discipline Took Over the Story

    Jul 5

    A 93.3% Win Rate Still Wasn’t Enough: The Week Exit Discipline Took Over the Story

    Conclusion The week ended at -2,007 yen, and the uncomfortable part is that the bots were not simply “bad at trading.” They found plenty of winning trades. GateGrid AI even had a day with a 93.3% win rate, which sounds almost too clean. But that number did not protect the portfolio. The real problem was exit quality. Across the week, several bots showed the same pattern: small wins piled up, then one oversized loss cut through the progress. I do not think the lesson is “the entries failed.” The sharper lesson is that an automated strategy can be directionally right often enough and still lose money if it does not know when the original idea has expired. Bot-by-bot weekly performance ■ GateGrid AIMain pair: GBPUSDWeekly theme: high win rate, weak loss controlNotable result: 93.3% win rate on June 30Key loss: -729 yen on June 29Main issue: one large grid loss erased many small wins ■ BoundSniper BotMain pair: USDJPYWeekly theme: execution was fine, signal-side exit risk was notNotable result: positive day on July 2 despite only 25.0% win rateKey loss: -771 yen on June 30Main issue: one late exit damaged the full portfolio ■ LLMBridgeTraderMain pair: EURUSDWeekly theme: strong planning when right, slow CLOSE when wrongNotable result: 6 wins out of 6 on July 1, +710 yenKey issue: holding losing ideas too long on weaker daysMain issue: AI needs better judgment for switching from HOLD to CLOSE ■ MLScore GF-T4Main pair: GBPJPYWeekly theme: low trade count, but open risk mattersNotable result: 0 yen realized on July 3Open risk: -211 yen unrealized loss on July 3Main issue: realized P/L alone did not show the actual account risk ■ Weekly totalPeriod: June 29–July 3Total realized result: -2,007 yenMain theme: exit discipline mattered more than entry accuracyMost uncomfortable pattern: high win rate did not prevent lossesNext focus: max-loss rules, earlier exits, and stricter trade invalidation Today’s, or rather this week’s, theme This week made the win rate feel a little dangerous. It is an easy number to like. It gives a sense of control. But the logs kept showing the same contradiction: the bots were often right, yet the account still moved in the wrong direction. June 29 was the first warning. GateGrid AI had an 80.0% win rate and still finished at -400 yen because one -729 yen loss overpowered the smaller wins. I stopped on that number for a moment, because it is the kind of trade that makes every clean entry before it feel smaller than it looked. June 30 made the point even harder. GateGrid AI produced 14 wins and only 1 loss, ending at +442 yen. But BoundSniper took a -771 yen hit, and the whole portfolio closed at -974 yen. That is the week in one sentence: one bot can behave well, and another bot’s exit can still decide the day. GateGrid AI GateGrid AI gave the clearest example of the win-rate trap. On some days it looked almost too good. A 93.3% win rate on June 30 is not something I want to dismiss. The CatBoost gate and Ollama judgment layer were clearly finding trades that could close green. But the bad days were not small. June 29 had the -729 yen loss. July 2 ended with GateGrid AI down -845 yen despite winning 15 out of 23 trades. The problem was not a lack of winning trades. It was the size of the losing side. For a grid-style bot, this is the oldest problem in the room: where do you give up? GateGrid AI is designed to avoid low-quality entries, and that still matters. But this week showed that “not entering badly” is only half the job. The other half is cutting the structure before the grid becomes a stubborn position. BoundSniper Bot BoundSniper Bot is simpler in design. It does not predict the market by itself. TradingView sends the signal, the webhook path passes it through, and MT5 executes. So when BoundSniper has a bad result, I look less at the execution engine and more at the signal and exit rules sitting upstream. The contrast was sharp. On July 2, BoundSniper had only a 25.0% win rate, but still ended slightly positive at +14 yen because the payoff ratio was strong. That was a useful reminder: a low win rate is not automatically bad if the losses are controlled and the winners have room. Then there was June 30. The -771 yen loss was too large for the role this bot should be playing in the portfolio. It felt less like a normal loss and more like a rule boundary being too loose. The fix is probably not in the webhook layer. It is in the TradingView-side stop, exit, or invalidation logic. LLMBridgeTrader LLMBridgeTrader had the most interesting week from an AI-experiment point of view. On July 1, it went 6 for 6 and made +710 yen. That is the version of the bot I want to study carefully, because the AI was not only entering. It was managing position actions through OPEN, HOLD, CLOSE, and sometimes REVERSE logic. But the same freedom can cut both ways. On weaker days, the bot seemed too willing to keep holding after the trade idea had started to fail. This is where LLM trading becomes less about prediction and more about self-correction. The main question for LLMBridgeTrader is not “can the model find a setup?” It can. The question is whether it can admit the setup is no longer valid. That is a harder judgment, and probably the one that matters more in live trading. MLScore GF-T4 MLScore GF-T4 did not dominate the week by trade count, but it gave an important reminder on July 3. The realized P/L was 0 yen, which looks harmless on a closed-trade report. But there was a -211 yen unrealized loss sitting in the open position. That is not just a footnote. In automated trading, open risk is still part of the result, even if the statement does not force you to count it yet. A system can look flat or even green in realized terms while carrying risk that will land in the next day’s report. I do not want to overjudge the bot from one open position. Still, it changes how I want to write these logs. From now on, realized P/L alone is not enough. Open positions need to be treated as part of the daily and weekly story. Summary The week did not say, “the bots cannot win.” It said something more annoying: they can win often and still lose overall. That is a harder problem, because it means the entry layer is not useless. It is just not enough. The next upgrade should not chase a prettier win rate. It should focus on max-loss limits, faster invalidation, and stricter exit rules. GateGrid AI needs clearer grid surrender conditions. BoundSniper needs tighter signal-side damage control. LLMBridgeTrader needs a better way to switch from HOLD to CLOSE when the market stops agreeing. MLScore GF-T4 needs open-risk visibility baked into the review. The week’s loss was -2,007 yen. Small in scale, maybe. But the lesson was not small at all. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

    2 min
  6. A 65.2% Win Rate Still Lost Money: The Exit Logic Broke First

    Jul 2

    A 65.2% Win Rate Still Lost Money: The Exit Logic Broke First

    The biggest result today was not the total loss itself. It was the shape of the loss. GateGrid AI won 15 out of 23 closed trades, which looks fine at first glance, then ended the day at -845 yen. I had to stop for a moment when I saw that number next to a 65.2% win rate, because this is exactly the kind of result that makes win rate feel comforting and dangerous at the same time. Across the four bots, the realized result was -868 yen. If I include the open EURUSD position held by LLMBridgeTrader at -60 yen, the equity impact was -928 yen. BoundSniper and LLMBridgeTrader both finished positive on realized P/L, but the day was still decided by GateGrid’s heavier losing exits. The issue does not look like entry frequency alone. It looks more like the point where the system stops holding, cuts, flips, or unwinds. Bot-by-bot results ■ GateGrid AI -845 yenRecord: 15W / 8LWin rate: 65.2%Gross profit: +873 yenGross loss: -1,718 yenPayoff ratio: 0.27Max loss: -408 yen ■ BoundSniper Bot +14 yenRecord: 1W / 3LWin rate: 25.0%Gross profit: +102 yenGross loss: -88 yenPayoff ratio: 3.48Max loss: -70 yen ■ LLMBridgeTrader +29 yenRecord: 2W / 1LWin rate: 66.7%Gross profit: +121 yenGross loss: -92 yenPayoff ratio: 0.66Max loss: -92 yenOpen position: -60 yen floating P/L ■ MLScore GF-T4 GB -66 yenRecord: 1W / 1LWin rate: 50.0%Gross profit: +250 yenGross loss: -316 yenPayoff ratio: 0.79Max loss: -316 yen ■ Total -868 yen realizedRecord: 19W / 13LWin rate: 59.4%Gross profit: +1,346 yenGross loss: -2,214 yenPayoff ratio: 0.42Max loss: -408 yenFloating P/L: -60 yenEquity impact: -928 yen Today’s theme: the entry was not the only decision I usually look at these bots through the lens of whether the model entered too early, too late, or not at all. Today pushed me back toward a less comfortable place: exit quality. A system can be right often enough and still bleed if the average winner is too small and the losing trades are allowed to stretch. GateGrid AI is the cleanest example. It uses CatBoost as the first gate, then Ollama as the second layer of judgment, with ATR, spread, session, recent win rate, recent P/L, and higher-timeframe trend information in the prompt. That design is meant to avoid bad entries, and in a narrow sense it did not look terrible. But the payoff ratio was only 0.27, which is hard to ignore. The bot was taking small wins, then giving back several of them in one wider loss. GateGrid AI: good hit rate, poor damage control GateGrid AI closed 23 trades, with 15 winners and 8 losers. The winners added up to +873 yen, while the losers totaled -1,718 yen. That imbalance says more than the win rate. The average win was 58.2 yen, and the average loss was 214.8 yen. When I see -408 yen as the largest single loss, it feels less like one unlucky print and more like a warning about the exit band. This bot is built around selective participation. CatBoost screens the market, Ollama judges the risk context, and the grid parameters adapt around volatility. The problem today was not that it traded blindly all day. It was that once several baskets turned against it, the realized cuts were too large compared with the clipped profits. I do not want to overstate it from one day of data, but the exit side is probably where the next adjustment belongs. BoundSniper Bot: ugly win rate, better trade math BoundSniper Bot had the opposite personality today. It won only 1 of 4 trades, which looks weak, but still ended at +14 yen. The one winning trade was +102 yen, while the three losses were small: -6, -12, and -70 yen. A 25.0% win rate is not pleasant to look at, but the payoff ratio was 3.48, and that gave the bot room to survive. This bot is not trying to think. TradingView sends the signal, the local webhook receives it, and MT5 executes. In that sense, the result is more about whether the upstream TradingView logic kept the losses tight enough. Today it did. I would not call this strong performance, but the loss design was healthier than GateGrid’s. LLMBridgeTrader: realized profit, but one open question remains LLMBridgeTrader closed 3 trades: +52 yen, -92 yen, and +69 yen. Realized P/L was +29 yen, with a 66.7% win rate and a payoff ratio of 0.66. On the surface that is fine, but the bot also carried one open EURUSD buy position with -60 yen floating P/L at the report cutoff. This bot gives the LLM a wider role. It does not only ask for BUY, SELL, or NONE. It also asks whether to OPEN, HOLD, CLOSE, or REVERSE, together with confidence, setup type, SL pips, TP pips, and the reasoning behind the plan. That makes today’s open position interesting. The realized trades were controlled, but the real test is whether the model knows when HOLD stops being patience and starts becoming delay. I do not have enough from this report alone to judge that last position, but that is exactly where the experiment lives. MLScore GF-T4 GB: one swap-hit loss erased the clean TP MLScore GF-T4 GB had only two closed outcomes. One was a stop-side close with swap included at -316 yen, and the other was a take-profit at +250 yen. The final result was -66 yen. It is a small daily loss, but the structure is plain: one heavier losing close outweighed the clean winner. A 50.0% win rate with a 0.79 payoff ratio is not broken beyond repair, but it does not leave much margin. The bot needs either a slightly larger average winner, a smaller stop-side loss, or fewer swap-damaged exits. The +250 yen TP was not bad. It just did not fully pay for the earlier damage. Closing thoughts Today’s log made the same point in four different accents. BoundSniper showed that a low win rate can survive when the losing trades stay small. GateGrid showed that a high win rate can still lose when one exit absorbs several wins. LLMBridgeTrader stayed positive on realized trades, but the open position is the part I want to watch next. For these LLM and ML-driven MT5 bots, the question is not only “was the entry intelligent?” The harder question is whether the system knows when the original idea has expired. Today, that answer was mixed, and GateGrid paid the bill. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

    2 min
  7. One Bad Exit Defined the Day: Four MT5 LLM Bots on July 1

    Jul 1

    One Bad Exit Defined the Day: Four MT5 LLM Bots on July 1

    Conclusion The combined closed result was +528 yen, so the day ended positive. Still, the clean number hides the part I kept staring at: the largest single loss was -414 yen on BoundSniper. A day can finish green and still leave a clear warning mark. LLMBridgeTrader was the strongest performer, with six closed winners and no losing trade. GateGrid AI also ended positive, but its payoff ratio was only 0.31, which tells a different story from the surface result. MLScore GF-T4 GB slipped into a realized loss and still had one open GBPJPY short carrying a floating loss at the report cut-off. The theme today was not “how many trades won.” It was whether each bot knew when to stop holding. Bot-by-Bot Results ■ GateGrid AI +307 yenRecord: 13W / 3L / 1 flatWin rate: 81.3%Gross profit: +1,210 yenGross loss: -903 yenPayoff ratio: 0.31Max loss: -364 yen ■ LLMBridgeTrader +710 yenRecord: 6W / 0LWin rate: 100.0%Gross profit: +710 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen ■ MLScore GF-T4 GB -303 yenRecord: 1W / 2LWin rate: 33.3%Gross profit: +200 yenGross loss: -503 yenPayoff ratio: 0.80Max loss: -252 yenOpen position: -94 yen floating loss ■ BoundSniper -186 yenRecord: 3W / 1LWin rate: 75.0%Gross profit: +228 yenGross loss: -414 yenPayoff ratio: 0.18Max loss: -414 yen ■ Total +528 yenRecord: 23W / 6L / 1 flatWin rate: 79.3%Gross profit: +2,348 yenGross loss: -1,820 yenPayoff ratio: 0.34Max loss: -414 yenOpen position: -94 yen floating loss Today’s Theme: The Exit Was Louder Than the Entry Today was one of those sessions where the final P/L looks fine, but the structure feels uneven. The total closed result was positive, yet the payoff ratio for the whole group was only 0.34. That means the average winning trade was much smaller than the average losing trade. I do not want to overreact to one day, but that number is low enough to make me slow down. The LLM-based bots are not only entry machines in this experiment. Especially for LLMBridgeTrader and GateGrid AI, I am watching whether the model or the surrounding logic can decide when to stop holding, when to close, and when to reverse. Today, the entry side was not the main concern. The exit layer was where the personality of each bot showed up. GateGrid AI GateGrid AI finished at +307 yen, which is a decent outcome on paper. But the path was not as comfortable as the headline result. The bot had 13 winning exits, 3 losing exits, and 1 flat exit, yet the payoff ratio stayed at 0.31. That usually means the system is collecting small pieces and occasionally giving back a large chunk. The -364 yen loss made me pause, because this pattern can look stable right until it is not. There was also a useful detail inside the loss structure. The large losing legs were partly offset by companion winners in the same grid cycle. For example, a -360 yen leg was softened by +203 yen and +155 yen exits, and later a -364 yen leg was offset by +214 yen and +158 yen. So the grid did not break; it absorbed. Still, absorption is not the same as control. The next improvement probably sits around how quickly the weak leg is cut, or whether the cluster should be closed earlier when one side starts dragging the whole basket. For a CatBoost plus Ollama design, this is exactly the kind of day worth logging. The model did enough to stay positive, but the exit rules were forced to carry the risk. I would not call it a bad day. I would call it a warning wrapped in a profit. LLMBridgeTrader LLMBridgeTrader was the cleanest bot today: +710 yen, six closed winners, no losing trade. The interesting part is that several exits were tagged as stop-related closes, but they ended in profit. That suggests the exit layer was not just cutting damage; it was locking in movement after the position had gone the right way. Because this bot gives the LLM a wider role, I care less about a single BUY or SELL call and more about the full plan: OPEN, HOLD, CLOSE, REVERSE, confidence, setup type, SL, TP, and the stated reason. Today, the realized result says the plan worked. I am still careful with that conclusion because there was no losing trade in the sample. A bot that never had to take a hit has not shown how it behaves under stress. Still, among the four bots, this one gave the least messy result. It did not need a huge move, and it did not need rescue trades. It simply kept taking profit. That is rare enough that I do not want to dress it up too much. MLScore GF-T4 GB MLScore GF-T4 GB ended with -303 yen realized, plus an open GBPJPY short carrying -94 yen of floating loss. This bot had one +200 yen winner and two losses around -250 yen each. The payoff ratio was 0.80, which is not terrible by itself, but with a 1W / 2L record it was not enough. The shape is simple and a bit frustrating. The winner was smaller than the combined damage, and the open position was not helping at the cut-off. The losses at -251 yen and -252 yen were almost identical, so this looks more like a fixed-risk structure than a chaotic failure. That can be improved, but only if the entry filter or exit timing earns enough winners to justify the stop size. My guess is that the issue is not only signal quality. The exit width may be too neat for the market it is facing. I am not fully sure yet, but the open short at the end made the day feel unfinished. BoundSniper BoundSniper is the most useful warning today. It closed three winners and one loser, yet still ended at -186 yen. The reason is blunt: the losing trade was -414 yen, while the three winners added only +228 yen together. When I saw that -414 yen cut, the first reaction was not dramatic; it was more like, “again, this shape.” This bot is not trying to predict the market by itself. It carries TradingView signals into MT5, so the key question is whether the execution and exit handling preserve the edge of the original strategy. Today, they did not. The winning trades were too small to pay for the one large loss. BoundSniper does not need a philosophical rewrite from this one day. It needs a sharper answer to one practical question: when a USDJPY move goes wrong, how long should the position be allowed to stay wrong? Until that is cleaner, even a good-looking sequence of trades can remain fragile. Summary The day ended positive, but the important lesson came from the red side of the ledger. LLMBridgeTrader was clean, GateGrid AI survived through basket behavior, MLScore needs a better balance between stop size and signal quality, and BoundSniper showed how one exit can outweigh several correct calls. I am keeping the focus on maximum loss and payoff ratio for the next run. Profit is nice, but the bot that teaches the most is often the one that makes the account feel slightly uncomfortable. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

    2 min
  8. A 93.3% Win Rate Still Wasn’t Enough

    Jun 30

    A 93.3% Win Rate Still Wasn’t Enough

    Four MT5 bot trade log for June 30, 2026 The strange part of today was not that the portfolio lost money. The strange part was that one bot won 14 out of 15 closed trades and the four-bot total still finished at -974 yen. I had to look at that twice, because a 93.3% win rate usually feels like the kind of number you want to keep. Today it was only enough to keep GateGrid AI green, not enough to save the whole board. The real theme was not entry accuracy. It was payoff ratio and max loss. Across all four bots, the average win was about 68 yen while the average loss was about 255 yen. That gap is not dramatic on one trade, but after 33 closed trades it starts to explain the day better than the win rate does. Bot-by-bot results ■ GateGrid AI +442 yenPair: GBPUSD-Record: 14W / 1LWin rate: 93.3%Gross profit: +775 yenGross loss: -333 yenPayoff ratio: 0.17Max loss: -333 yen ■ BoundSniper Bot -755 yenPair: USDJPY-Record: 5W / 3LWin rate: 62.5%Gross profit: +436 yenGross loss: -1,191 yenPayoff ratio: 0.22Max loss: -771 yen ■ LLMBridgeTrader -410 yenPair: EURUSD-Record: 4W / 5LWin rate: 44.4%Gross profit: +360 yenGross loss: -770 yenPayoff ratio: 0.58Max loss: -206 yen ■ MLScore GF-T4 GB -251 yenPair: GBPJPY-Record: 0W / 1LWin rate: 0.0%Gross profit: +0 yenGross loss: -251 yenPayoff ratio: 0.00Max loss: -251 yen ■ Total -974 yenPairs: GBPUSD- / USDJPY- / EURUSD- / GBPJPY-Record: 23W / 10LWin rate: 69.7%Gross profit: +1,571 yenGross loss: -2,545 yenPayoff ratio: 0.27Max loss: -771 yen Today’s theme Today was a clean reminder that a bot can be right often and still be fragile. GateGrid AI did the best job on the surface. It kept taking small GBPUSD wins, and most of those exits looked like the kind of grind a grid-style system is built for. But the payoff ratio was only 0.17, so the single -333 yen loss mattered a lot more than the win count made it feel. Seeing +775 yen of gross profit get cut down that quickly made me pause a little. BoundSniper Bot had a different problem. It won more than it lost by count, but the first closed loss came in at -771 yen including swap. That one number bent the entire day. Since BoundSniper is mainly the execution bridge for TradingView signals rather than a prediction engine, I do not read this as an MT5 delivery issue. The problem sits closer to the signal and exit design. LLMBridgeTrader was more interesting from the LLM experiment side. The losses were not huge individually, and the payoff ratio of 0.58 was the best among the losing bots. Still, it lost five of nine closed trades. When a bot is allowed to decide OPEN, HOLD, CLOSE, or REVERSE, the exit is not a small detail. It is the experiment. GateGrid AI GateGrid AI was the only clear winner today, finishing at +442 yen on GBPUSD-. Fourteen wins and one loss is a strong result, but I do not want to over-celebrate it. The average win was about 55 yen, while the only loss was -333 yen. That means one bad exit was roughly six average wins. The design did what it is supposed to do in one sense. It kept finding small harvests and avoided ending red. CatBoost and the local LLM filter are meant to reduce bad entries, and today the entry side looked decent. But the exit side still carries the risk. If the bot keeps a losing grid alive too long, the day can flip quickly. The uncomfortable lesson is that GateGrid AI may need to stay extremely selective. A win rate around 70% would not be enough with this payoff structure. Even 80% could be shaky. Today it survived because 93.3% is a very high bar, and that is not something I want to depend on every session. BoundSniper Bot BoundSniper Bot finished at -755 yen realized, with a separate open USDJPY short showing -90 yen floating loss at the report close. The closed-trade win rate was 62.5%, which sounds acceptable until the loss distribution shows up. The max loss was -771 yen, and another loss came in at -416 yen. The small wins, from +30 to +256 yen, could not repair that. This bot does not think through the market by itself. It receives TradingView signals and sends them to MT5. So when it loses this way, I look less at the transport layer and more at whether the TradingView-side exit is late, too wide, or too tolerant of reversal. The -771 yen loss is the number that bothered me most today. Not because it is huge in absolute terms, but because it tells me the bot can let one trade become the whole story. That is the part I would want to isolate before adjusting anything cosmetic. LLMBridgeTrader LLMBridgeTrader ended at -410 yen on EURUSD-. The bot had four wins and five losses, so it was not completely off, but it never found enough clean follow-through. The best thing in the data is that its max loss was -206 yen, much smaller than BoundSniper’s worst loss. The worse part is that it kept leaking. For an LLM-driven bot, I care less about whether one entry was clever and more about whether the model knows when to stop believing its first plan. Today, the exit decisions look mixed. Some losses were cut in a controlled range, but the sequence still says the bot was too willing to re-engage or stay wrong. The payoff ratio of 0.58 is not terrible compared with the other bots, but with a 44.4% win rate it was not enough. It needs either cleaner filtering before entry or better switching behavior after the position starts moving against the thesis. My guess is that the exit prompt and the HOLD-to-CLOSE threshold are more important than adding another indicator. MLScore GF-T4 GB MLScore GF-T4 GB had only one closed trade, a GBPJPY loss of -251 yen. That is too little data to judge the model. One stop-out can be noise, and I do not want to build a whole story around a single trade. Still, the clean loss is useful as a record. It did not snowball, and it did not stack positions. On a day where max loss shaped the portfolio, a single controlled loss is not the worst thing a bot can do. The next check is whether this bot tends to produce isolated losses or whether it clusters them. Today only tells me that the first attempt failed. I need more samples before I trust any conclusion. Wrap-up The total came in at -974 yen realized, even with a 69.7% combined win rate. That is the kind of day that makes the dashboard feel misleading if I only look at green and red trade counts. The bots were not all broken. The problem was that the losing trades were much heavier than the winning trades. For tomorrow, I would not start with the entries. I would start with the exits: BoundSniper’s worst-loss rule, LLMBridgeTrader’s CLOSE judgment, and GateGrid AI’s point of giving up on a grid. The trade log is saying one thing pretty clearly today: the bots can find wins, but the exits still decide whether those wins survive. This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

    2 min
See All (47)

About

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

Information

You Might Also Like