AI FX Bot Lab: Real Trading Experiments

About AI FX Bot Lab: Real Trading Experiments

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 (https://fxaibotlab.substack.com?utm_medium=podcast)

Publisher

Kimi | Japan FX Bot Lab

Category

business · news

Language

en

Explicit

No

First episode

17 May 2026

Latest episode

26 Aug 2026

Latest episodes

71 episodes in the feed.

1. 

   26 Aug 2026

   Five Winning Trades Were Erased by One Stop: Exit Size Ruled the Day

   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 (https://fxaibotlab.substack.com/subscribe?utm_medium=podcast&utm_campaign=CTA_2)

2. 

   24 Aug 2026

   34 Losing Legs, Yet a 1.27 Payoff Ratio: GateGrid’s Loss Wasn’t the Scariest One

   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 (https://fxaibotlab.substack.com/subscribe?utm_medium=podcast&utm_campaign=CTA_2)

3. 

   22 Aug 2026

   One Small Loss Was Enough: LLMBridgeTrader Led the Six Bots With a 4.18 Payoff Ratio

   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 (https://fxaibotlab.substack.com/subscribe?utm_medium=podcast&utm_campaign=CTA_2)

Contact AI FX Bot Lab: Real Trading Experiments

Guest appearances

Does not typically book guests

Based on episode analysis; this does not confirm that the show is currently accepting guests.