AI FX Bot Lab: Real Trading Experiments

ConclusionAugust 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: -¥252Today’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 AIGateGrid 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 BotBoundSniper 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.LLMBridgeTraderLLMBridgeTrader 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_ScoreAnalystML_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.MAribbonTraderMAribbonTrader 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 Bot2BoundSniper 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 ThoughtsAugust 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

ConclusionThe 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: -¥251Today’s Theme: A Bot Can Lose Often Without Losing BigGateGrid’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 AIGateGrid 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 BotBoundSniper 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.LLMBridgeTraderLLMBridgeTrader 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_ScoreAnalystML_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.MAribbonTraderMAribbonTrader 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 Bot2BoundSniper 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.SummaryAugust 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 NoteGateGrid 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

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 yenToday’s Theme: A Good AI Exit Does Not Need to Be PrettyLLM 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 ThroughGateGrid 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 CleanBoundSniper 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 RecoverLLMBridgeTrader 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 WinML_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 NegativeMAribbonTrader 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 TimeNo 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 ThoughtsThe 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

ConclusionThe 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 yenThe 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 SeparateThese 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 AIGateGrid 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 BotBoundSniper 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.LLMBridgeTraderLLMBridgeTrader 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_ScoreAnalystML_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.MAribbonTraderMAribbonTrader 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 Bot2Bot2 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.SummaryThe 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

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.ConclusionThe 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 yenToday’s Theme: The Exit Rule Mattered More Than the Entry ModelMAribbonTrader 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 AIGateGrid 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 FamilyThe 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.LLMBridgeTraderLLMBridgeTrader 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_ScoreAnalystML_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.MAribbonTraderMAribbonTrader 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-upThe 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 NoteMAribbonTrader 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